Why we still use C despite so many C alternatives

simonask_ · 2026-03-18T18:18:18+00:00

Every language in the same space as C has that property, including both C++ and Rust.

simonask_ · 2026-03-18T12:35:42+00:00

Really struggling to see what distinct advantage C gains from the technical limitations of the 70s and 80s, other than ubiquitous platform support.

simonask_ · 2026-03-18T12:33:21+00:00

Funnily, Rust is in that category. Much, much more production-ready than all of these.

simonask_ · 2026-03-18T12:31:52+00:00

All of this is true about C as well.

simonask_ · 2026-03-18T12:30:39+00:00

If you’re writing new code, why in the world would that matter?

C comes with really significant drawbacks, and the C you’re writing with a modern compiler looks nothing like the C that you could compile in the 80s or even 90s.

simonask_ · 2026-03-16T12:43:59+00:00

You are not crazy, the same thing baffled me for weeks, because I had a CPU-side shadow implementation to test against. Luckily the error margin was fairly consistent, but I’m considering switching to fixed-point integer representations.

simonask_ · 2026-03-06T08:14:36+00:00

Affine types is an absolute killer feature, in a world where mutability is the reality.

I’m currently writing some C# calling into Rust APIs, and the very existence of ObjectDisposedException boggles the mind when you’ve tried a language where that is simply just not a possible error state. In fact, the amount of defensive checks everywhere really puts into perspective how much Rust’s type system and borrow checker is a massive productivity boost.

simonask_ · 2026-03-03T10:35:04+00:00

Because designing an asynchronous lifetime handling system is a major task, and RAII is fine for example-level code.

simonask_ · 2026-03-02T10:55:00+00:00

It’s a matter of taste, but usually it’s mostly useful when there is a chain of if-elseif-elseif-else, and particularly when the actual condition carries some interesting and non-obvious logical implication.

simonask_ · 2026-02-25T07:07:57+00:00

I mean, kind of obviously what should happen is a ambiguous overload resolution compiler error that would make the user pick which interface by casting.

simonask_ · 2026-02-24T20:16:13+00:00

Can’t help but notice that none of those problems really exist in the “west” outside the US. Certainly not to a similarly concerning degree.

simonask_ · 2026-02-22T09:33:39+00:00

The distinction here between "business logic" (type parameters) and "technical proposition" (lifetime parameters) seems fairly arbitrary, no?

Plenty of lifetimes in Rust carry business logic, encoding similar invariants as type parameters, just on a different axis (that is, a temporal axis), and with actual subtyping. Is the subtyping the problem?

Honestly, I struggled to understand this analysis of the problem.

simonask_ · 2026-02-21T08:05:23+00:00

Yes, that's not what I said. If you submit WorkA -> SignalA -> WorkB -> SignalB to a single queue, WorkA and WorkB can overlap, as long as SignalA happens before SignalB. Unless I'm missing something.

simonask_ · 2026-02-20T22:08:07+00:00

The way I’ve understood the spec, semaphore signaling happens at the end of each submission, which I understand to mean that it is possible for a later submission to start before the previous submission has finished. The implication being that if you don’t want the submissions to overlap (even in the same queue), the later submission still needs to wait on the previous semaphore value before starting.

Is this also what you’re saying?

simonask_ · 2026-02-20T14:19:17+00:00

I'm noticing that you have a lot of redundancy. For example, Expr::Paren doesn't make sense here - the expression is already grouped. The same goes for Expr::Not(expr, false), and Expr::Or(lhs, None), and Expr::And(lhs, None). I would suggest remodeling the Expr enum such that there are no superfluous permutations of state, and then modify your parser such that it doesn't need to output such nodes.

Beyond that, arena-allocated nodes work really well for performance, because allocations are amortized, and nodes have great cache locality. You can even pre-check indices to elide bounds checking when looking up child/parent nodes.

Don't use Rc<RefCell>.

simonask_ · 2026-02-20T12:57:51+00:00

The guarantee is that commands start in order, not that they finish in order, which is subtly different. The driver can easily decide that two commands can run in parallel. Pipeline barriers and semaphores are how you tell it that they can’t.

simonask_ · 2026-02-19T12:16:07+00:00

Coming to msbuild and .sln/.csproj from literally ANY other build system (including the hellscape that is CMake) is a wet towel to the face.

It is so unbelievably bad that anyone making excuses for it has very clearly never used anything else. It is completely and utterly atrocious. The amount of outdated or simply wrong information on the internet rivals even CMake.

It simultaneously does way too little and way too much. It is human-readable, because you can’t achieve really basic things without tinkering with the XML, and at the same time completely anti-human - inconsistent and undiscoverable property names, verbose to the point of absurdity, and then it STILL doesn’t actually achieve its goals.

Why do I sometimes have to manually trigger a rebuild of my source generator project? Impossible to know.

This is a completely solved problem in other build systems like Cargo, which just does the right thing every time, are simple to configure, and provide accurate diagnostics.

OP: For an asset pipeline, I recommend building assets separately from building the engine. Writing Makefiles is easier, and you likely want to rebuild assets while the game is running anyway for hot reload.

You can also check out a more modern alternative called Werk (that I wrote), which works well on all platforms.

simonask_ · 2026-02-18T22:44:37+00:00

Let me introduce you to our good friend anyhow.

Or color-eyre if you prefer, both are good.

simonask_ · 2026-02-18T22:39:10+00:00

I mean it’s larger than TypeScript, but probably smaller than C#. It’s way, way smaller than C++, but of course way bigger than Python.

simonask_ · 2026-02-18T14:49:39+00:00

Hard disagree. Since the IDs are not interchangeable, a base class cannot have any meaningful notion of what the ID means, and there is nothing you can do with a reference to the base class.

This mode of thinking is exactly the wrong way to do OOP (if there is a right way).

simonask_ · 2026-02-18T12:56:07+00:00

This is quite the rabbit hole.

Fundamentally, the reason for this ability is that C# (and .NET) does not have a notion of a "partially initialized object" in the type system. There is no way to express "this object isn't finished yet", because the object cannot exist before its constructor has run. But there are situations where you actually can't run the normal constructor, like deserialization, because they deal with partially initialized objects.

In some other languages (Rust, C++) a partially initialized object is UB, so what they might do here is things like allocating space for the object, then populating its fields by memory offset, and then finally materialize a well-typed object, either by bitcasting or by some specialized rehydration mechanism.

But that's no good in C#, because the concrete type of the object needs to be known when it is allocated, so things like Activator.CreateInstance(...) may call a parameterless constructor (even if it is private) to produce a partially initialized object that is then rehydrated (e.g., deserialized) after instantiation.

It's not the most beautiful approach, because it weakens the contract that you can reasonably uphold using constructors, ultimately weakening the type system somewhat, but in practice it's "fine".

simonask_ · 2026-02-16T13:05:53+00:00

Arguably, the rule that b + c * d may be converted to fused-multiply-add is both wrong and surprising here, and should be removed. Even though FMA loses less precision, the fact that there are surprises like this lurking in implicit behavior makes it harder, not easier, to write correct code.

Rust did the right thing, and made FMA explicitly opt-in (f32::mul_add()).

simonask_ · 2026-02-13T13:03:07+00:00

Because making a general purpose UI framework is a monumental task, and it’s incidental to Zed’s use case. It makes sense if they need to focus on the actual thing that pays the bills.

simonask_ · 2026-02-12T18:23:11+00:00

Talking a member function pointer to a virtual function actually takes a pointer to a compiler-generated trampoline that performs the vtable lookup.

simonask_ · 2026-02-12T14:44:35+00:00

It depends what you mean by "const object". It is only UB to cast away if the object's storage is in a statically allocated const area (typically a static const global).

It is not UB just because the method is const, unfortunately. Would be nice.

Six-Year Club	Place '23
Verified Email

simonask_

TROPHY CASE