arendjr @ arendjr @programming.dev

Posts

11

Comments

98

Joined

1 yr. ago

tsc is (very) slow and there are also no convenient ways to interact with it from Rust.

So it saves a lot development and CI time to roll our own. The downside is that our inference still isn’t as good as tsc of course, but we’re hopeful the community can help us get very close at least.

I see this argument repeated here every now and then, but it’s not true: https://aoav.org.uk/2020/the-effects-of-strategic-bombing-in-wwii-on-german-morale/

To summarise: Bombing had a profound effect on depressing morale through inducing defeatism, fear and apathy. Bombing did not harden popular resolve against the US. The hate and anger it aroused was directed against the Nazi regime, not the Allies.

It’s that the compiler doesn’t help you with preventing race conditions. This makes some problems so hard to solve in C that C programmers simply stay away from attempting it, because they fear the complexity involved.

It’s a variation of the same theme: Maybe a C programmer could do it too, given infinite time and skill. But in practice it’s often not feasible.

Which one should I pick then, that is both as fast as the std solutions in the other languages and as reusable for arbitrary use cases?

Because it sounds like your initial pick made you loose the machine efficiency argument and you can’t have it both ways.

I’m not saying you can’t, but it’s a lot more work to use such solutions, to say nothing about their quality compared to std solutions in other languages.

And it’s also just one example. If we bring multi-threading into it, we’re opening another can of worms where C doesn’t particularly shine.

Well, let’s be real: many C programs don’t want to rely on Glib, and licensing (as the other reply mentioned) is only one reason. Glib is not exactly known for high performance, and is significantly slower than the alternatives supported by the other languages I mentioned.

I would argue that because C is so hard to program in, even the claim to machine efficiency is arguable. Yes, if you have infinite time for implementation, then C is among the most efficient, but then the same applies to C++, Rust and Zig too, because with infinite time any artificial hurdle can be cleared by the programmer.

In practice however, programmers have limited time. That means they need to use the tools of the language to save themselves time. Languages with higher levels of abstraction make it easier, not harder, to reach high performance, assuming the abstractions don’t provide too much overhead. C++, Rust and Zig all apply in this domain.

An example is the situation where you need a hash map or B-Tree map to implement efficient lookups. The languages with higher abstraction give you reusable, high performance options. The C programmer will need to either roll his own, which may not be an option if time Is limited, or choose a lower-performance alternative.

I think it’s the latter. I once had to take care of a sick friend who was pretty much puking her guts out. Her moans sounded arousing. Of course she wasn’t intentionally doing that, it’s just our own male brains playing tricks on us.

I’m making a case for custom codes, not for using a 200 status code with it. My reply said the 200 didn’t make sense.

Of course once you use custom codes, the actual HTTP status codes do become less important, because there’s some redundancy there. That’s not an argument to do it wrong, but it is an argument that accurate HTTP status codes are less of a priority. So understandably some people will take shortcuts.

Apparently you find this very frustrating, but in the end it’s just an implementation detail. But it also sounds like you’re more frustrated with the service API as a whole than the fact it uses custom error codes specifically, so I’m just going to leave it at that.

I’m not arguing against that. Merely providing some counterweight to the idea that the author was “flinging shit in the trenches” 😅

I found the title of that section slightly triggering too, but the argument they lay down actually makes sense. Consistency helps you to achieve correctness in large codebases, because it means you don’t have to reinvent what is correct over and over in separate pockets of the codebase. Such pockets also make incremental improvements to the codebase harder and harder, so they do come back to bite you.

Your example of vendors doesn’t relate to that, because you don’t control your vendor’s code. But you do control your organisation’s.

Well, looking at your example, I think a good case can even be made for it.

“s23” doesn’t look like an HTTP status code, so including it can make total sense. After all, there’s plenty of reasons why you could want custom error codes that don’t really align with HTTP codes, and customised error messages are also a sensible use case for that.

Of course duplicating the actual HTTP status code in your body is just silly. And if you use custom error codes, it often still makes sense to use the closest matching HTTP status code in addition to it (so yeah, I agree the 200 in your example doesn’t make a lot of sense). But neither of those preclude good reasons for custom codes.

There is a serious attempt for that actually: https://www.assemblyscript.org/

It doesn’t offer full compatibility with the regular TypeScript though, despite being very similar.

In fairness, this also happens to me when I write the bash script myself 😂

Thanks! I’d be happy to hear your thoughts.

Mostly the same reason why democracy worked for quite a while too. As long as people believe in a system and see the benefits to themselves as well, they can go quite a while with it.

In general I also think most people aren’t out to screw one another, no matter how much it may seem that way sometimes, so as long as that keeps for the monarchs in a majority of districts, the system could balance itself.

But yeah, I’m not going to say it’s perfect. Sooner or later it would collapse, and when it does my money would be on the same reason as yours.

So I think the main question is: would it be able to last longer than democracies can, especially in the face of mass media manipulation and other challenges. I can’t prove it, but I suspect it might have a decent shot, mostly because the monarchs would be more agile to respond against unforeseen threats.

Pray tell, what does it tell?

Your proposal is just an idealistic version of early US.

Thanks, I guess :)

You claim that corruption is fundamentally impossible, but assume that magically “the monarchs aren’t allowed to own property” without regard to enforcement.

I make no such claim, and I don't make assumptions regarding enforcement either. Constitutional enforcement is discussed in quite some detail.

You claim to have an alternative to democracy but still propose majority voting on replacing rulers and constitutions.

There is majority voting on deposal of rulers, to be specific. Their replacement isn't voted on by a majority of the population.

Constitutional changes are voted on through majority, but first require a majority of the monarchs to be on board.

Both these limitations are intentionally designed to mitigate manipulation of the population.

You simply assume that monarchs will keep each other in check and not devolve into the conspiring, warmongering tyrants that history is full of.

There is quite some detail about the enforcement mechanisms. The idea is very much not to assume, but to persuade the monarchs to act in a benevolent manner, by enticement through both the carrot (wealth for as long as they rule), but also the stick (deposal if the majority doesn't vote in favour of their actions, with a threat of assassination if they refuse to be deposed).

Power can always be abused to get more power and go against all your original ideals. The only way to definitely prevent corruption is to ensure power is never concentrated in the hands of few.

Ah. So it wasn't me that claimed that corruption is fundamentally impossible, it's you that claim to have the definitive answer.

For what it's worth, I agree power shouldn't be concentrated in the few. Which is why I split power across districts, and between citizens and monarchs, and why the group of monarchs for each district cannot be too small either. It's all there if you could try to be a little less dismissive.

:D

From your other responses I can see you're being sarcastic, but yeah, seems that many won't read any further after seeing the word monarchy :shrug:

There is a huge difference between how things should work and how they will though. Without any system of enforcement, I would call it nothing but wishful thinking.

In fairness, democracy was a kind of wishful thinking too, which is why I would propose a new form of monarchy instead: https://arendjr.nl/blog/2025/02/new-monarchy/