I suppose the kind of character traits that enable becoming super-rich probably also lend themselves to giving such talks.
Most sane people would stop working by the time they become rich, not super rich. To become a billionaire, your brain must be wired differently, and perhaps with unwavering conviction that you are right, righter than anyone else and the world owes you its attention.
"The reasonable man adapts himself to the world: the unreasonable one persists in trying to adapt the world to himself. Therefore all progress depends on the unreasonable man." -GB Shaw
I don't fully agree with the quotation from Shaw, but there's some truth to it. And I suspect a common quality of the billionaire class is ruthless unreasonableness -- and considerable luck.
My pet theory is that billionaire weirdness and AI psychosis have the same root cause: talk too much to sychophants and the human mind starts to go off the rails.
Without a reality check, the natural feedback loop that tells us we're wrong sometimes, the human mind starts to diverge into madness.
A few comments point out, and I agree, that setting up, never mind maintaining a webpage, has become a PITA:
- server (AWS? 10 optional services to config etc etc, config, updates etc)
- domain
- SSL cert
Are there solid providers who do it all-in-one? I pay one bill, get a domain, SSL certificate, renewed, and a managed, pre-configured Linux box, or even static hosting? Thinking of setting up a webpage for my consulting business and I'd rather not spend weeks fiddling with all this, or (shudder) use Wix.
Literally type "webhosting" into a search engine and every single provider that comes up will do that all-in-one. They'll also throw in a database and PHP, probably with an automatic installer for things like WordPress. There's a good chance your registrar will even try to upsell you the whole package.
Backblaze offers 10 GB of free storage and CloudFlare offers free data transfer from B2, with these two you can host a static site for free. I have a worker script that routes requests to the index page and sets cache headers for my site.
export default {
async fetch(req, env, ctx) {
// Cached response
let res = await caches.default.match(req);
if (res) return res;
// Fetch object from origin
let reqPath = new URL(req.url).pathname;
reqPath = reqPath.replace(/\/$/, ''); // Remove trailing slash
if (!reqPath.includes('.')) // Check file extension
reqPath += '/index.html'; // Default to index page
res = await fetch(env.ORIGIN + reqPath);
if (res.status === 404) // Object not found
res = await fetch(env.ORIGIN + '/404.html');
// Configure content cache
res = new Response(res.body, res);
const ttl = res.headers.get('content-type').startsWith('text')
? 14400 : 31536000; // Cache text 4 hours, 1 year default
res.headers.set('cache-control', 'public, max-age=' + ttl);
// Cache and return response
ctx.waitUntil(caches.default.put(req, res.clone()));
return res;
},
};
You can use GitHub pages. Or just set up one virtual server and host everything on it - I do that and it's pretty painless. The "10 services on AWS" is definitely the most painful way there is.
Providers like Netlify, Firebase Hosting, CloudFlare are much better value for money for features for maintenance. Static hosting means you don't need to update the server because there isn't one, and there are even free tiers below a certain usage.
There's still the usability thing, they're not made for non-techies. There's an assumption you'll use Git, etc. But there's no practical reason why Netlify CMS or similar couldn't handle everything.
I have actually been experimenting with this. And it's real simple.
I think for these cases everyone should be shooting for a static site. In which case it is:
1. Rent a vps
2. Buy a domain
3. Set up nginx or something else
4. Copy files to the right folder
5. Point a dns record to said server
6. Use certbot to get an ssl cert installed for you
It's not that hard for you... the process you just described is unintelligible for 99% of the population I would say. And then you have to produce the content on top of that.
NearlyFreeSpeech might be what you want. Been using them for over a decade and still love them. They handle domains/DNS, hosting (static and other), mysql hosting, email forwarding, and much more. They also have great content policies, ie they only kick you off if you're breaking the law.
This has always been the case, not sure why you’d frame it as a recent development. Not that long ago you even had to PAY for an SSL cert. Domains are nothing new. You always needed a server.
It hasn't. TLS was not needed until recently. Non-TLS sites used to show up in search results. TLS was not mandatory at all. Also ISPs often provided users with a free webspace. So I could just send 1 html file to my host without much technical knowledge and I had a website that people could visit.
I think sadly a lot of Python in the wild relies heavily, somewhere, on the crazy unoptimisable stuff. For example pytest monkey patches everything everywhere all the time.
You could make this clean break and call it Python 4 but frankly I fear it won't be Python anymore.
As a person who has spent a lot of time with pytest, I'm ready for testing framework that doesn't do any of that non-obvious stuff.
Generally use unittest as much as I can these days, so much less _wierd_ about how it does things. Like jeeze pytest, do you _really_ need to stress test every obscure language feature? Your job is to call tests.
Yeah, I've been thinking about how I'd do it from scratch, honestly. (One of the reasons Pytest could catch on is that it supported standard library `unittest` classes, and still does. But the standard library option is already ugly as sin, being essentially an ancient port of JUnit.)
I think it's not so much that Pytest is using obscure language features (decorators are cool and the obvious choice for a lot of this kind of stuff) but that it wants too much magic to happen in terms of how the "fixtures" automatically connect together. I would think that "Explicit is better than implicit" and "Simple is better than complex" go double for tests. But things like `pytest.mark.parametrize` are extremely useful.
Allowing metaprogramming at module import (or another defined phase) would cover most monkey patching use cases. From __future__ import python4 would allow developers to declare their code optimisable.
On aggregate, humans will engage in exactly as terrible and selfish behaviour as society lets them get away with, without fail. Murder, rape, theft are the way of nature. We don't need a spotlight to know this. The only thing we can do is use our collective power as a social species to shut down each type of harmful individual behaviour, which does not solve such behaviours completely but does drastically reduce them.
The discussion shows just how many different communication styles there are. So many comments about "XYZ is the right way", "ABC is always wrong" or "I did UV to someone who says they like UV and they took offence".
It shows me:
- there are many communication styles and people tend to think their preferred one is obviously right
- people are often unclear on what they actually value in communication (and might like the opposite of what they say they value)
- people seem also to, at times, confuse other people's different communication style for rudeness, indecisiveness or small-mindedness.
So I guess the reasonable policy is to adopt a hybrid approach. Be tolerant of other people's comms style, try to be concise with enough politeness added in that you don't offend people, even if they say they want you to be ruthlessly direct. When you need to, try to steer the conversation towards your preferred style. Maybe "ok, I understand the background, let's try to distill the facts now", or equally "I feel I need more context before we continue, let's slow down and...".
For example, I have worked in a number of medium sized (50-200) companies that were so proud of being flat structured meritocracies, where anyone can say anything directly to their superiors. Every single time it turned out to be BS, higher ups wanted deference and following chains of command. But that sounds less catchy.
Doesn't really answer you question but IME this is sort of unavoidable unless you're massive and you can afford to have people who just document this kind of stuff as their job.
Reason being, a lot of this stuff happens for no good reason, or by accident, or for reasons that no longer apply. Someone liked the tech so used it - then left. Something looked better in a benchmark, but then the requirements drifted and now it's actually worse but no one has the time to rewrite. Something was inefficient but implemented as a stop gap, then stayed and is now too hard to replace.
So you can't explain the reasons when much of the time there aren't any.
The non-solutions are:
- document the high level principles and stick to them. Maybe you value speed of deployment, or stability, or control over codebase. Individual software choices often make sense in light of such principles.
- keep people around and be patient when explaining what happened
- write wiki pages, without that much effort at being systematic and up to date. Yes, they will drift out of sync, but they will provide breadcrumbs to follow.
I'm not sure you can blame this on deities. Nazis and Stalinists (especially the latter) were very atheistic. Both at some level thought they're building a better world, literally by murdering millions of people and enslaving orders of magnitude more.
Most sane people would stop working by the time they become rich, not super rich. To become a billionaire, your brain must be wired differently, and perhaps with unwavering conviction that you are right, righter than anyone else and the world owes you its attention.
reply