@G117CH
What's your point?

@torresjrjr I don't understand how this manifesto supports either simple or sustainable software. C is not appropriate for building large and complex systems due to its complex and bug-prone memory management methodology, and this manifesto describes a subset of C that would be even more complex.

C doesn't even support Unicode properly on many implementations, which is one of the tenants of the said manifesto. I just don't get how the items listed are supportive of simple or sustainable software.

@G117CH
> complex and bug-prone memory management
> doesn't support Unicode

The author of the manifesto holds these same opinions, and in fact made his own programming language in the spirit of C which addresses these issues. It might interest you.

https://harelang.org/
@hare

I've contributed to Hare myself and enjoy the language.

@torresjrjr @hare Thank you. Context was lacking on my end. I will gladly look into it. What is your/the author's (if you know) opinion of Rust?

@G117CH
Of the author's opinions:
- https://drewdevault.com/2019/03/25/Rust-is-not-a-good-C-replacement.html

Also of interest:
- https://drewdevault.com/2017/01/30/Lessons-to-learn-from-C.html
- https://drewdevault.com/2017/03/15/How-I-learned-to-stop-worrying-and-love-C.html

- https://harelang.org/blog/2021-02-09-hare-advances-on-c/
- https://harelang.org/blog/2022-05-02-what-is-hares-scope/
- https://harelang.org/blog/2022-04-25-announcing-hare/

@G117CH
I myself kinda hate Rust haha. Or more so the Rust ecosystem. But I do respect it's primary points of memory safety, etc.

@torresjrjr See, I've been finding myself enamoured of Cargo. One of the things I hate most about C/C++ is makefiles when I start wanting to use external libraries. Pulling in crates is intoxicatingly easy.

@G117CH
> intoxicatingly easy
Precisely where the poison lies. Copying the npm/.node_modules monster is a terrible idea. Your point about C/C++ external libraries is also true. Which is why I like Hare's sensible and user-friendly inbetween.

=> https://harelang.org/tutorials/libraries/

@torresjrjr Now that's a criticism that's totally valid! I should have been thinking about that a bit more with the recent faker.js incident, etc.

There are groups working to make it better, even Google (yeah, I know) is working on an Assured Software Chain to prevent it from happening again, but it will always be one less time the developer has his hands on the code before he uses it. It's a hard trade-off between efficient development and safety.

I've been developing since Borland C++ 3 on Dos, and I agree things are far too complex and break way too often, but I've also had to face the fact that the ecosystem no longer allows one developer to do most meaningful work like it did when I got in the business.

I look forward to reading up on your and your friend's work on this language, but I wonder how adoption will work out.

@G117CH
I'd argue philosophically that npm as a concept is flawed, and the lack of this insight is what causes all these issues in the first place.

Also, I don't buy a lot of this "forced upon by the world ecosystem complexity". I see a large lack of due diligence out there. But yes, the outside world exists, and we have to deal with it :D.

> I wonder how adoption will work out.

World domination is not a priority for the Hare project. Upstream Hare deliberately does not support non-libre OSs. It's a principled language, and if others happen to find value in it, that's great. It's not meant to replace anything. Languages serve different purposes and niches, including Rust.

@torresjrjr I do certainly agree with the author’s statement that Rust is not a replacement for C because C and C++ are not the same languages. I was unaware of Go’s lineage, but that makes a lot more sense. I come from the C++ side of things more so than C. My last C work was around 2002.

Also, I don’t buy a lot of this “forced upon by the world ecosystem complexity”. I see a large lack of due diligence out there.

Yes, I agree. My TV no longer works because Roku pushed a broken update. My phone won’t stay paired to my car. These are things that would’ve been unthinkable back when I got into programming. What I mean though, is regardless of OS, most programs aside from console-based ones require an inordinate amount of code and complexity to write, and most of this code is hidden away in toolkits and OS-level libraries. It is impossible, for instance, for me to vet the code of the Qt project, and write a program that does something useful, by myself. This exact limitation has caused problems down the line for my business, as undefined behavior in Qt presented as a very hard-to-find bug.

So it does feel that some complexity is forced upon developers to continue to be productive, but I don’t know that there is a clear path out of those woods.

@G117CH

You certainly make some good points there. I agree. I suppose I always talk with the implication of libre software in mind.

What business, if I may ask?

@torresjrjr I am an embedded systems developer for a company that makes sawmill equipment. We use Linux, and FreeDOS (yes, DOS). It's actually a fascinating field. We use lidar for optimizing board feet per log, reducing waste, etc. Quite a lot of automation. Qt is used in our GUIm and I'm the only one that's willing to deal with GUI stuff. ;)

@tobtobxx
This is 2 years old, btw
https://git.sr.ht/~sircmpwn/arewesimpleyet.org/log

@torresjrjr Most of these projects are way older that that.

@tobtobxx
Thanks for sharing them anyway.

@torresjrjr

I'll give in to the assembler/binutils point. We need that (llvm is simple to use, but that's not the 'simple' they seek). I can't tell whether tcc would fit this category though.

About the kernel: you can tune Linux down as much as you want. Once you remove all unneeded drivers/architectures, the code is actually almost as simple as you can get without giving up features.

2/3

@torresjrjr

And build system: Yeah Make is hell, clang too. But there are some interesting upcoming projects. I'm personally keeping an eye on nobuild[0].

So yeah. Pretty bad article IMHO.

[0]: https://github.com/tsoding/nobuild

@tobtobxx @torresjrjr There's also redo, which is more similar to make but without many of its problems

@yyp @tobtobxx
TIL. Links for lurkers:

https://jdebp.uk/FGA/introduction-to-redo.html
https://cr.yp.to/redo.html
http://www.goredo.cypherpunks.ru/
https://github.com/apenwarr/redo
https://github.com/leahneukirchen/redo-c
https://git.sr.ht/~ach/redo-hare

@torresjrjr, @yyp and @tobtobxx, you might be interested in zig build as well

@cnx I dislike zig build. Writing build code in "real" language might seem convenient, but it requires in cross-compiling for example, both host and cross toolchains must be installed. And the builds take longer because you compile twice (and it's pretty bad with LLVM). Also, I see no reason why the same thing zig does can't be done using make or redo