Curriculum

Now that the study program’s over for us, and after the three years I have written about our experiences (and agonies) with the over two dozen courses we had to attend, I thought I would summarize the entire curriculum for the benefit of my (mostly non-existent) readers. Not the way it’s written in the regulations, but the way we experienced it. As a reminder, this was (and is) the Applied Computer Science program at UAS Hamburg.

Basically the courses, for us, were organized in what one might call a number of “tracks”–and then some assorted stuff. At the center was what everyone considered the “core” subjects, or what one might call a programming/software engineering track, consisting of

  • Programming Technique and Programming Methodology I in the first term–technically two subjects with two separate exams,  but always taught by the same professor and universally known collectively simply as “Programming I”;
  • Programming (Methodology) II in the second term;
  • Software Engineering I in the third term;
  • Software Engineering II in the fourth term;
  • Architecture of Information Systems in the firth term.

They really nicely built on one another. Programming I introduced the basics of object-oriented (always!) programming, using Ruby (one can discuss this choice); Programming II moved on to the “real” stuff with Java. Software engineering introduced us to higher-level subjects like requirements, use cases, design patterns and so on in one term, then added project management, risk management, process models etc. in the second. Architecture, however, was in some ways repetitive. True, with architecture models it went to an even more abstract level of building software, but other than that it repeated things like UML, design patterns, microservices in the cloud, etc. In my thinking it might not have warranted a full term. On the other hand, things we never heard about (much) were programming paradigms other than object orientation, say functional programming.

Even though this was decidedly the central part of the program, in terms of effort and anxiety it was, for the first three terms, easily dwarfed by what we considered the math track, consisting of

  • Foundations of Mathematics for Computer Scientists in the first term;
  • Automata Theory and Formal Languages in the second term;
  • Logic and Computability, also in the second term;
  • Concepts and Algorithms of Graph Theory, in the third term;
  • Algorithms and Data Structures, also in the third term.

Since they were all five of  them taught by the same two professors who in turn taught nothing else, and since they clearly built on one another, they appeared very much of the same kind. However, actually there is a curious twist in this sequence. Math was very basic and, as I said earlier, taught barely the simplest mathematical necessities for following a computer science program. Automata theory and logic, however, were extremely theoretical. Conversely, graph theory and algorithms, while clearly building on the previous courses in the math track and still full of theoretical concepts, contained a lot of things that were applicable to real life problems (say, flow networks in graph theory) or programming (algorithmic complexity), so this is where the programming and the math track came joined, in a way. Also, the practica really expected you to be able to program, so it made complete sense that these subjects were being taught in the third term, after we had completed the programming courses.

A third, for us clearly delineated track we used to call the technical computer science courses because they were all close to the metal and invariably taught by professors from the technical CS study program who loved words like register, platform, process, protocol, port and said “read the RFC” about three times per session. This track included

  • Computer Architectures and Machine-Oriented Programming in the second term;
  • Operating Systems in the third term;
  • Computer Networks in the fourth term;
  • Distributed Systems in the fifth term;
  • IT Security in the sixth term.

Again, these somewhat built on each other, though I would say IT security was closer to computer networks than either was to distributed systems. Generally I think with five full lectures they had a little more weight in the study program than strictly necessary. Particularly, machine-oriented programming, where we learned all the intricacies of writing Assembly, and operating systems, which introduced us to concepts like say paging or locks in often needless detail, are together covered by a single course in almost every other university I know of.

Likewise the other three could easily have been packaged in just two courses. I am not saying the things we learned here are not fundamental for anyone who seriously wants to develop software for a living. In fact, in this internet age, a lot of this stuff could be considered part of any good general education. Only when hearing computer networks did I finally understand what happens when I write an e-mail or open a website. Before IT security I never knew why my browser objects to expired certificates. But yet–the painstaking detail was usually unnecessary for a good understanding. Not to mention that in any case we forgot 80 percent of it right after the exam.

Taken together, these three for us clearly delineated tracks account for 16 of the 21 mandatory courses in the study program. The other five are more diverse. They include

  • Foundations of Computer Science in the first term — this was reasonably entertaining and presented the basics of logic and of how computers work in a colorful and relaxed way;
  • Databases in the second term — in many ways highly technical, and certainly too early in the program to be of any use, which rendered it primarily theoretical (I didn’t really have any need for what we learned here before I used a PostgreSQL database for my bachelor thesis project);
  • Intelligent Systems in the fourth term — again, highly theoretical, and for many (but not me) the first contact with logic programming, data science, and neural networks; it might have been considered the final math course, in some ways;
  • Business Administration I and II — taught by demotivated (in one case) and hyper-motivated (in the other case) contract lecturers, and basically completely useless, just intended to look good on our certificates.

To round out the program, from the fourth term we had to attend elective courses, starting with the curiously named “compulsory choice modules” (Wahlpflichtmodule), of which we had to do three over the course of three terms. In addition, there was a project course and a seminar in the fifth term. In my case I rarely ever got my first choice, ending up doing two of these courses with the same professor. All in all I attended

  • Adaptive Systems (module) — this is where I fell in love with neural networks and built my game AI that never worked;
  • Learning Agents (project) — neural networks again, this time genetic optimization;
  • Process Mining (module) — unexpectedly primarily algorithms;
  • Certified Tester (module) — plenty of rote learning for a certificate I won’t need;
  • and the seminar which doesn’t even have a subject (you just choose a professor) — this is where I gave my talk on functional programming in Scala.

In addition, my co-students also attended three ungraded social science courses, but since I have a degree (several, in fact) in history, this requirement was waived for me.

To me the program made a lot of sense. Starting from the basics, we thoroughly learned first to program, then to design software systems, and to organize our work. We worked individually, in pairs, and in teams, but the emphasis was always on practical applicability. Of math and the technical, hardware-oriented stuff we got what we needed to get along in the core subjects, and then some more for a general understanding, in order to make us fully rounded developers and allow us to expand into other areas if needed, but not more.

Compared to people with a bachelor’s or even a master’s degree in CS from say UHH (where students do a lot of math and theory, but only one programming course and with luck an elective course in software engineering), or most other universities for that matter, we definitely learned, above all, to develop software. And we learned it from professors with a lot of experience in the industry, and with the most recent technologies too. Anybody with a Applied CS degree from UAS, in my opinion, can be employed in that role–software developer, that is–right away without any additional qualification, anywhere in the IT industry. Particularly since we also learned to quickly adapt to new technologies and concepts. We are truly allrounders.

So my decision, three years ago, to choose UAS over UHH for just this reason was definitely right. I have never regretted it.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s