Teaching

On the Science of Engineering Trustworthy Software Systems

New course coming soon! Stay tuned!

Summary

Trustworthy software systems are correct, robust, secure, and reliable. Correctness means that the system functions according to a given specification, without errors under regular inputs; while robustness refers to correct behavior under unexpected, but benign, edge-case inputs. Security, on the other hand, means that the system maintains its confidentiality, integrity, and availability in the presence of adversaries who are actively trying to compromise it. Finally, reliability means that the system can withstand unexpected failures and continue operating without disruption. (But you already know all these from K22!) Today, with the increasing rise of GenAI, it is trivial for anyone to produce vast amounts of software, starting from a fuzzy specification in the form of a natural language prompt, to thousands of seemingly-functional lines of code within seconds. However, the core question is how to assess what such software systems can actually be trusted to do. The goal of this course is to discuss techniques and ideas from relevant scientific domains and literature, and help pave a principled scientific avenue for engineering trustworthy software.

Early Registration

If you intend to take this class on Spring ‘26 please fill this form. More details will be available soon, but this will help get an early estimation on the size of the class, and adjust materials and expections accodingly.

Summary

K22: Operating Systems

Operating Systems: Internals and Design Principles

Announcements

Calendar

Schedule

Every Monday and Wednesday 15.00-17.00 @ A2.

Summary

The goal of this course is to provide a hands-on introduction to Operating System (OS) internals and design principles, and to help you understand what is really happening when you execute a program on a machine. On the plus side, core OS abstractions, such as processes and threads, and OS primitives, such as locking and Inter-Process Communication (IPC), are ubiquitous in any software stack. Furthermore, the complex and architecture-dependent management of hardware resources performed by the OS is implemented following traditional design principles and optimization patterns that are useful in engineering any software system.

Rationale

The idea that software engineering is about producing vast amounts of source code was never a good one, and now, with the prevalence of Generative Artificial Intelligence (GenAI), it is finally coming to an end. What matters is principled understanding. To this end, producing small portions of code, but being able to quickly navigate and understand large code bases – potentially written by various people and different teams – is of paramount importance. Working with OSes, and more specifically with OS kernels (such as the Linux kernel), is an excellent playground to master the aforementioned skill. You cannot copy-paste code repeatedly and hope for something good to eventually happen. Instead, you need to understand the rationale behind the structure of software, abstract portions irrelevant to your goal, focus on the relevant ones, and spend your energy there.

Syllabus

The course will revolve around questions regarding the following topics

• Desirable OS properties and design principles
• Synchronous and asynchronous events
• Runtime, program linking and loading
• The process abstraction
• Inter-Process Communication (IPC)
• The thread abstraction
• Synchronization
• Time management
• Memory management
• The file abstraction
• Storage management

Homeworks

You will have to implement new features directly on the Linux kernel, build it, and run a VM with it. There is no diplomatic way to put this: it is going to be difficult painful [the truth resurfaces after popular request] and will require your time and engagement. However, the reward will be enormous. If you understand and own how things are being built at the OS kernel level, no codebase will ever again be complex enough to intimidate you in the future.

• Warmup instructions for setting up a VM and making your first Linux kernel patch
• Hello World system call in Linux (from tutorial 01)
• Programming assignment 1
• Programming assignment 2
• Programming assignment 3

Logistics

- Programming assignments: 50%
- Midterm exam: 20%
- Final exam: 30%

Contact

• Eclass
• Piazza
• Instructor: Vaggelis Atlidakis (vatlidak@di.uoa.gr)
• TAs: Alexandros Kostas (sdi2100080@di.uoa.gr), Christos Komis (sdi2200073@di.uoa.gr), Christos Kotsis (sdi2200087@di.uoa.gr), Stefanos Stamatis (stef@di.uoa.gr)

Office hours

• Every Thursday, 10.00-12.00 at A37.

Feedback

• If you have feedback regarding the course, use this form to share it anonymously over the semester.

Open door policy

• Whether you’re a colleague or a student, you’re always welcome to stop by for a chat, a question, or to just say hello.

Similar OS courses

• @Columbia by Jason Nieh
• @Columbia by Junfeng Yang
• @Stanford by David Mazieres
• @UC San Diego by Amy Ousterhout
• @DIT by Alex Delis

Textbooks

• Operating Systems: Three Easy Pieces, by Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau
• Operating Systems: Principles and Practice, by Thomas Anderson and Michael Dahlin
• Operating System Concepts, by Peter Baer Galvin and Abraham Silberschatz
• Linux Kernel Development, by Robert Love
• Understanding the Linux Kernel, by Daniel P. Bovet and Marco Cesati

Source Code Reference

• Bootlin Elixir Cross Referencer

Acknowledgments

This course, and especially the programming assignments, are heavily inspired by the OS course taught at Columbia University by Jason Nieh. Jason’s class (COMS W4118) was the first to introduce virtualization as a tool for teaching operating systems. During my time at Columbia, this class changed my perspective on how working with any software systems should be approached.