ATypical CompSci

Today, I'm launching ATypical CompSci, a channel of Computer Science videos aimed at me about three-and-a-half years ago (and others in a similar situation), as I started my degree in Computer Science at Cambridge.

The first batch of released videos are (unfortunately) a lot of ground-work: the next batch of videos (lists - sets, matrices, graphs, sorting, dependent types) will be far more fun.

What's it about?

My first series, Solving Problems in Computer Science, is (hopefully) a pragmatic adaptation of the Foundations of Computer Science course that is inflicted upon first-year CompScis as soon as they arrive into Cambridge. In retrospect, I love this course and all it has exposed me to but at the time it was the bane of my existence. The course has been referred to by later students as "demoralising" which is a real shame, because the content is actually really simple and elegant (however, as I tell many of them, simple is not the same as easy). I'll be explaining how to solve the problems that come up in the course, and also how the way of thinking these problems encourage enable a person to tackle further aspects of theoretical computer science (with an emphasis on "Theory B" computer science, i.e. logic and programming).

Once I finish Solving Problems in Computer Science, I intend to branch out into functional algorithms and data structures, operational and denotational semantics, concepts in programming languages, logic and proof, types, separation logic, model checking, compilers and optimisations, formal verification, metaprogramming, and so on.

Why?

Two reasons. First, I don't want other students to go through the same, needless struggle I did when learning this material. I had to find my way and fight to my 'a-ha!' moments and until that point, I just thought I was stupid for not understanding something that pretty much everyone around me seemed to understand.

Computer Science is a young field, and I think academics have just been teaching things the way they learnt it without attempting to or realising the need to come up with other perspectives. Like with maths, if a student doesn't understand, they tend to blame themselves rather than the explanation. Unlike with maths, there hasn't been enough exploration of different explanations or perspectives on these topics. Case in point: if you search for linear algebra videos on YouTube, you find multiple different channels and playlists on the topic, each with many videos associated. However, if search for operational or denotational semantics, you find very little - a few research conferences, maybe one or two decent videos. I aim to fix that.

Second, I think that learning this material and perspectives broadens your programming horizons. I have noticed that it just takes one patient, well thought-out explanation to a novice to convince them of the value of a given concept - I know I've won when I either see a smile creeping across a previously confused face, or I get the response "Why doesn't everyone do that?"

An intuitive grasp of a rigorous, mathematical framework in which one can think about the challenges of programming (time and space complexity, memory management, concurrency, types, abstraction, correctness, optimisations and so on) can have real, tangible, benefits. For example, learning about the option type made me better at programming with potentially null pointers in C/C++. Learning about types and the Curry-Howard-Lambek correspondence opened my eyes to mathematics, specification (e.g. API design) verification (e.g. debugging). Learning about regions, lifetimes, substructural types and separation logic improved my ability to understand memory management, and I don't even know where to start when it comes to all the new perspectives I've gained regarding concurrency.

How is it different?

I want to strike a middle ground between the purely-applied view of programming (most materials on the web today) and the purely-theoretical view (most "Theory B" textbooks and papers). I want to show the theoretical concepts by implementing them in real code and explain them within an applied context as best as I can.

Sounds Ambitious

It will take time, for sure.