1. 61
  1.  

  2. 26

    Although I posted something else in this thread already, I wanted to respond to this, which is the crux of the post.

    How do we build computer science programs that prepare students to build their own futures?

    That’s a huge question and I don’t think the answer provided had a lot of thought put into the matter. For one thing, it cites no relevant research. And there is a wealth of it. You could start with the ACM Special Interest Group on Computer Science Education, for example. Or read the ACM’s Computer Science curricula guidelines and learn about the wide range of approaches taken by various education institutions. Chapter 5 is of particular interest, where it states:

    Whether or not programming is the primary focus of their first course, it is important that students do not perceive computer science as only learning the specifics of particular programming languages.

    Even for computer science, programming from the outset is not a given.

    The post also cites the ACM curriculum incorrectly. The post states,

    We have to recognize what the ACM has been telling us since 2002 - that there are two or three tracks to “computer science”: what we might call “theoretical computer science”; what we might call “computer engineering”; and what we might call “software engineering”.

    According to the ACM Curricula Recommendations (from 2005), it defines five sub-disciplines.

    1. Computer Engineering
    2. Computer Science
    3. Information Systems
    4. Information Technology
    5. Software Engineering

    In short, this proposal ignores the plethora of existing research into teaching computer science, computational thinking, and all the related sub-fields with the unfounded assertion that teaching programming and teaching the details of how computers work, preferably with a command line interface, is the path forward. There is little reason to believe any of this. This seems like an op-ed from what is likely a bright mind falsely assuming that most others should work the same way they do. I encourage the author to read some existing research and talk with those who work in this field. It is remarkably complex and nuanced.

    1. 9

      Thank you very much for linking those relevant resources! Also, big oopsie on my part for not looking for the updated curricula recommendations; I was using the version that was printed out in my department’s lab when I wrote this (prior to COVID, actually!)

      1. 1

        If you would like, I will ask my friends who research in this area to provide you with some more papers or links. I know they have mentioned active learning at U of Toronto and some studies with POGIL, but I have no specifics. PM me if you’re interested.

        Edit: I do know that Mark Guzdial has been active in this area for some time (I read his blog in the mid 2000s when it was around). If you’re interested, that’s a good place to start.

      2. 3

        A better way of explaining the controversy here is by focusing on exactly where we transition to pure op-ed:

        We move forward by giving students a taste of all three when they enter the field, and letting them specialize as they wish.

        I am very sympathetic to the idea that getting students programming quickly is important. So do that.

        Like Geoff said, not everyone thinks it’s about better programmers. Another software engineer might say “I am very sympathetic to the idea that getting students comfortable and flexible with novel computing tools is important”.

        Another might replace that with “practice, practice, practice in recognizing and framing problems is important”.

        Perhaps another would say “proving correctness or testing more often than programming is important”,

        or “an acute and situational awareness of the impacts and ethics of computing is important”,

        or “visualizing and building an intuition of data and analysis is important”,

        or “communicating and collaborating often with fellow engineers is important”…

        In short, this particular educational goal of creating “better professors, better engineers, and better web developers” relies on a very opinionated definition of what’s “better” for them. This debate around “better” is at the heart of the nuances in CS education.

      3. 12

        Having learned from a curriculum that didn’t use IDEs and forced you to use the computer lab (which is basically a unified environment), I can tell you it wasn’t any better than using an IDE. I taught and was a teaching assistant on some courses at the university level and one thing that always happened was students would customize or do seemingly strange things that make teaching to a common environment challenging. Yeah, you put that “it must work on such and such a machine”, but that didn’t stop them. It’s been a while, though, so I don’t know what the current thinking is on this.

        I do know that in my graduate and professional career, the knowledge needed to use a computer is not correlated with the ability to program it. Not even close.

        1. 5

          My personal experience with IDE usage when learning is quite the opposite. When I was learning programming (2009-ish), I was using Trubo Pascal environment (for general “introduction to programming”) and Java with IntelliJ (for algorithms course). A little bit later, started with Python using PyScripter/Geany.

          If I remember correctly, IntelliJ’s auto-format, red squiggles, yellow squiggles with fix it lightbulbs and auto-completion were tremendously helpful. Switching form Java to Python was a pretty horrible experience, because I was missing all those tools for dealing with trivial, but numerous speed bumps. I haven’t learned command line, git and unix until my third year in the University (when I needed them for the first work-like “project”), but I don’t really see why would I have used those tools at the time? Like, I think my programs at that time were couple of hundreds lines at most, why would I use git in that context?

          I also want to offer a personal anecdata-based counter-points to the two conclusions in the article.

          they will not be able to do the crucial work of self-directed learning that is a hallmark of all computer science success.

          My holiday project after first (or second?) semester at the Uni was the visualization of a binary tree in Java. We obviously weren’t taught any kind of graphics, but I still was able to do this on my own, because I was able to auto-complete my way through the AWT. If I had needed to think about imports, I simply wouldn’t have been able to draw the tree.

          Students need to know how to use computers before they can program them in a serious way.

          One of the most serious programs I’ve written so far (quite probably the most serious, if you weight it by me experience) was written when I knew nothing about using computers, beyond clicking on icons in Windows. I wrote it at school, before Uni, when I, formally, wasn’t able to program. I only did math at the time, and only had had like 4 hours total introduction to Pascal. “Pascal” for me at that time was that dos-looking “TURBO” icon on the desktop, which opened a weird blue background / yellow letters windows, were you can type text, and where a shortcut makes the “program” “run”. Language wise, I could use cycles and arrays, I didn’t know about functions, and I think even copy-paste wasn’t working in Turbo-pascal. Nonetheless, I had to study for the programming exam for the University. At the math summer school that year I’ve learned about polynomial interpolation (Newton and Lagrange). Arrays are enough to do polynomials, so I’ve started with polynomial evaluation, addition and multiplication, and then interpolation. Than it occurred to me that I can multiply polynomials by taking degree + 1 samples, multiplying results and then interpolating back. Finally, I’ve figured out that I can solve all “prove, using induction, that 1^1 + 2^2 + 3^2 + … +n^2 = some formula with n” problem once and for all, by just interpolating the result polynomial, automating the hell of the Gauss’ trick (again, didn’t know functions were a thing. my mind was completely blown away when I was taught that they exist).

          I am still insanely proud that I did all that, and “knowing” how computers work wasn’t a part of that at all. Admittedly, if I had known git at that time, I would have had the code with me now. But that’s a comparatively minor nice to have :-)

          My current approach to introducing people to programming is quickly talking about Python interpreter (“program is a text file. Interpreter reads this file and executes the specified steps”), showing how to use text-editor and terminal to do the hello world, and then installing PyCharm and using it for actual programming. One thing I really miss for teaching is a build-in immediate character grid GUI library, like the one with Turbo Pascal. Drawing ASCII mazes and making games is one of the most engaging ways of learning, but it is soooo hard to do with modern languages.

          1. 4

            I agree with this.

            I think it is worthwhile to note that some students took it up on their own to provide courses for new students that teach them all those little things professors don’t have time for – CLI, filesystems, version control, etc. etc.

            1. 6
              1. 1

                Ah yes, that’s what I meant! Thanks for the link!

            2. 4

              I think using notepad or vi at first helps a lot.

              My organization is trying to upskill our SAS programmer to know R. Rstudio came in with a really smart instructor who assumed everyone in the class was a programmer. We used RStudio (a nice IDE) but so many people got stuck on paths and packages that the IDE confused them. I think having the first day just with command line and a text editor is good for teaching basics.

              Years ago I had a psychology professor teach me stats. He made us do everything by hand with no calculator doing stuff like calculating standard deviation and chi-squared tests for two weeks. Then we used calculators. It still helps me 25 years later.

              1. 2

                I think using notepad or vi at first helps a lot.

                I think that depends on whether your goal is to teach computer science or whether your goal is to turn students into productive computer programmers.

                I started off with Notepad and spent more time manually formatting my code than I did actually learning why the code worked. In Python, making sure I consistently used tabs or spaces (and consistently the same number of spaces) was time consuming. And debugging why my code didn’t run when I hit four spaces only to find out that I hit the spacebar four times but the computer had only registered three is what taught me to just always use tabs. It certainly did not make me a better programmer, it made me a worse programmer. Until I got even the most basic IDE with proper linting that formatted my code when I hit save and showed me errors when the line was wrong. In Javascript working with Notepad I’d occasionally forget to put in a semicolon. Same thing, an hour of debugging to find out where versus even the most basic IDE that could tell me.

                I’m sure there are better ways to turn students away from programming, but using Notepad has to be in the top 5 at least.

                1. 1

                  I think that I could make assignments in python that required minimal formatting. I wouldn’t want to to focus on extensive typing.

                  The reason why I say notepad or vi is because it’s useful to teach what formatting is, why it’s important, how to debut errors and whatnot before we use editors that do all that for us.

                  I think the goal for new coders is to learn logic, symbols, structure and people who don’t know what a program is or don’t know what a variable is need to focus on those concepts before they start cranking out stuff. I think, at least.

              2. 4

                a two-day detour to teach the Windows users how to get rid of the CRLFs in their commits, and teach the Mac users to remove the .DS_Store files from their repositories

                I think the real solutions to these problems are better tools (e.g. editors that quietly accept any combination of LF and CRLF) and better defaults (e.g. a default .gitignore that includes .DS_Store).

                Edit: Also:

                Students who use Windows aren’t taught that, while their file system is case-insensitive, not all filesystems are.

                Can we just make all filesystems case-insensitive (but case-preserving) already? Computers should serve humans, not the other way around.

                1. 3

                  Can we just make all filesystems case-insensitive (but case-preserving) already?

                  No, because that opens the door to too many weird attacks, like readme and Readme being different files, and just plain unexpectedness unless you know lots and lots of facts about global writing systems, like why the dumb system insists that straße and STRASSE are the same, or that i doesn’t always upcase to I if someone’s set a magical configuration file such that it upcases to İ. (Can’t tell the difference? I guarantee you they are different but it does help prove my point.)

                  1. 1

                    Can we just make all filesystems case-insensitive (but case-preserving) already? Computers should serve humans, not the other way around.

                    Several years ago I assisted another team with a source code review.
                    The client source code contained filenames that differed in case in the same directory.
                    I’ve always wondered whether this was deliberate or accidental.

                  2. 7

                    It should be “Stop Making Students Use Java” first.

                    Not only due to my personal criticism against Java, but mostly because it limits you to the JVM instead of teaching students about the actual systems and platforms.

                    1. 6

                      I agree, but for somewhat different reasons – and I’ll rephrase that as “Stop making students use java first” :)

                      From the first section of the article:

                      A student who has not written an if statement doesn’t need to understand the philosophy behind putting each public class in its own file, or what public or “class” even means

                      I completely agree. In that case, perhaps a language that forces you to start everything with “class” and follow it with “public static int main” is not the best choice?

                      If you want to teach someone to write if statements and loops, provide a tool that allows them to do just that – eliminate the distractions rather than hiding them. Just like the article mentions later on:

                      Use a language that teaches the fundamentals of the paradigm you’re interested in, like Scheme or Python. (Please, please not Java.)

                      IDEs are not the main problem here. Java is. But an overly helpful IDE can also bring more harm than good.

                      When I teach my students Python, I suggest them simple IDEs like Thonny because I don’t want to see them spending 60% of their time juggling windows around in order to see the results of what they wrote – only to realize that they forgot to save the file. At the same time, I discourage them from using something like PyCharm at least for the first few days, since the constant “help” of autocompletion makes them almost brainless – if autocomplete suggests something then it’s probably right! After all, I’m just a beginner! Sometimes I encounter self-made beginner programmers who did start with PyCharm, and now they don’t really know Python – they just know how to write Python in that IDE. That’s not very helpful either, even if it seemingly makes them effective quickly.

                      1. 3

                        it limits you to the JVM instead of teaching students about the actual systems and platforms

                        Conversely, it enables one to concentrate on the programming language without having to delve into the minutuae of each hosting OS.

                        1. 1

                          If you provide the 100% pure Java-powered OS to the world, that would be true.

                        2. 3

                          but mostly because it limits you to the JVM instead of teaching students about the actual systems and platforms.

                          Most programming activity does not require you to know about the actual systems and platforms. And no matter how much you know about it there’s still a layer underneath so you gotta stop somewhere.

                          Java is still a terrible first lang tho.

                          1. 1

                            Most programming activity does not require you to know about the actual systems and platforms.

                            It sure doesn’t! Don’t get me wrong, I’m not pushing people to making their own memory management and doing syscalls at their first days.

                            But, right after you get out of the academic code (like, algorithms only, with strictly defined input and output) you might want to know how to do basic “operational” tasks. Most of the cases reading/writing to file(s) comes first, and you probably should know where to write, why you can’t write there, what you need to do first and why it doesn’t work on a Mac in the same way (because you put some assumptions into the code). This is where “knowing the platform” comes in.

                            That might sound silly for people around here, but there are quite a lot (mostly young) people who want “to code” but barely know what even a file is (mobile platforms are quite good at hiding that file abstraction from the user, I’m afraid of that trend moving onto bigger machines) or what’s a difference between process and thread (which isn’t obvious on mobile as well).

                        3. 3

                          The Harvard CS50 course does a really nice thing here. They teach C and Python using a simple cloud-hosted IDE built atop Cloud9 which is called “CS50 IDE”. It has a simple file manager, text editor with basic syntax highlighting, and integrated terminal for compiling/running programs. They have built small command line tools to help with debugging and interpreting error messages. The first 75% of the course is taught using C, with the last 25% taught with Python. For the C portions, their command-line invocations just use make, which uses clang under the hood for compilation of C code. They also teach valgrind for debugging memory leaks. They also have a simple step–through debugger integrated with the IDE, but they actually encourage students to begin debugging with simple printf statements and logical reasoning. For the Python portions, they just run CPython 3.x directly.

                          So, the students get an experience that is very close to a “real-world development environment”, but it all runs in their browser. Their online documentation describes how you can get an similar development environment running locally, and use your own text editors and shells and even IDEs. In my opinion, this is a great way to do it. You spare intro-to-CS students of all the vagaries of setting up a local or remote UNIX dev environment, but you also lay down a foundation of tools that allows them to do so on their own time, as they please. Rather than picking an IDE bound to a specific language and time, they have abstracted the “IDE concept” and managed to teach a little UNIX in the meanwhile (ls, cp, mv, compiler command-line arguments, etc.), by osmosis.

                          1. 1

                            That seems like a great idea! Is that tool available to other institutions?

                            1. 1

                              Based on my understanding it’s a bit of a complex setup they have, since they give every student their own container and disk space on shared cloud infrastructure that is tied to an authentication system for the course. I am also not sure if they have open sourced their customizations. But the actual editor itself that runs in the browser is a customized version of Cloud9, which does have a public open source project. And using AWS, you can spin up Cloud9 environments.

                          2. 3

                            A happy medium for those who simply must teach or learn in a Java environment was an IDE-lite like BlueJ ( https://www.bluej.org/ ) - we used this off and on through my undergrad and it did a decent job of briding the gap between “automating the compilation process” and “having a clean way of supplying test input”, versus “having to understand what the hell a classpath or java.io.BufferedInputStream is”.

                            By contrast, as I’m sure everyone can sympathise with, suffering Eclipse in our upper-level software engineering classes was an enormous hurdle. I do wonder if IntelliJ would be any better in that setting, or if this is just a fundamental issue with “professional-grade” development software in education.

                            1. 3

                              My experience (as a CS TA teaching Pascal in the mid-80s, and as parent to a gifted child) is that most people, even smart people, have a difficult time mastering basic programming. Some of the concepts are intrinsically quite difficult, like indirection (pointers), recursion, and simulating control flow in your mind. At that level, anything you can do to remove minor distractions helps! IDEs are a godsend. FFS, don’t make the students worry about line endings or invisible files! That’s like failing a student’s English essay because she was told not to use past tense but let a “was” slip in [true story.]

                              The gifted students, the ones who take to code like a penguin to water, will thrive even in the harshest environments. These are the ones your advice makes sense for. I learned to code on a goddamn Teletype, and later hand-assembled Z80 instructions. My kid politely ignored the Xcode and Python I set up for them, but a few years later discovered GameBoy emulator ROM modding and taught themselves 65816 machine code by deciphering and extending other people’s Pokémon Blue hacks. Ten years later they’re reversing Apple’s private graphics frameworks and writing GPU shaders, despite being unable to survive a single semester of college.

                              1. 2

                                At that level, anything you can do to remove minor distractions helps!

                                I would (and do, in the post) argue that Java is chock full of these distractions, by its very nature; switching to a language like Python or Racket means that not only is the whole complexity of an IDE removed, but the language itself is easier for a new programmer.

                                Tell me, which is more distracting to a new programmer:

                                class HelloWorld {
                                    public static void main(String[] args) {
                                        System.out.println!("Hello, world!");
                                    }
                                }
                                

                                or:

                                print("Hello, world!")
                                

                                Or, from another perspective, is it easier to teach a student:

                                “There’s a program called Python. It looks at the code you wrote and tells the computer what to do based on that. To run your code, put it in a file and tell Python the name of the file, and it will run.”,

                                or “To run your code, open Eclipse, create a new project from the menu File -> New Project, then do x, y, and z in the wizard, then navigate through the project tree to your main class, then enter your code and click this specific button on the top toolbar.”?

                                1. 2

                                  Totally agree with you there. Teaching java as a fist language seems like a bad idea these days.

                                  1. 2

                                    We can have both a language with minimal distractions and a helpful IDE. Maybe not with Python or Racket, because of dynamic typing. But there are other possibilities. One recent language that has been designed specifically for teaching, and now has its own IDE to go with it, is Quorum. (Disclosure: I contributed some code to the project.)

                                    1. 1

                                      that looks pretty neat, you should submit it as its own post!

                                2. 2

                                  I’m not so sure about all ofthis. Well ok, let me try to break this down a bit

                                  1. I didn’t learn programming in university, but before that
                                  2. I started with Notepad, but moved on to editors with syntax highlighting, then later code completion
                                  3. We were mostly told to use eclipse for Java stuff at uni (a long , long time ago)
                                  4. I learn best by just writing shitty code, which motivates me to build things, which motivates me to improve.

                                  So because of 2) + 3) I feel entitled to state my opinion: Sure it helps if people don’t just autocomplete their way through the assignment, but also grasp what they’re doing. I’m really not sure if the IDE is so much in the way

                                  I’m really bad at remembering specifics, after coding in python for years I still sometimes try trim() instead of strip(). I wouldn’t say this makes me a bad developer.

                                  So maybe 1) disqualifies me from saying “IDEs are good” but maybe I just went into CS education the wrong way, as I had already written code for money before. So of course the 101 courses were a little boring and I didn’t really learn anything new of what was written in this post (not saying I learned nothing new, but it was mostly data structures and concepts, not files and build systems)

                                  But I guess my main point is 4). I absolutely work iteratively, like an MVP, sometimes to the detriment of my coworkers. One of them is especially like “if you encounter a road block on line 20, then it’s stalled until it’s solved” and I’m 100% more like “screw this, I will hardcode a value with an @TODO and get everything working end-to-end and then come back and fix the one thing”. Maybe this is why I gave up on Haskell, I need something working and don’t want to bang my head against a single line of code that won’t work. If an IDE helps me do this, I learn a lot more. On the one hand because I don’t lose my motivation, on the other hand because you can’t learn everything at once, so if the IDE solves this one problem I can continue and maybe learn more about the language so this will be solved in another way, or tomorrow.

                                  TLDR: IDEs are fine, if people don’t use them as an excuse to not learn anything.

                                  1. 2

                                    I’m in HS and we’re required to use IDEs and here’s my take: Whenever I’m out of school I go back to Sublime. I even sneak in “nano” at school (I use it regularly with servers). The reason I love Sublime and very simple text editors is exactly what Nora talks about: flexibility and not having to be locked into any interface.

                                    Code is code, so students should fundamentally understand that notepad is no different from Ecplise.

                                    Sidenote: I always thought Ecplise and all other IDEs are clumsy because there’s so many buttons.

                                    1. 2

                                      What they can’t do, unless they’ve figured it out on their own, is operate a computer outside of the confines of the IDE they’ve been taught.

                                      I see this far, far too often; tool blindness.

                                      Many times I’ve done “magic wand” thinking, wondering how I would teach programming. Honestly, I think I’d start with simple text editing skills. Master that, then OS scripting. Then move to a simple build using a handful of files. Only later would I get into more complex things like IDEs. When we start with IDEs, the students never get around to the basics. I’d rather them have a firm and complete grasp of just a few things than a loose connection to a couple of dozen things that all kind of hang together to form a solution. There’s too many cards in that house of cards.

                                      1. 1

                                        That’s why I think the focus on high level languages is bad.

                                        I’d teach baremetal raspberry pi assembler programming, or on x86 FreeDOS and Flat Assembler.

                                        The amount of cs grads I’ve encountered who can’t even write a simple program in assembler or C sickens me.

                                        1. 14

                                          The amount of cs grads I’ve encountered who can’t even write a simple program in assembler or C sickens me.

                                          If you take the stance that CS is training for programming jobs, then there are a multitude of programming jobs where this doesn’t matter. Especially writing in assembler. (We should let C die a slow death anyway. And I say this as someone who works on a C compiler for a living.)

                                          If you take the stance that CS is learning to think computationally and understand computation, what evidence is there that knowing C and assembler even matter in this regard? I’ve never heard of anything about it. Everything I hear about it is dogma and completely unsubstantiated.

                                          1. 3

                                            If you take the stance that CS is training for programming jobs

                                            I have to say: I absolutely do not take this stance. University traditionally has been all about learning all about and advancing a subject or series thereof. A place of knowledge and research.

                                            It is a really bad trend that, for many universities and degrees, it is turning into a “prepare for job” course like the alternatives to university.

                                            to think computationally and understand computation, what evidence is there that knowing C and assembler even matter in this regard?

                                            That how computers work do not matter on understanding computation is quite the claim. I believe the burden of supporting this claim is with you.

                                            1. 3

                                              The comment by @matklad on this thread is proof of how very far a beginner can get without getting around to the so-called basics.

                                              1. 1

                                                It’s kind of amazing, but ultimately I have to feel sorry for the person who had to do it with hands tied on his back, and can’t help but wonder how much faster and farther they could have got otherwise.

                                                1. 4

                                                  For that matter, along the four hours of Pascal we also got exposure to CS-flavored Boolean algebra (Karnaugh maps for minimization, and Boolean scheme modeling in some GUI program). This bit of knowledge was fun, but irrelevant for the polynomial things. We didn’t talk about assembly and compilers, and the lack of that knowledge didn’t harm, at that time.

                                            2. 2

                                              Came to this thread for exactly this idea. When I’ve taught uni students Java (which is only one of a few languages I’ve taught to students, not all of whom were in CS) we’ve used BlueJ which is an environment that removes the thinking between “open environment” and “type in Java”. That’s good for when you want students to explore an algorithm, coincidentally in Java notation, and bad for when you want them to learn how professional programmers write software, which is often done in Java despite the protestations of the RESF.

                                              Agreeing with or even understanding critiques of programming tooling in a CS class requires acceptance of what a CS class is for, and there isn’t wide agreement even among educators. Where I teach, plenty of the undergraduate classes don’t even use a computer because the goal is to understand computation, not to make a computer implement a customer’s requirements.

                                            3. 8

                                              I don’t think optimizing Computer Science education for the current local maximum of C-on-Unix is future proof.

                                              Anyway, most recent CS grads I’ve gotten to know online are very unhappy that their first developer jobs don’t allow them to use Haskell for everything.

                                              1. 1

                                                May I ask why? I agree that learning a systems programming language is probably a boon, but I imagine that C++ would be the language of choice at many institutions.

                                                1. 2

                                                  I guess @ethoh is saying that universities shouldn’t be vocational schools, factory lines churning out programmers that know only one or few more things.

                                                  I think students need to learn both, the high-level stuff and the low-level, from web servers to the basics of digital electronics. Assembler is not a very complicated language. It is useful for a student to understand how do you add two numbers using just two registers and an instruction. I wouldn’t have students write a game in assembler. But writing a number guessing game in a high-level language first, showing the compiler assembler and then being able to study what it does is a valuable skill.

                                                  I would teach the full spectrum with a parallel curriculum of two courses, a programming 101 teaching some basics of a high-level programming language, and a computer engineering basics teaching the low-level bits. The first one of the high level one starts with hello world in Java/Python/X, moving on to more complicated applications focusing on more abstract problems, while the first class of the low-level one starts from boolean logic, moving on to logic gates, flip-flops, registers, von Neumann architectures, and so on.

                                                  Eventually, about one third in of the curriculum, these courses would meet, so to speak; we would have now a sufficient understanding of the high-level language and the compiler so that we can inspect the raw assembler it generates, which we would then be able to understand given the low level knowledge we’ve accumulated. Then they would again diverge, the high-level language builds something more interesting and tangible, like a compiler, a web server, a game, while the low-level part goes on to study different microarchitectures, computer architectures, microcontrollers, embedded operating systems, and so on.

                                                  By the end, the students would understand what the abstract machine C describes (a PDP-11) is different from the computers we have today, and how compilers, operating systems, even programs, make all sorts of interesting compromises to be able to perform efficiently. They would understand why your JavaScript web app was also vulnerable to Spectre.

                                                  1. 2

                                                    This is almost exactly how things are done at Georgia Tech, where I’m a student. There’s some variability depending on your specializations, but almost everyone goes through the sequence you’ve described. I’ve found that it’s given me a really solid foundation for learning the more practical parts of software engineering (SCM, web dev, building stuff with the cloud, best practices, etc), most of which I’ve learned on my own.

                                                  2. 1

                                                    C++ can be used to teach systems programming, but it is too much of an invitation to abstract away the machine. C is less problematic in that sense, but it is no replacement for assembly.

                                                2. 1

                                                  Or any other specific IDE for that matter.

                                                  1. 1

                                                    I definitely agree with this, and I personally found IDEs cumbersome when I was trying to learn programming.

                                                    But, I am curious, are there fields and/or career paths where you can just stick with programming in an IDE and never really have to worry about the operating system or network system your code will run in?

                                                    Scientific programming comes to mind, but what others?

                                                    1. 4

                                                      Oh, definitely. Windows application programming, for one. I don’t think it’s acceptable for the CS programs to cater only to that kind of career path, though!

                                                    2. 1

                                                      We were forced to use a bare bones editor in Java classes at school for reasons like this: learn the concepts, not defer learning. Only for me the easiest way towards really understanding something was to use it in a realistic context.

                                                      I knew and enjoyed programming and got a B (second best) but decided Java was not for me and only began using it and enjoying it after I started working with someone who showed me how to use eclipse.

                                                      I know school shouldn’t tie you to one product but teach the concepts, and I agree that knowledge of operating systems concepts and the differences between them are important but that doesn’t mean schools shouldn’t teach how to use available after they have in the first week explained how to compile from the command line. Especially when the tooling is free and open source.

                                                      BTW: the microcontroller course I took was much more reasonable and taught assembly first, and then immediately followed up by teaching C, explaining how to inspect the generated code in the process.

                                                      The result was vastly different: in the Java case I got a distaste that lasted for a years until someone took the time to help me. In the microcontroller case I enjoyed both assembly and C.