The End of CSE 333

Last Saturday was the last lecture of my Operating Systems CS class at the univ. It’s been an amazing journey where we got to learn a lot about the fundamentals of operating systems, and how they function internally. So, it was a nice introduction to the topic, taught by a good professor from the CS department at Alexandria University.

Why it was incredibly important to me

Being enrolled in the electronics and communication department, I don’t get the chance to study a lot of CS classes as part of my curriculum, so this has been one of the few enjoyable classes that I’ve taken since enrolling in this degree.

What was covered in the course

  • We started the course by a brief introduction into operating systems, their purpose, and a brief history about the evolution of operating systems.
  • Then we have dived into the internals of operating systems, and we learned about processes, and threads, including the concept of pseudo-parallel programming, and multi-core programming.
  • We then took a look at the inter-process communication, during the chapter we learned about mutual exclusion and synchronization.
  • Then we learned about different scheduling algorithms and we took a quick look at how they are implemented, and the trade-offs between them for different systems.
  • And we finished the course by studying memory management, it discussed swapping, and how virtual memory is implemented, and we discussed different page replacement algorithms with their trade-offs.

The programs we wrote during the course

  • We started off with writing a shell program that mimics a linux shell, using standard C system calls.
  • Then we wrote a program for matrix multiplication that taught us about how threads function, and you can see it in the following gist:

  • Our last program was a Stanford problem for creating a water reaction. Its purpose was to teach us about mutual exclusion using mutex and condition variables, we used PThreads for that. You can see the source code for the program in the following gist:


IDK, everything ends, the good courses that we enjoy, and the bad ones that we were forced to take. One true thing is, we are only left with the joy of learning a thing for the first time.

We could have opened the reference and studied all these concepts on our own, but the point of taking a university class goes much deeper than this, you have a teacher that you could ask anything you like, you have classmates that you could write code with, or discuss the material on Piazza with. You have F***** amazing memories that will last forever, like the first memory you’ll have of learning about multi-programming, or compiling your first multi-threaded application with your best friend.

Most courses focus on forcing us to memorize certain equations and rules for solving problems, but I guess that course left us with a deep understanding of the trade-offs that were made to design and implement these different operating systems that we’re dealing with on a daily basis. The code itself could be forgotten, we could stackOverflow it, or remind ourselves of what we wrote, but the memories are all we’re left with. <3