I think the commenter is correct. C makes you learn how a computer works. As your code gets more sophisticated you'll eventually have to know this or you can't take your work to the next level. I don't know C all that well and I'm currently facing gaps in my knowledge that would be filled in had I spent some time with a C compiler.
Agreed. Unfortunately the job market pushes people into professions they are not suited for. I bet 90% of lawyers do it for the career prospects and not because they like law.
I accept your premise that we don't want to push people into professions they are not capable of doing well in. But basic knowledge of programming is becoming important enough that I think providing a gentle intro is wise. Like Math and Physics, you can ramp up the difficulty in later classes.
The other option, and the one I choose, is to go from high-level languages down. What I'm not so sure about is just throwing people in in the middle, so that they are trying to grasp abstractions like functions and variables at the same time as they are trying to understand pointer arithmetic.
In the subset of Racket we use, all values are immutable, so an understanding of memory (stack vs. heap) is less necessary. We do still talk about "frames" to understand lexical scope, though, and students get used to thinking of each function call using up a new "frame" of memory to store its local variables. This allows them to understand the memory efficiency of recursive functions.
We then move onto Python, and _do_ talk about an "environment" (stack) and a "heap" (I call the heap "object-land" because objects live there). This enables us to talk about garbage collection. More importantly, students get used to thinking about variables as being bound to either primitives or pointers to shared memory.
In Go, there _are_ pointers, and students get used to thinking about memory addresses as values. They learn that pointers are useful both for sharing mutable references, and for avoiding expensive copies. (In Go, arrays are values, and passing a large array to a function copies it.) But none of the sharp edges of C's pointers are present. Go does "escape analysis" so that if you return a pointer to a local variable, that local variable is allocated on the heap; it is safe to point to anything and if you do, it won't be garbage collected. There's no pointer arithmetic.
By the time they see C, in the third-year course, a lot of the pieces are in place to have a good understanding of how the stack and heap (and manual memory allocation) really work. And along the way, because they were using higher-level languages, the students have been creating cross-platform, complex programs (web servers, games, etc.) that they're proud of. :-)
Re: sibling's comment that "some people aren't cut out to be engineers," I think that's a somewhat dangerous attitude. I think the study of computation is profound & rewarding and should be part of a liberal arts education for everyone; even apart from that, programming is also a useful skill for people who won't get a job as an engineer.
Agreed that some basic skills are a good thing. But in the same sense that I have some grasp of writing but never will be a good writer or enjoy it, a lot of people are just not cut out to be software engineers. It would be a sad world if everybody had the same talents.
C isn't the only language with such features.
https://www.embarcadero.com/products/delphi
https://shop.mikroe.com/compilers?programming-language*=pasc...
Basic:
https://www.visualstudio.com/vs/universal-windows-platform/
http://gambas.sourceforge.net/en/main.html
https://shop.mikroe.com/compilers?programming-language*=basi...
Z80:
Any Assembly will do, pick ARM, RISC-V, AVR, PIC, ....
- compiles to native code via ngen, mono, .NET Native, MDIL, IL2CPP
- has pointers in unsafe code
- has value types
- structs allow for layout control
- value types can be stack allocated, it also allows for alloca in unsafe code
- memory can be allocated outside GC via safe handles or marshaling services
- latest versions have support for zero allocation memory references
The only thing it doesn't do properly is to have global statics, but it can be worked around via a singleton.