The Fifth Semester Experience


To write this article easier, I'll assign acronyms for some courses so I don't have to write its full name every time. Also, the acronyms will be taken from the Indonesian translation, so they won't necessarily match up with the English translation.

  • DAA: Design and Analysis of Algorithms
  • KASDD: Artificial Intelligence and Basic Data Science

For many of my peers, the fifth semester is supposedly the hardest semester in our computer science journey. This is due to the combination of some quite deadly courses, which are: Numerical Analysis, DAA, as well as KASDD. I have briefly touched on the difficulty of Numerical Analysis in a previous blog, so my fifth-semester journey is different than most. Despite that, I still have to agree that the fifth semester is the hardest when compared to others. I'll probably rank the difficulty of each semester in a different blog post later when I (hopefully) graduate.

Anyway, let's jump right in! So, in the fifth semester, I took 6 courses (total of 21 credits), which are (ranked from least to most difficult in my opinion):

  1. Image Processing
  2. KASDD
  3. Computer Networks
  4. Software Engineering
  5. Semantic Web
  6. DAA

Image Processing

This course is optional. Meaning that you can graduate without ever taking this course (although I think if you are a CS student you SHOULD definitely take it). The reason is partly due to my biased interest in computer vision, moderately difficult course, and a superb lecturer.

So, a little fun fact about me: I've always been interested in machine learning since I first heard about it (lol, cliche). For me, the ability to predict based on data is cool enough on its own. But now add a camera into the variable, and you can do even COOLER things with it! Think about medical examinations, law enforcement, and autonomous vehicles. There are all things that benefit quite a lot from computer vision. Of course, some of the use cases might be a bit dystopian (e.g: mass surveillance), but let's not go into that haha.

In this course, you will learn about image processing in the spatial & frequency domain, compression, color theory, restoration, feature extraction, deep learning, and object detection. Sounds complicated, but honestly most of the hard materials are only relevant for the quiz.

Regarding the course difficulty, it's surprisingly... easy? I mean, we learned some of the underlying math, but it's not really emphasized enough. Plus, the way the course is graded makes it relatively easy to get an A. In the syllabus, 30% goes to labs (6), 15% to quizzes (2), 35% to a group project, 10% to a forum and self-quiz, as well as 10% to participation.

Here's the thing: for each lab, the TA provides a tutorial. However, this tutorial is literally the lab itself but uses different images to process. Often, you can copy-paste the code provided in the tutorial directly into your lab. I don't know if that's intentional, but it made the labs pretty much a guaranteed 100. In fact, for five of six labs, I got a perfect 100, except one for 98. Which is basically 100.

The only remotely difficult part of this course is the quizzes. There are two of them, so each is 7.5% of your total grade. It is all MCQs, so you can not waffle your way out. I think it's basically a memory test. If you can consume hundreds of slides for a quiz, then you can probably get a good enough score. That's because they are theoretical questions.

Then there's the project. We worked in groups of five. The task was image segmentation on some plant data. Thankfully, we were allowed to use other people's papers for the segmentation itself. So mostly, the challenge was to create the report. It took me about 90 minutes to train the model using a deep learning approach, specifically using DeepLabV3+. Other members of the group worked on conventional image segmentation methods such as using color & thresholding or another deep learning approach such as U-Net. We presented our findings in front of the class, answered some questions, and that's about it.

I say that this is perhaps the easiest course this semester since it's almost impossible to fail it. The professor was kind and quite generous with the grading. The only difficult criteria are the quizzes, but that only accounts for 15% of the total grade.


Another biased opinion since I like the course more than others. I'll try to keep this one short since I just realized how much I've written about image processing.

Basically, you will learn about common libraries used in DS, such as NumPy, Pandas, and Matplotlib. You will be acquainted with data preprocessing, basic classification, and regression tree-based models such as Random Forest, then about dealing with imbalanced datasets, neural networks, and lastly clustering.

Like image processing, the labs are quite straightforward since a lot of the coding can be copied and pasted from the tutorial. What's interesting is that some of the labs have Kaggle competitions where you compete for bonus points. I think I was ranked first for one of them among hundreds of students :D

The bulk of the grade comes from midterms, finals, and a group project. I don't know how, but I managed to get satisfactory grades for all of them. Regarding the test, I think it's because since I knew that the test was open book, I could just focus on the essays more. And, um, yeah, I studied the day before (like 8 hours before the test) and focused more on all of the different essay types. It worked out in the end since the bulk of the points are from the essays anyway. For the group project, it helped that I teamed up with some exceptionally talented folks :)

Computer Networks

Truth be told, I didn't like this course that much. In CS, there are several types of courses. Typically, they are math-based, programming-based, and computer(?)-based. Math courses are like Calculus 1 & 2, Linear Algebra, etc. Programming-based courses are obvious. And lastly, computer-based courses are like Digital Systems, Computer Architecture, Operating Systems, and.. Computer Networks!

You'll learn about many different layers in the protocol stack, such as application, transport, network, link, and even up to the physical layer. You will also get a chance to learn about security in computer networks.

I have to admit, this is probably the most demanding course. There are 6 total assignments and 4 hands-on tasks. Along with that, there are also 6 quizzes, a midterm, and a final.

I think out of the entire course, the most interesting thing I learned was socket programming in Go. Which, coincidentally, is the first time I have ever touched Go.

Software Engineering

You actually spend a lot more time making diagrams than programming. You'll learn about many different software methodologies (the most well-known is probably agile). Of course, also learned about designing your software's use cases and creating the user tests.

You will decide early on what app you will create along with creating your team. Throughout the course, you will make the use case diagram & specification, analysis class diagram, design class diagram, sequence diagram, and other helpful diagrams. Only at the very end of the course will you actually develop the app using your preferred tech stack. We went with Next.js :)

My part of the project was quite ambitious. I created an AI-powered financial advisor searching feature. But to be honest, it's basically just text embeddings. After that, you can pay using Midtrans, and it will automatically create a Google Meet link with that advisor. As you can imagine, this involved many different APIs, and I learned a great deal about software engineering in the process.

What's funny to me is that I have already interned as a software engineer before taking the course and didn't manage to get an A here, hahaha.

Semantic Web

This is an interesting course. People are normally used to relational databases. This means using table(s) to store your data. But what if we used a different approach, such as graphs?

There are multiple reasons why graph-based databases might make more sense than relational databases. One of them is the fact that graph databases are a lot more flexible than relational. What does this mean? Well, imagine that you are creating an event. You know that there will be the name, start, and end date of the event. In traditional relational databases, you would typically create a table with 3 columns, which are name, start_date, and end_date. But what if we don't know the start or end date? Well, we would nullify that cell, right?

Now imagine if there are tens or hundreds of columns spread around different tables. I guess you could argue that these null values are quite ugly. One way you could combat this is to use graph-based databases. They are represented using a node and an edge. If the start or end date exists, then just create a node that represents the event object connected to the corresponding date node with a start_date or end_date edge. If you currently don't know the start or end date, then just don't create the node and edge! It's a simple yet powerful solution.


I already knew beforehand that this course was probably the most difficult. Algorithms and such aren't really my strong suit, which is why I try quite hard on it.

However, I was quite lucky because when I took the data structures and algorithms course in my third semester, a lot of the materials overlapped with the DAA that I took for fifth semester. For example, matrix chain multiplication algorithm and heapsort I already learned beforehand.

BUT, that only helped to an extent since the rest of the course is still difficult hehe. Homework was difficult, experiment tasks (basically comparing 2 algorithms) were difficult, and above all, the midterm and finals were EXCEPTIONALLY difficult.

Regardless, this course is fundamental for CS majors since you will learn about many different approaches to solving a problem. You will first start by learning how to analyze algorithms and their growth of functions. You know, if the algorithm runs in logarithmic, linear, exponential, or other magnitudes of N. Then you will be introduced to divide-and-conquer algorithms, heapsort, quicksort, order statistics, dynamic programming, greedy algorithms, backtracking, branch and bound, as well as NP completeness.

You can start to get a sense of the usefulness of this course. If you plan to work as a software engineer and want to ace the interview questions, learning these concepts is fundamental. Otherwise, you can try practicing at LeetCode (something that I'm currently procrastinating on).

To get a sense of the difficulty of this course, in the end, the professor decided to give everyone who actively attended the class an additional 5 points. This is HUGE. This means that if you originally got a B, your final grade will be B+ instead. Basically, one index up. I think they probably realized that too many students would have failed the course otherwise.


As a 3rd year CS student here at UI, I can fully confirm the rumor that 5th semester is indeed the hardest so far. Hopefully however, the difficulty starts to decline now that most of the mandatory courses are over. But who knows? Now that I'm taking a student exchange at NUS, maybe the rumor does not apply to me. In any case, I'll write a blog about it later in about 4 or 5 months if I'm not lazy :-)