Year 1

You are introduced to the basics of every CS degree. The courseworks will hold your hand with well-defined specs and robust testing suites.

Programming 1

Covers the basics of programming from writing your first hello world to the fundamentals of Object-Oriented Programming. We used Java, which I remember learning in a single night before the first day, only to realize that was unnecessary.

Programming 2 (electric boogaloo!)

Continuation of Programming 1 that introduced us to actual programs with large codebases. Introduction to Git/GitHub and Apache Maven as part of a Tetris clone coursework (TetrECS). I strongly remember that we could manipulate the raw scores and upload them to the "multiplayer" server, meaning anyone could set a high score illegitimately (I did no such thing :3).

Computer Systems 1

This module covers the basics of computer hardware and architectures, We got a Raspberry Pi 3B+ to play with, which I did definitely return and definitely didn't keep till the end of my degree. (There's a not so small chance that this Pi was eventually used as the platform for my ThymPi final year project).

Foundations of Computer Science

This module was basically the "Linear Algebra and Discrete Mathematics". Also known as the module that will weed out half the first year cohort.

Algorithmics

This module was just "Data Structures and Algorithms". I liked that this module was eventually built upon further in "Theory of Computing" in 2nd year, in the computability and complexity sections of that module.

Data Management

This module was basically "Relational Database Theory and Intro to SQL". I made some simple SQL queries, used MySQL a bit and wrote some simple unix Bash scripts.

Software Modelling and Design

This module was eventually made into a 2nd year optional, which it should have been from the start! Formal software design and verification is a huge field, and it's definitely useful to learn, but it is way too complex for an amoeba-brained freshman CS student to grasp and appreciate. We made a simple management system in the university's proprietary "Event-B" language and tools, to this day, my cohort regards the name "Event-B" as the language that shall not be named.

Professional Development

This is the token "career skills" module that for some reason, universities put in first year, instead of later in the degree. Freshmen don't have any real skills or experience, nor do they have any idea what they want to specialize in, asking them to write a CV and a career plan at that stage is asinine.

Year 2

Here you build on the basics of CS that you learned in the previous year. You are also given more freedom with your courseworks and given more autonomy and responsibility.

Programming 3

I do not know why the University of Southampton loves functional programming so much, a lot of CS degrees don't even cover it anymore, since it's barely used in production code. We taught the functional programming paradigm in general using Haskell, in contrast to the procedural and object-oriented paradigms we were used to by this point.

At the time, I didn't see any use for this, it was just something I had to do to pass the module and get it over with, partly because the lecturers did a poor job of explaining the actual reasons for using a functional programming approach.

In hindsight, I now appreciate and embrace functional programming as a useful paradigm in certain contexts. I think this is partly from becoming one of the dozens (yes, entire dozens!) of expert Haskell developers. However, I also started using some functional principles in other languages like Python and C, where I can now appreciate the benefits in code clarity, functional predictability and statelessness.

Software Engineering Group Project

We were put in groups of 6 and told that we had to make a big software project together. Then we were allocated some seniors to act as customers who gave us continuous feedback. We basically had the freedom to organize ourselves however we wanted, but the course strongly guided us towards the best practices. We used GitHub to manage collaborative programming, discord to have weekly scrum meetings, and made UML diagrams and burndown charts, like the good AGILE practitioners we are.

We made an app to calculate runway distances, meant to be used by airports. We split the app using an MVC design pattern and I was the "lead backend developer" and part of the software architecture sub-team who designed the UML class diagrams and data flows. In other words, I made all the logic for the calculations and made the app actually do stuff and not just be a fancy UI.

Theory of Computing

This module was the continuation of "Algorithmics" from the previous year, where we dug into computability and complexity. There was also some stuff about automata, Turing machines and context-free grammars. Which are really cool computer science theory things that I would have to study for many more years to be able to explain them and do them justice.

Programming Language Concepts

This module was a bit of a curve ball, we had heard about it in first year and in the first semester of second year that we would eventually have to design our own interpreter. Obviously, this was terrifying news to first years who had just about figured out how to use GCC and Clang to compile their first C helloworld.c program. We had heard rumors of the module where we would have to "design and code our own compiler" since 1st year. This module introduced us to compiler theory, the layers of abstraction from machine code to high-level languages and how compilers/interpretersa actually work. We were then put into groups of 3 to make our own programming language, which you can read more about on its dedicated project page linked below.

Computer Systems 2

This was the only optional module that I was able to take in year 2, that I chose because I love hardware and enjoyed systems 1 in 1st year. This module built on systems 1 and introduced us to scheduling and prioritization on an OS level, firmware concepts, system buses, and embedded systems theory.

We were also just given a Pi Pico microcontroller and literally told to have fun and make some cool projects with it. Literally, we were told that what we did didn't matter, as long as we built something, which I really enjoyed. This module really cemented my love for low-level systems programming and embedded programming.

Intelligent Systems

This module was "Intro to Machine Learning and Artificial Intelligence" as it went from the maths background for AI and the theory behind neural networks to how to implement them. It was quite interesting but I found it to be too bogged down in the theory, it would have been way more engaging if we were allowed to do some more hands-on stuff. Imagine how cool it would have been if we had a coursework where we implemented our own neural network and trained it!

Distributed Systems and Networking

I don't know why this module wasn't split up into 2 smaller ones, it basically was when we took it anyway. We started with the networking half which was as expected, an introduction to network architectures following the OSI 7-layer model. That was pretty unremarkable, pretty theory heavy and more or less got the points across. This module was basically 2 modules in one. The networking half came fist and was the "intro to networking" module that covered network architectures following the OSI 7-layer model. The distributed systems part of this module was all about distributed systems theory, concurrency, consistency and reliability.

We were then told to implement a networked distributed file system in Java, which was really fun as it was a really neat way of tying everything together. However, the deadline was too short in my opinion, so I wasn't able to build something really fleshed out like I would've wanted.

Interaction Design

My cohort called this module "professional development 2" as it was the only non-technical module of the year. Though in actuality, this was essentially a Human-Computer interface theory module with an emphasis on User Interaction and Experience. Definitely a useful module to teach future developers, but I think it could have been done in a lot more technical way to keep us NERDS engaged.

Year 3

Here you get to be completely independent, you get to choose your own modules and your final year project topic. All the modules are now extremely specialized and take you up to near-expert level in the topics they cover. The final year project is also the first large and unique project you will make in academia (in theory).

Advanced Computer Architecture

I chose this because I love hardware and wanted to continue learning what was set up in systems 1 & 2 in this regard. We learned about CPU design from basic digital logic to a full superscalar pipelined multicore SoC design. We also covered assembly and microcode in a bit more detail, such as comparing RISC and CISC performance. We also covered a bit of highly parallel (GPU) architectures which was fun because I can now understand gpu whitepaper block diagrams!

Real-Time Computing and Embedded Systems

I loved playing with the Pi Pico in systems 2, and loved embedded programming, so I picked this module. The real-time systems part of this module covered real-time operating systems theory and had us actually play with scheduling algorithms in "Cheddar". the embedded systems part of this module had us installing FreeRTOS on a Pi Pico and trying out some practical process scheduling.

Computational Biology

I thought this was going to be able biologically inspired algorithms, systems and computing. This turned out to be a bioinformatics introduction course, which is basically large data set statistics. I was duped into doing scientific compute statistics with NumPy, Pandas and Jupyter Notebooks!

Web Architecture and HyperText Technologies

When "Computer Vision" turned out to be more digital signal processing and maths than the machine vision I wanted to actually do, I switched to this module. This module turned out to be much better than I expected, it taught me the web architecture in depth as well as gave me a deep understanding of REST and HTTP. I didn't realize this at the time, but when I ended up making my own website (this one!), I found myself connecting a lot of the concepts learned in this module to this practical experience. We were also told to play with the university's building information API, document it and propose improvements to it. This was incredibly fun and was a great opportunity to play with tools like curl, Wget and Postman.

Engineering Management and Law

This was the only "required" module in 3rd year, and covered some basic and trite "management" theory. The law part of this module was fun though, as we got to read about past legal cases, mostly involving engineering failures.