C++, Java, Rust are far from minimal. Go feels minimal but it too has a lot of features compared to C and it has a garbage collector too.
Here are some things I am looking for:
* Compiles down to machine code.
* Does not have the footguns of C.
* Simple like C.
* Implementations available for all major OSes, at least, Linux, Mac, Windows, *BSDs.
After extensive search I got the feeling that it is difficult to find such a language. If I am willing to let go "simple like C", then it provides a lot of options like Rust, Nim, and all. Just asking here to see if I missed something during my search.
> Simple like C.
You have to pick one, or give in on both and find a happy medium between the two. The way you get safety in a language is by abstracting over the simplicity.
I personally would suggest biting the bullet and going with C++, you can stick to a reasonably sane subset of the language but it definitely won't be C.
I'd say Pascal is simple, and has fewer foot guns than C. It might be too simple - but one can do a lot with freepascal/Lazarus.
Or go with Ada. Also somewhat simple, I'd say.
It should be noted that there are languages developed as safe dialects of C, such as Cyclone[1], whose design goal was to have it both ways and enhance C's safety while preserving its simplicity.
[1] https://en.wikipedia.org/wiki/Cyclone_(programming_language)
Yes it has GC. What is it that you want to build though? Will GC be in the way? If so, I would consider Rust instead.
C is simple, true – but in many cases it seems like that fact pushes the complexity up to higher layers instead.
C still has it’s place in embedded. And our best kernels are currently written in C. Outside of those domains I don’t see much reasons to start a greenfield project in C.
> C++, Java, Rust are far from minimal. Go feels minimal but it too has a lot of features compared to C and it has a garbage collector too.
> Seems like Go might be able to fit your bill.
> I would consider Rust instead.
As others have pointed out in this thread, there are good reasons why Rust is designed the way it is.
With that said, I hope the OP will find a language that they like and can be productive in. Hopefully they input from this thread can be of guidance.
Zig sounds mostly like what you want, though: https://ziglang.org/
Possibly a subset of D could work, too:
https://dlang.org/blog/2018/06/11/dasbetterc-converting-make...
But likely the D language will be too big?
Each one has its own way in which it deviates from C in a way that some people might not like. Odin is probably a lot closer to C than Zig. Zig tries to bring some of the more recent ideas into the low level programming space (compile time null checking, builtin "T or error" types, etc.
Of course there are some other contenders, but having looked at them, either they are not even serious enough, or they deviate from C way too much, with GC, closures, etc.
V isn't anywhere near finish. The closest thing should be Zig. But that is far from finish as well.
Crystal is more like Go than C. But I mean someone wrote a OS [1] using Crystal in her spare time.
Or just plan old Pascal.
I mean if you are looking for simplicity like C and compiled to machine code you virtually ruled out 95% of all programming languages. Other languages like Lua is simple. But certainly dont fit the bill.
This doesn't seem like a satisfiable set of constraints. I'd recommend removing "not garbage collected" from the constraints, as automatic memory management mostly got introduced to reduce footguns.
With 64-bit CPUs and virtual memory, that might even be a viable approach for some applications. You would have to decide up-front how many Foo’s, Bar’s, etc. to support, but you can set those limits very high (the old solution to that was to replace a card dimensioning some arrays and recompile)
Weird? Yes, for current thinking, but you would get a simple language.
Strings are memory managed for you, and can even include nulls.
See the Free Pascal project[1], and the Lazarus IDE[2]
You have to learn the type system, task and protected types, and a few other things to really get the advantages of Ada, though. While those aren't hard, they aren't "simple" in the same way that C is simple. But you can learn them piecewise, which is good, as it permits incremental learning of the language.
My web servers run with like 300MB of RAM and work fine on t2.nano serving thousands of users??
And also Java gives you full access to primitive types if you don't like OOP
Personally, I still think that C is a very good compromise between size (both of the language and of its RAM usage) and it's level of abstraction.
The size of a language can be judged by the size of a definitive text on learning the language. Compare how small the K&R book "The C Programming Language" is [230 pages] compared with (say) the O'Reilly book "Learning Python" [1200 pages].
C, when run on the same exact machine as Java, is only a few x faster in the best case scenario to my understanding. And as complexity of the application grows, there is a chance that you don't manage your memory properly, something which a garbage collected language usually does well enough.
Couple in the rich libraries for both languages, I think I would still choose java unless I was writing an embedded system.
And of course if you had written that in C it would probably have taken up a lot less.
And sticking to some common heuristics goes a long way towards safety. Some people think it's impossible to write safe C, but you can.
So the answer is C.
C + smart pointers and container types?