Hello all,

I made a (way too long) video where I talk about the "how" and "what" of current CS education and what I would do differently (Specifically: CS education of universities of applied science, since this is the only experience I have).

I think it wasn't that good, but I wanted to share it nonetheless (I don't have to speak English a lot in recent times, so it's always a bit slower than when speaking German I think; watching it on 3x is quite possible)

I mainly did that video since the possibility came up that I might be allowed to have a course at the university I work at. Given that there already has been a fishbowl about this topic, I don't know if there is a need for a discussion here, but I would be happy anyways.

Summary of the video (the video is, of course a bit clearer though): (After writing this, maybe a blog post would have been better, but now it's already here :D)

how: I think there is a clear lack at university of watching experts program; it's either theoretical stuff one gets taught or one has to do practical tasks oneself

what: A big focus on OOP which also comes with a very abstract reasoning about computers. Additionally, from the three main skills of programming ("program structure", "algorithmic thinking" and "dealing with errors/debugging") only the first one is really taught (by following OOP / SOLID / Clean Code principles etc). Essentially, students never learn alternatives, they are kind of forced to do their programming in the exact same way every time, which is obviously a bad thing

The last part of the video is me showing the beginning of a little game I have written that was meant as a little example of what one could do. The reasoning for doing a course on a game in C was that it forces you to write non-OOP code and given that you have to update the visuals ~30 times a second, you also have to think about your computer in a less abstract way. Otherwise, the performance of your computer is not enough for drawing such a high amount of pixels.

If you have read until here (or even considered watching the video), I am very thankful.

One thing that might also be useful is to encourage reading other programmers code.

For example when trying to figure out ImGUI things, trying to read Dear ImGUI's code. It's also useful to keep aware of different ways to program (for example I don't use C++ anymore, but by reading some libs writen in C++ I have a bit of understanding on what was added in the language since then). And you can discover things (API, algorithm...) that you weren't aware of.

And I don't consider that to be similar to watching in (sic) expert program.

You are right, I didn't consider looking at someone's code at all. Thank you for bringing that up.

I assume, that listening to an explanation when the code is written is easier than looking at code without any idea of what is going on. However, this clearly is an important skill as well and I should probably train it myself.

I looked at codebases for semester-long projects or my thesis, but I guess when being just meant as a small part of a course, it is not that easy to incorporate reading a lot of code: "Homework: Read this codebase until next week and tell me what is fancy about it"

However, while I haven't been in such a course, there have been voluntary courses where you basically read a paper each week and then the contents were discussed during the lecture. Such a setting could actually be quite cool for reading code.

Umm, I want to talk about, I forgot, let's talk about something else first... Three minutes in, the viewer is gone without knowing anything. I would start with the actual content and skip everything that is not relevant to the viewer.

Zooming/cropping closer to the face, good scene light, clean backdrop, careful color grading, introduction music and animated logo also helps to keep viewers focused on the content.

In my University, there was a "large scale programming" course where we would optimize the CPython reference implementation, written as object orientation in plain C using explicit virtual function tables.

There was also a "test methodology" course, which many programmers should have taken.

The only practical course missing was Git version management, because most startups struggle with choosing between merge (for combining a feature branch into the main branch) and rebase (for cleaning up a pull request).

The most useless theoretical course was about "compiler design", which focused mostly on file parsers that you cannot actually write a compiler using, and seriously flawed compiler-compilers full of bugs (picking a path by random, then walking into a dead end without even looking where the path goes).

Thanks for the feedback.

Yeah, I considered deleting the video afterwards, but given that I started this thread and I was not sure how to delete that, I kept everything as is.

Maybe one day, I'll make a better version.

The python thing sounds interesting, what was the test methodology course though? Was it about debugging? Or how to write tests?

Given that we had several free-to-choose, semester-long projects, the git thing was not too much of a problem I think.

The Python project was about optimizing the interpreter to go faster, just so that we would understand how to work in an overwhelmingly large project. It taught the importance of responsibility separation between modules and good documentation in the real world.

It was common that students only worked alone on their programming projects, so new workers had to be taught how to use Git when starting to work.

Okay, that project really is overwhelmingly large when just looking at it. I'm really wondering how the course worked. Was that a mix between lecture and project?

Maybe at one point, I will google around for courses like that in other universities.

It was both lectures and projects, but the project was the biggest part. Many students had to face the reality of programming for the first time after all other courses had tiny toy examples that can make any paradigm look good in theory. CPython was a balancing act between being a reliable reference implementation and being decent in speed when compared to JIT optimized IronPython.