> I feel exactly the same wrt. the first. As to the second... I > don't know. This affine types thing is neat, but for managed > languages (Common Lisp, I'm looking at you!) turns out to > solve a non-problem -- and don't tell me modern GCs are slow. > > For very small embedded systems... but then I'd stick to C.
I see you haven't yet learned Rust. 🙂 While ownership and borrowing came from the desire to have the same kind of safety as with GCs (but without the need for an actual GC, which can be significant for realtime tasks or embedded systems), while learning Rust you will discover that it can be useful elsewhere, e.g., they also solve the problem of avoiding race conditions in shared-memory concurrency. > C is somewhat of a nightmare for huge monoliths with many cooks > stirring the soup (someone said Linux kernel?), so there the important > thing is to enforce compartmentalisation and clearly defined > interfaces at the boundaries, so more of an architecture thing. C also makes it very difficult to write and use libraries (among other things because of the amount of info about how to use it that can't be expressed in the language, so is relegated to the docs&comments when you're lucky, but is otherwise kept in the original author's head as choices that are so obvious that they didn't realize they made them). Rust makes all that a lot easier, because you're encouraged (and often even forced) to clearly encode the constraints in the type information. === Stefan
