A “single process” mastodon alternative for who would like to self-host

I find Pyto to be really unstable and it tends to crash a lot even when doing basic things and following the examples provided.

In the past I tried to report bugs to the developer but never got any reply

I don’t use it regularly, but it worked well enough when I was pushing it pretty hard a while back. Rats. So now we’re back to 0 modern, stable Pythons on iPad?

How do you write code without having a model of the world?

With protobufs you get bytes that you have to parse with defined rules on what to do with unexpected and missing fields.

How’s it different from the proposed model where you start by parsing the data you receive and, once it’s parsed and know it’s good, you process it?

It probably would work, provided that each client takes the original proto file and removes all the fields they don't use, so they are treated as unknown fields?

I don't know if there's a supported way to do this, though. To leverage it for refactoring, there would also need to be a way to do a query to find out out which clients use which fields.

In some cases interviews are so short that you cannot even show any of these evidence

All the companies have in common a huge budget they can invest on their build systems to overcome the shortcomings of monorepos.

They do have some benefits, but they also come with an immense cost

But that's what the OP's quote is saying. "large" companies use them.

all of those companies were once small too

Package managers solve it quite well. Just depend on the latest version of your dependencies and tag a new version whenever they change.

This doesn’t work when an underlying system changes, and upgrading is mandatory for all clients or package dependants (happens often at scale for a multitude of reasons).

That's not good stewardship. You have a better API? Great, convince us it's worth investing in soon, you can even deprecate the known-good version.

There's always a window where both will be in use, because we can't synchronously replace every running process everywhere (not that it's even a good idea without a canary). The shorter you try to make that window, the more needless pain is created and plans disrupted. While we could use prod to beta test every single version of everything, that shouldn't be our priority.

That's not reality for most large companies, even though it's the right mindset for most software libraries. Ex: A new legal requirement comes in, resulting in a mandate that fields X and Y for certain queries, that are being done all over the codebase, now have to be tokenized. This is a breaking and mandatory change, with no room to allow systems to stay behind, and expensive consequences.

In this case you'll have a very short transition, between all consumers updating their client code (possibly in a backwards compatible way) and the change in the implicated system being deployed, not the other way around.

If adopting the new API is mandatory, every team should be told why it's mandatory, and we'll reprioritize and get it done. Doing it to our code behind our back is passive-aggressive and likely to break stuff, because who is monitoring and reporting on a change in our system's behavior that we didn't even see?

This is essentially the problem go has had, precisely because you could only ever pull the latest from master.

Introduce a breaking change into a common library and now you have to update every other dependency to support it.

Not so bad in a monorepo. But when your codebases are distributed?

It's almost like semantic versioning exists for some reason

Or realize that it is an advantage to control your dependencies.

Now you have to desperately try to get people to upgrade every time an important change goes through. And you quickly live in a world where you need to maintain tons of versions of all your services.

While I agree that String parsing in Swift is quite annoying, when I started using Scanner my Advent of Code parsing experience improved

https://developer.apple.com/documentation/foundation/scanner

Is this a follow up to Street Fighting Mathematics, from the same author? https://mitpress.mit.edu/books/street-fighting-mathematics

You can consider it as such, yes. The main difference is that whereas street fighting mathematics was focused more on the mathematical side, this book focuses more on physics. However, the spirit and bold worry-free approach is exactly the same.

What would a functional approach be?

It depends on what is the goal. To take advantage of multicore for computations one can use explicitly parallel functional algorithms. To improve response under load one can do load balancing within application and schedule at the very top (shell level) several independent functional pipelines.