COMP3007 - Computer Systems

This database contains the 2017-18 versions of syllabuses. Syllabuses from the 2016-17 session are available here.

Note: Whilst every effort is made to keep the syllabus and assessment records correct, the precise details must be checked with the lecturer(s).

Taught ByBrad Karp (100%)

The aim for this module is to have our advanced undergraduates develop a “whole-stack” understanding of the complex interactions among modern computer system hardware (specifically, a modern, multi-core CPU and its memory hierarchy), a modern operating system, and the applications that run atop them. These interactions dictate application correctness and performance.

These fundamental principles will be taught in the concrete framework of the x86 CPU architecture and the Linux/UNIX operating system.

Students should not only understand these fundamental principles, but be able to put them into practice in real C programs.

Learning Outcomes
  • To understand the C and Linux/UNIX programming environment, from the hardware (memory hierarchy, memory model between cores) to low-level operating system functionality (file and network I/O, process management, virtual memory system, program linking and loading).
  • To understand the interactions between hardware and the C and Linux/UNIX programming environment that affect application correctness and performance.
  • To know how to design correct applications that perform well in the C and Linux/UNIX programming environment.


This module teaches students topics in computer systems design and systems programming, with an emphasis on the C programming language, Intel CPU architecture, and UNIX/Linux operating system architecture. Topics covered will include:

  • Machine-level representation of code and data (assembly language; how C constructs are compiled into x86 assembly language; machine-level representations of data types and machine and C arithmetic; stack frame structure in C on the x86; array layout in memory; pointer arithmetic)
  • Use of the gdb debugger on C code in the Linux/UNIX environment
  • Common memory-related C programming errors and consequent vulnerabilities and exploits (e.g., stack smashing buffer overflow vulnerabilities and attacks)
  • The memory hierarchy: registers, L1 caches, L2 caches, L3 caches, DRAM, SSD, disk; cache architectures; performance implications of caches on program performance
  • Linking: static linking, relocatable object code, symbol resolution, loading executables, dynamic linking and shared libraries, position-independent code
  • Processes, signals, context switches, exceptions, system call error handling, job control, process creation and management
  • Virtual memory: address translation, memory mapping, dynamic memory allocation, garbage collection, memory-related bugs in C, reference-counted variables (and implementation)
  • System I/O: filesystem I/O, system call interface and semantics
  • Network programming: sockets, web server design
  • Concurrent systems programming: threads in C on Linux/UNIX, x86 memory consistency model, races, deadlocks, I/O concurrency with threads vs. event-driven programming

Method of Instruction

3 hours of lectures per week.


The course has the following assessment components:

  • Written Examination (2 hours, 60%);
  • Programming Courseworks (5 pieces, 40%).

To pass this course, students must:

  • Obtain an overall pass mark of 40% for all components combined;
  • Obtain a minimum mark of 30% in each component worth ≥ 30% of the module as a whole.


Reading list available via the UCL Library catalogue.