UGent Courses: A Review
Published on August 10, 2013 under the tag ugent
Last month, I graduated from Ghent University. This seems like an excellent time to review all the courses I took, and I hope this might be useful to future or current UGent Computer Science students.
This is purely my own opinion and I do not represent my classmates. One should also note that I review the courses as they were at the point that I followed them, and I know that some of the courses have been revised at this point. I can’t comment on the revisions since I didn’t take any courses more than once.
We only had mandatory courses in our first year.
Algorithms and Data Structures I: (Algoritmen en datastructuren I): Quite simply a solid first course on algorithms and data structures.
Applied Formal Logic I (Toegepaste formele logica I): Some parts about lambda calculus, and some on simple logic laws. Elementary.
Calculus I (Analyse I): It was a calculus course. It was quite boring.
Communication skills (Communicatievaardigheden): This seems to be widely regarded as a useless course. However, I have given quite a few talks in the past few years, and I do think this course has definitely improved my skills when it comes to making slides.
Computer usage (Computergebruik): This course teaches some UNIX and command-line basics. The exercises and practical exam focus on esoteric problems which are hard to solve using the given tools. While this makes it fun, challenging and interesting, the course comes with a big “Do Not Try This Stuff For Real”-warning.
Discrete mathematics (Discrete wiskunde): Quite interesting, I guess. Kind of hard as well.
Laws of Intellectual Property (Recht van de intellectuele eigendom): The only mandatory law course in the Computer Science program. It’s well-taught but the subject remains plain and boring.
Linear Algebra and Geometry (Lineaire algebra en meetkunde): I feel like this is a really interesting, vastly underrated course at UGent. The main problem with this course is that all exercises, and even the exam, could be solved by copy-pasting previous or example exercises. Hence, no one even bothered to really study this.
Programming I (Programmeren I): The lessons are pretty good, but it really teaches Java instead of “Programming”. I guess this course suffers a bit from an Everything-Is-An-Object-Even-When-It-Isn’t-symptom. I believe it would be more useful to start out with simple procedural programming and teach that well, then introduce Object-Oriented programming later as a natural transition by coupling datatypes and related procedures.
Programming II (Programmeren II): This course was basically about two things: the Swing framework and the corresponding interpretation of Model-View-Controller. I don’t think a lot of interesting materials are taught here. However, this course came with a project, which yielded really valuable programming experience.
Scripting Languages (Scriptingtalen): Basically the continuation of Computer usage. Made us do seemingly impossible stuff with arcane tools (think XML processing with
awk). This made the course fun but I’m not sure if it was that useful, since I hardly remember anything about
awk and only use simple
sed commands (as opposed to the stuff we had to pull off during the exercises – whaddup, hold buffer?).
In our second year, we were allowed to choose a single optional course.
Algorithms and Data Structures II: (Algoritmen en datastructuren II): Largely a continuation of Algorithms and Data Structures I. More algorithms, more data structures. Not a bad course – the professor really knows this stuff and is very enthusiastic, which made the lessons quite fun.
Applied Formal Logic II (Toegepaste formele logica II): I actually do not quite remember anything specific that I learned in this course. This course seems mostly unnecessary.
Calculus II (Analyse II): See Calculus I: same shit, different year.
Computer Architecture (Computerarchitectuur): This teaches some essential basics of how a computer works. I feel like this course belongs in the first year rather than the second year. Very well-taught and the lab sessions are very cool.
Databases (Databanken): I think this course should be called “History of Databases: Where we start out with ancient history and end in the 90s!”.
Software Development I (Software-ontwikkeling I): I already wrote a post on this course, which can be found here. The gist of it is that we were taught some C and C++ in this course. To quote Ron Swanson: “Never half-ass two things: whole-ass one thing”.
Software Development II (Software-ontwikkeling II): In this course, we had to do a small project with a team. That was really interesting and we learned a whole bunch from it. In the end, the teaching assistants graded the project without judging the internal design of the project, which we thought was quite lame. In addition to this project, there were some lessons and lab sessions. Both were useless and uninteresting.
Multimedia (Multimedia): Some important multimedia fundamentals, supplemented by a collection of mildly interesting trivia on widely used formats such as VRML. This course didn’t really appeal to me.
Probability Calculus and Statistics (Waarschijnlijkheidsrekenen en statistiek): Another fundamental but kind of dull course. Due to lack of time we didn’t properly see statistics, which I think is a bit problematic.
Introduction to Bio-informatics (Introductie in de bio-informatica): I chose this course because I thought it would be challenging and interesting. It turned about to be only slightly interesting and much less practical than I had hoped. I vaguely remember searching online databases for property X of protein Y without even knowing what X or Y was. Hell, I still barely even know what a protein is. I recommend only taking this course if you have a real interest in biology.
Algorithms and Data Structures III: (Algoritmen en datastructuren III): See Algorithms and Data Structures II: same professor, different subjects. Pretty much my only complaint about this course is that the chapter on distributed algorithms seemed to date from a time in which distributed algorithms were not actually used. Yep.
Communication Networks (Communicatienetwerken): This was a pretty useful one. Some stuff on networks, and commonly used protocols on different layers such as IP, TCP/UDP, HTTP. The more advanced topics included IPv6, IPSEC and VPN. The lab sessions were very well set-up and intriguing.
Cross-Course Project (Vakoverschijdend project): Build a simple webapp. A pretty nice experience, altough building a such a project over 12 weeks makes you focus on Get Stuff Done rather than Do Stuff The Right Way. Makes you dislike your team because they’re all incompetent.
Data Communication (Datacommunicatie): Definitely deserves a nomination for all-round worst course in the program. The subjects are dull and they are taught in a deadening way. Attending the exercise sessions is an utter waste of time. The exam included solving an massively huge but simple exercise: I can’t remember exactly what it was but I guess it compares to multiplying a few 10x10 matrices with pen and paper: clearly the best way to check that one understands matrix multiplication.
Introduction to Electrical Engineering (Introductie tot elektrotechniek): This course was pretty hard and I am still undecided on whether this should or should not be a mandatory course – most of it seems only related in a very indirect way. Nonetheless, I kind of enjoyed knowing a bit more about this stuff, although I forgot most of it soon afterwards.
Internet Technology (Internettechnologie): Quite simple, completely useless.
Formal Languages, Automata, Complexity (Formele talen, automaten, complexiteit): I thought this was a dull course, but I remember a number of concepts we saw in this course (e.g. the distinctions between regular and context free languages, the halting problem) really clearly so I guess it was not bad after all.
Operating Systems (Besturingssystemen): Regardless of the name, this pretty much feels like a continuation of Computer Architecture. Some intriguing low-level stuff is taught here, and the course has great lab sessions as well.
Scientific Computing (Wetenschappelijk rekenen): Well-taught and quite interesting. I barely remember anything from this course though: except the fact that numerical computing can be hard even when it seems easy. Therefore, one should just use existing libraries and applications.
Economy (Economy): Probably one of the easiest courses at UGent. I was doing a lot of open-source development and other exciting stuff at this time so I didn’t want to waste too much time with another course. Well, I never attended any lessons and studied less than two days as exam preparation – so I think it deserves the title.
Programming Languages (Programmeertalen): This course simply boils down to reading Concepts, Techniques, and Models of Computer Programming and programming a bit in Oz. But hey, it’s a really good book, and Oz is a fun language.
Advanced Computer Architecture (Geavanceerde computerarchitectuur): Another nice course on low-level stuff. We had to do some research for this as well. That was cool, but unfortunately, there were lots of other projects in this term, so the research projects didn’t get the attention they deserved.
Design of Distributed Software (Ontwerp van gedistribueerde software): Except for some chapters on MPI and a few interesting algorithms, I found the subjects in this course extremely boring or pretty much useless.
Design of Multimedia Applications (Ontwerp van multimediatoepassingen): This course had challenging and interesting projects to work on. I didn’t really like the theoretical classes and found them rather shallow and untechnical.
Multimedia Networks (Multimedianetwerken): Another course containing a wide variety of subjects, sometimes related, sometimes not. Teaches you a whole bunch of facts about backbone networks and routing in these networks – most of which I forgot about a week later. Some of the lab sessions were quite cool though.
Queuing Theory (Wachtlijntheorie): I can figure out basic queues and I guess I can look up other models if I ever need to. I’m not sure why we need an entire course on this subject.
Software Architecture (Softwarearchitectuur): Spend an entire term writing documents and making presentations about a product you’ll never end up coding. Earn bonus points for hypothetically earning money and win the game if you manage to out-bluff the other teams in terms of complicated design patterns and buzzwords.
Software Design Project (Software-ontwerpproject): Now you get to actually implement the product you designed in Software Architecture. Only, you’ll cut as many features as you can first, add a whole bunch of others, scratch those again, redesign it and then still code something else entirely. The end result might be a total turd but at least you’ll have a Test Manager ensuring you that no tests failed so everything will work as expected, and a shitload of pretty presentations to convince clients around the world.
Software Management (Softwarebeheer): This (extremely dull and completely useless) course has made me realize that Dilbert must be based on actual facts.
Information Security (Informatiebeveiliging): I liked this course. It’s practical and gets technical, while still providing a very good high-level overview.
Functional and Logical Programming Languages (Functionele en logische programmeertalen): Since I’m an avid fan of functional programming languages, the fact that I enjoyed this course will probably not be a suprise to you. I’ll just add that I liked the teaching style, and the combination of two paradigms/languages (Prolog and Haskell) which highlighted the strengths and weaknesses of both.
Formal Systems Modelling for Software (Formele systeemmodellering voor software): A lot of subjects lie in the intersection of the Applied Formal Logic I/II and this course, so there was a lot of repetition of an already quite dull field. We did get an interesting ACL2 project which I liked a lot once I sort of got into it.
Information Management (Informatiebeheer): A variety of subjects: Data Mining, B-Trees (we already saw that), how filesystems work (what?), Data Warehousing, mobile databases (what??), storing geographical POIs in a DB (what???). The practical exam also deserves a nomination for Lots-Of-Calculations-Showing-Absolutely-Nothing, although in this area it still loses to Data Communication.
Compilers (Compilers): A good course on compilers which mostly interesting lab sessions. This course should be mandatory rather than optional in any Computer Science program.
Movement and Sports: Now and Later (Bewegen en sport: nu en later): I took this one mostly because it seemed like fun. It was less fun than I expected, but still pretty easy (the other reason I chose this course).
Business Law (Ondernemingsrecht): I don’t ever want to study anything like this again as long as I live. The only thing I remember is that starting a Business brings with it a awful shitload of legal work in Belgium.
Internship (Stage): I worked for 3 months in Tokyo, coding Haskell, with amazing people at an awesome company. It was fantastic.
Investment Analysis (Beleggingsleer): I chose this course because it related to my Internship. While it gave a pretty good high-level overview, it wasn’t really practical and we skipped some of the most interesting subjects (futures, options).