he's saying that you don't need to be comfortable with ides and fancy debuggers and cmake and language servers and game development engines and ci pipelines and all kinds of complicated stuff to write c successfully
a bare-bones text editor and the most minimal build system are plenty
and if they aren't plenty, he's not saying that's a problem with you, but with c
i don't agree (ctags, valgrind, git, and gdb go a long way towards making c usable, and evidently c is the best language for a lot of things even ctags and gdb struggle with, like linux kernel drivers, and cmake evidently helps a lot if you care about ms-windows) but that's what he said, and you totally misunderstood him because you somehow got the idea that vim and make are some kind of super advanced tool
they're maybe a bit unprepossessing at first glance but mostly what they are is simple and primitive
think of using a hammer rather than a cam-driven turret lathe
you can go lower tech than make too now that cpus and c compilers are so fast
while sleep 1; do # ci pipeline
gcc -Wall -funny -mtune=i69 *.c -lm -liberty -letmypeoplego -o proggie && # build system
./proggie --run-tests # test runner
done
c compiles fast enough that this scales to several thousand lines of code, c++ very much does notof course you need a testing framework
if (!strcmp(argv[1], "--run-tests")) return run_tests();
... three seconds latair ... int run_tests()
{
return test_ui() ||
test_network() ||
test_parsing();
}
now i'm not saying you shouldn't write a test runner in unity and distribute your ci pipeline with zmq and mqtt and whatever the fuck. better ux is worth my weight in gold, and i have programmer gutwhat i am saying is that the difference between no test runner and an infinite loop in bash is much bigger than the difference between the bash loop and circleci or gitlab pipelines. so don't be intimidated by articles like this which make it sound like you need a team of phds to set up a test runner
except for version control. a build script in shell is a serviceable alternative to make, but cp -a proggie/src snapshot.$(date +%Y-%m-%d) is not a serviceable alternative to git
If you're going to learn a bunch of modern tooling and start a green field project that justifies that complexity, C is generally a poor choice. Learn a modern language.
I use C somewhat regularly, including for kernel stuff, embedded, and legacy code.
Mostly, though, when I use C, it's because I'm doing a small thing that I need to be very fast, and I haven't yet bothered to get comfortable with Rust.
Yeah, the "C is the universal ABI" problem is... annoying. Hopefully something safer eventually replaces it in that niche.
Also, I think the main reason I use a lot of the tools I do is just "suck cost fallacy".
what the fuck is it with these people that they flagged your comment upthread
Are you using C99 features? I find the "new" features extremely enjoyable, it feels like a different language compared to C89 or the common C/C++ subset.
I don't say any of this as a dig at C, but at ~50 years old, it definitely shows its age.
See https://www.urbandictionary.com/define.php?term=Gatekeeping
We always talk about how good engineers "choose the right tool for the job". I don't think expressing an opinion on what the right kind of job is for a particular tool should be out of bounds. (Setting aside whether the opinion is correct or not.)
What a bad faith interpretation.
It's advice based on the poster's experience, stated with both qualification and good humor. You are free to ignore it. I appreciated it.
The fact that you don't see this as problematic, is problematic.
The advice is common enough that it has a wikipedia page: https://en.wikipedia.org/wiki/KISS_principle.
There is no gatekeeping. There is a suggestion that C is best used for projects that have builds no more complex than a Makefile configuration. There is explicitly no ~judgement~ limit on what ~kink~ text editor one may use to edit the files.
thus hegemonic institutions reinscribe the kyriarchy generation after generation by perpetuating a hierarchical opposition between "knowledge" and so-called "ignorance", which is socially constructed to be inferior, less than, but which serves the purpose of distinguishing the graduates of elite institutions (to which access is mediated by the financial privilege of the bourgeoisie) from the subaltern underclass; thus "knowledge" serves the interests of capitalism by reproducing oppressive class divisions, enabling the continued exploitation of the working class
what could be more problematic than that?
but if you're interested in learning something and not just playing word games to gain status by putting others down, i problematically mansplained what you're missing in https://news.ycombinator.com/item?id=37083233
I'm guilty as charged. If anyone is actually discouraged from learning C by that well-meaning advice, then they're going to have a pretty hard time in general.
If someone wants to do that anyway, I am going to be perplexed that C was the language choice rather than golang or rust, and perhaps worried about C being a footgun WRT security, but whatever.
If you work on a C project, you need to be ready to have to edit source code, at least minimally, from an environment that doesn't have GUI. You will have to interact with pagers, man readers, readline a lot -- it's a lot more convenient if your editor works in the same way as those tool.
You are just creating unnecessary problems when you use VSCode or a similar editor. And I cannot think about a single benefit that would come from using it. Beside other things, it's just a crappy text editor... the only thing that's going on for it is that it's a Web browser application... which is kinda worthless when it comes to a typical C project.
Seemed perfectly modern for the mid-90's using DG/UX.
Apparently plenty of people don't have a clue of many of those environments used to be.
This is called gatekeeping and it’s not helpful.
It’s fine to write C in vim/emacs/nano if you want.
It’s fine to write C in Visual Studio Code if you want.
It’s fine to write C in CLion if you want.
There is nothing wrong with any approach and no need to gatekeeper an entire programming language based on editor preference.