I agree strong typing is a necessity in the front end. To prevent the language explosion issue, I recommend writing your single page apps in Java. The Flavour framework makes this quick and easy with complete maven tooling and powerful components.
There is research correlating autism and mothers taking certain medications (painkillers, antidepressants). Since autism is hereditary, there is a significant chance that these mothers are autistic too. Autistic people have a vastly high risk of depression, and often have unusual pain thresholds, requiring more painkillers. I would not be surprised of the correlation was real, but the direction of action was reversed; after all, it's plausible that autism causes the need for taking more medication.
What numbers are you seeing for the surpassing living standards? Their gpd per capita flatlined in 2024 at $13k. That's with only 80M of their citizens making above $2000/month. The bulk of their citizens make less than $100/month, and there's a declining middle class of around 200M that makes around $800/month. But they have high youth unemployment rate (>40%), there's a massive layoff wave coming in September with the mandatory social security payment from companies, and their recent factory wages have plummeted to $2/hour, barely survivable in first tier cities.
Before everyone jumps in with GDP per capital with PPP, what quality at that low price means is tofu dreg buildings, cancerous food items, waist high flooding every summer in cities, ghost buildings, and unsafe water (recently one of the most prosperous city, Hangzhou, had sewage seeped into the water for weeks, which the local government denied responsibility).
When you don’t need as many people because of automation, you also don’t need them to fight your wars. You use drones and other automated weapons. You don’t need things like democracy because that was to prevent people from turning to revolution, and that problem has been solved with automated weapons. So then you don’t really need as many people anymore, so you stop providing the expensive healthcare, food production, and water to keep them all alive
I have added what I think they call login alias to my account. This blocks logins using the normal account username (which is my public email address), and only allows them via the alias (which is not public and just a random string). Not a single foreign login attempt since I enabled the alias.
You can enable it on account.microsoft.com > Account Info > Sign-in preferences > Add email > Add Alias and make it primary. Then click Change Sign-in Preferences, and only enable the alias.
I'm reminded of the famous story of (I think) the central beam in a building at Oxford. The story goes something like:
The central beam was beginning to fail and the Oxford administration knew they needed to replace it. When they went around for quotes, no one could replace the beam because it was 100 ft in length and sourced from an old growth tree. Such logs were simply unavailable to buy. To solve the issue, the staff begin to look at major renovations to the building's architecture.
Until the Oxford groundskeeper heard about the problem. "We have a replacement beam," he said.
The groundskeeper took the curious admins to the edge of the grounds. There stood two old growth trees, over 150 feet tall.
"But these must be over 200 years old! When were they planted?" the admins asked.
I think that https://blessed.rs does a pretty good job of providing recommendations for things that probably can't be crammed into the standard library, but which you'll almost certainly end up needing at one point or another. I honestly like that system a lot, it makes it so that the only packages you need to worry much about are usually doing something rather specific.
The GAO wrote a report on fraud, waste, and abuse potential of Energy Star in 2010. They were able to get a gas-powered alarm clock (and 14 other fake products) marked as Energy Star compliant. Worth a read/laugh.
The one thing that sold me on Rust (going from C++) was that there is a single way errors are propagated: the Result type. No need to bother with exceptions, functions returning bool, functions returning 0 on success, functions returning 0 on error, functions returning -1 on error, functions returning negative errno on error, functions taking optional pointer to bool to indicate error (optionally), functions taking reference to std::error_code to set an error (and having an overload with the same name that throws an exception on error if you forget to pass the std::error_code)...I understand there's 30 years of history, but it still is annoying, that even the standard library is not consistent (or striving for consistency).
Then you top it on with `?` shortcut and the functional interface of Result and suddenly error handling becomes fun and easy to deal with, rather than just "return false" with a "TODO: figure out error handling".
Yes exactly - usually in Artifacts, which I then copy and paste into the GitHub web editor in order to ship them via GitHub Pages to https://tools.simonwillison.net/
> I wish there was an easy way for this - plug and play kinda
I can click a button in Lidarr to auth with Spotify and automatically search usenet for every album of every artist I follow on spotify, download them all, and make them available in Jellyfin. It'll even monitor the spotify account and import new additions. Getting the whole stack set up is pretty much the exact opposite of plug and play, but once you have it all installed it's amazing how much becomes smooth sailing. 2K songs is nothing for this kind of stack.
I've owned a Model 3 for years now, and FSD is scary as hell. We haven't paid for it -- and we won't -- but every time we get a free trial of it (mostly recently this past Fall), I give it a whirl, and I end up turning it off. Why? Because it does weird shit like slow down at an intersection with a green light. I don't feel like I can trust it, at all, and it makes me more anxious than just using standard auto-steer and cruise control (which still ghost breaks sometimes). I don't get why anyone uses FSD.
> It’s not like there are other contenders out there.
Apache Skywalking might be worth a look in some circumstances, doesn't eat too many resources, is fairly straightforwards to setup and run, admittedly somewhat jank (not the most polished UI or docs), but works okay: https://skywalking.apache.org/
Look at trajectories, think in systems. They are rapidly building a nation state clean energy electrical system, and when they're done domestically, these products will be exported globally.
I worked full time on a pretty seriously-trafficed product based on MongoDB for 3 years and I still don't know of anywhere I'd want to use MongoDB. I'd basically always want either a DB with a schema or a super fast opaque-store style cache.
Also, their hosted offerings (MongoDB Atlas) were not well operated and they took down our company for 2 days. Our MongoDB instance stopped accepting new connections and restarting our instance via their control panel didn't bring it back up and then their support literally said "we don't know why this happened or how to fix it" for like a day and a half, while we were on their highest tier ultra platinum support contract. Ultimately, we had to do 24 hours of research and then tell their own support how to fix the problem using their special shell access. If I recall correctly, it was some issue with WiredTiger (an internal component of the Mongo version we were using).
After that experience, I'd never use anything produced by MongoDB for anything; we moved everything that we possibly could out of Mongo and into more traditional RDBMS (PostgreSQL) and never had to deal with issues like that again.
If anyone is looking for a one click solution without having to have a Docker running, try Msty - something that I have been working on for almost a year. Has RAG and Web Search built in among others and can connect to your Obsidian vaults as well.
Here's the raw data of the top 10 models involved in fatal accidents according to the study.
1 Hyundai Venue
2 Chevrolet Corvette
3 Mitsubishi Mirage
4 Porsche 911
5 Honda CR-V Hybrid
6 Tesla Model Y
7 Mitsubishi Mirage G4
8 Buick Encore GX
9 Kia Forte
10 Buick Envision
This looks like the sort of data you'd expect to see if there was absolutely no correlation whatsoever between the class of vehicle and accident rates. And then the data was massaged to put Tesla in the headline because clickbait — and even after that massaging, Tesla was pretty much tied with Kia. So what have we learned from this data? Nothing. It's meaningless data. Might as well be random.
We used Dokuwiki in a similar situation. It's been a few years since I last used it (new client uses confluence) but I remember it was super easy to connect external tools. If your script can output text, Dokuwiki can display it :)
In my last role as a director of engineering at a startup, I found that a project `flake.nix` file (coupled with simply asking people to use https://determinate.systems/posts/determinate-nix-installer/ to install Nix) led to the fastest "new-hire-to-able-to-contribute" time of anything I've seen.
Unfortunately, after a few hires (hand-picked by me), this is what happened:
1) People didn't want to learn Nix, neither did they want to ask me how to make something work with Nix, neither did they tell me they didn't want to learn Nix. In essence, I told them to set the project up with it, which they'd do (and which would be successful, at least initially), but forgot that I also had to sell them on it. In one case, a developer spent all weekend (of HIS time) uninstalling Nix and making things work using the "usual crap" (as I would call it), all because of an issue I could have fixed in probably 5 minutes if he had just reached out to me (which he did not, to my chagrin). The first time I heard them comment their true feelings on it was when I pushed back regarding this because I would have gladly helped... I've mentioned this on various Slacks to get feedback and people have basically said "you either insist on it and say it's the only supported developer-environment-defining framework, or you will lose control over it" /shrug
2) Developers really like to have control over their own machines (but I failed to assume they'd also want this control over the project dependencies, since, after all, I was the one who decided to control mine with the flake.nix in the first place!)
3) At a startup, execution is everything and time is possibly too short (especially if you have kids) to learn new things that aren't simple, even if better... that unfortunately may include Nix.
4) Nix would also be perfect for deployments... except that there is no (to my knowledge) general-purpose, broadly-accepted way to deploy via Nix, except to convert it to a Docker image and deploy that, which (almost) defeats most of the purpose of Nix.
I still believe in Nix but actually trying to use it to "perfectly control" a team's project dependencies (which I will insist it does do, pretty much, better than anything else) has been a mixed bag. And I will still insist that for every 5 minutes spent wrestling with Nix trying to get it to do what you need it to do, you are saving at least an order of magnitude more time spent debugging non-deterministic dependency issues that (as it turns out) were only "accidentally" working in the first place.
Personally - just let the developer own the machine they use for development.
If you really need consistency for the environment - Let them own the machine, and then give them a stable base VM image, and pay for decent virtualization tooling that they run... on their own machine.
I have seen several attempts to move dev environments to a remote host. They invariably suck.
Yes - that means you need to pay for decent hardware for your devs, it's usually cheaper than remote resources (for a lot of reasons).
Yes - that means you need to support running your stack locally. This is a good constraint (and a place where containers are your friend for consistency).
Yes - that means you need data generation tooling to populate a local env. This can be automated relatively well, and it's something you need with a remote env anyways.
---
The only real downside is data control (ie - the company has less control over how a developer manages assets like source code). I'm my experience, the vast majority of companies should worry less about this - your value as a company isn't your source code in 99.5% of cases, it's the team that executes that source code in production.
If you're in the 0.5% of other cases... you know it and you should be in an air-gapped closed room anyways (and I've worked in those too...)
I think a lot of people don't realize it's possible to use UDP in browsers today with WebRTC DataChannel. I have a demo of multiplayer Quake III using peer-to-peer UDP here: https://thelongestyard.link/
Direct sockets will have their uses for compatibility with existing applications, but it's possible to do almost any kind of networking you want on the web if you control both sides of the connection.
It has 3 ways to declare functions, multiple variations on arrow functions syntax, a weird prototyping inheritance system, objects you can create out of "new" on functions, object literals that can act an pseudo-classes, classes, decorators, for-i loop + maps + filter + for-in loop (with hasOwn) + forEach, async / await + promises and an invisible but always-on event loop, objects proxies, counter-intuitive array and mapping manipulations, lots of different ways to create said arrays and mappings, very rich destructuring, so many weirdnesses on parameter handling, multiple ways to do imports that don't work in all contexts, exports, string concatenation + string interpolation, no integer (but NaN), a "strict mode", two versions of comparison operators, a dangerous "with" keyword, undefined vs null, generators, sparse arrays, sets...
It also has complex rules for:
- scoping (plus global variables by default and hoisting)
- "this" values (and manual binding)
- type coercion (destroying commutativity!)
- semi-column automatic insertion
- "typeof" resolution
On top of that, you execute it in various different implementations and contexts: several browser engines and nodejs at least, with or without the DOM, in or out web workers, and potentially with WASM.
There are various versions of the ECMA standard that changes the features you have access to, unless you use a transpiler. But we don't even touch the ecosystem since it's about the language. There would be too much to say anyway.
There are only two reasons to believe JS is simple: you know too much about it, or you don't know enough.
I especially go back and forth on attribute inheritance (it can be disabled via the htmx.config.disableInheritance option)
Three of the criticisms boil down to the fact that client-side state doesn't always play well w/htmx swaps (especially the simple ones) which is absolutely true.
And events can get crazy. They are powerful, but crazy and at times hard to debug. Such is event-driven life.
The one thing I don't agree with is the default queuing mode: it is not to cancel an existing request and replace it. Instead it is to keep the current request in flight and queue one and only one additional request. I'd need to sit down w/them to see if they were misinterpreting something, using the hx-sync attribute to implement the behavior they mention, or if there is a bug.
I would also like to take this opportunity to market our mug for people who don't like htmx:
JS concurrency is crap. It should be shot and buried in a lead coffin.
Debugging async code is pure hell. With Go, you have a normal debugger that can be used to step over the code. You can get normal stack traces for all threads if needed. There is a race detector that can catch most of unsynchronized object access.
With JS? You're on your fucking own. You can't find out the overall state of the system ("the list of all threads"), without getting deep into the guts of React or whatever framework you're using. Debugger is useless, as each `await` call drops you into the event loop. So pretty much every complicated non-trivial JS app ends up with _tons_ of race conditions, by depending on the order of async functions finishing.
Speaking of race conditions. Coming from classic multithreading and Go, I tried to use `Promise.race` to simulate the `select` statement. Turns out that in JS it is actually useless because it LEAKS MEMORY BY DESIGN: https://github.com/nodejs/node/issues/17469
-FranceLeMoulin-Rouge-boulevarddeClichy_A7462-edit-double.jpg?fit=max&w=1200&h=850&auto=format,compress){kind=link}
C# is a super underrated language and Monogame has just enough batteries to get going without being in your way too much.
For ECS, I've been using Friflo ECS and haven't had issues so far: https://github.com/friflo/Friflo.Engine.ECS