ITKA203 Operating Systems: Desired Learning Outcomes
This document lists the learning outcomes of the course ITKA203
Operating Systems. It is originally based on the ACM computing
curriculum recommendations:
http://wiki.acm.org/cs2001/index.php?title=Operating_systems and
http://www.acm.org/education/CS2013-final-report.pdf (esp. page 138;
no critical changes since the 2001 recommendations). The objectives
have been selected and modified according to the local curriculum and
traditions, and then re-translated into English.
After completing the course, the student should be able to...
...with regard to operating system structure and principles:
- describe the main responsibilities of a contemporary
operating system (OS) and to explain the history leading to their
current form
- list the most fundamental subsystems of an OS and the
functions that each subsystem is responsible of
- recognize and give examples of conflicting goals
and compromises necessary in implementing an OS and configuring its
run-time parameters
- know the common English terminology related to OSs
along with the most common variations of the terms; to
discuss OS issues in written and spoken English
- describe the abstractions typical to OSs (processes,
resources, files, etc.) and the layered structure between the
abstractions and the physical devices; list reasons for
using abstractions in device management and extend the
idea of abstractions to software development tasks other than
OSs.
- understand the goals of standardization of OS (and other)
interfaces; describe what kinds of things the POSIX
standard defines, and, on the other hands, things that POSIX leaves
undefined, i.e., up to the specific implementation
- know and identify (from content description or C code), the
most common data structures required in an OS implementation
(certain C struc's and arrays, queues, lists, stacks, and
hierarchical structures thereof) and know which purpose each of
these can be used for. Specifically, the student is able to identify
and describe the OS data structures used in process state
management, paging virtual memory management, file system management
(with "unix i-nodes"), and scheduling.
- tell under which circumstances the processor is
executing code either in kernel mode or in user mode, and how these
modes differ from each other
- explain under which situations and by what kind of mechanism the
processor transitions into interrupt handling; understand the
benefits and, on the other hand, the implications, that the
processor interrupt handling mechanism has on application and system
software
- know the most important differences between a monolithic and a
microkernel OS
- represent the contents of a C language data structure
as the contents of consecutive memory locations with distinct
addresses; especially, the student is able to implement a reference
to data as a memory address (C pointer). Likewise, the student is
able to identify the location and content of a simple C data
structure in the memory space, when given the structure, the start
address, and some memory surrounding the start address.
- understand the execution of a program as the trace of
consecutive machine language instructions residing in the computer
memory, and how typical programming structures manifest themselves
in machine language; recognize a machine language program upon
seeing one (in assembly or disassembly either in the AT&T or the
Intel dialect)
- read short (i.e., 2-10 instructions) machine language
programs that have been fully commented line-by-line in English
describing the workings of each instruction; formulate
(using a pen and paper, if necessary) the trace of such a program
and follow the temporary and persistent effects of such a program in
the state of the registers and the memory of the computer
... with regard to concurrency:
- describe how multitasking is possible to implement in a
uniprocessor system, and how application programming differs between
a multicore system and a uniprocessor one
- provide an annotated state diagram that describes the states
and state transitions during the whole lifetime of a process;likewise,
interpret such a state transition diagram
- identify and list application scenarios in which it is useful
to use multiple threads of execution (including the fundamental need
for multitasking in an OS)
- explain the concept of a process and the process control
block (PCB) in a typical OS; recognize a PCB upon seeing the C code
of such, and assess whether such a data structure
contains everything that is necessary to handle the main tasks of a
modern OS
- explain the difference between a process and a thread
- provide a concrete example (in C or in some
pseudocode) of code that can lead to deadlock or data corruption due
to a race; likewise, the student is able to tell whether a given
code example (in C or similar pseudocode) has a bug that makes
deadlock or data corruption likely to occur
- remember the most elementary challenges in concurrent
programming (i.e., situations requiring mutual exclusion and
synchronization) and solve them using semphores (as
defined by the POSIX threading interface).
- verify whether a given C (or similar pseudocode) program
correctly solves the producer-consumer problem using multi-valued
semaphores
- explain the semaphore (as defined by POSIX) as a concept, a data
structure of a platform (esp. as defined by POSIX concurrency), and
as an application interface; remember the history of the semaphore
concept and list traditional examples of application
- remember names of synchronization methods other than
semaphores
- list and explain simple scheduling algorithms and give examples
of applications in which each scheduler could be more beneficial
than the others; likewise, choose the most suitable scheduling
algorithm from a number of given choices, given an application
scenario
- give examples of scheduling algorithms used in other context
than OSs.
- provide a useful definition for a realtime system; give examples
of actual realtime systems
- know what pre-emptive scheduling and deadline scheduling are and
in what kind of situations these are necessary
... with regard to memory management:
- explain the typical (physical) computer memory hierarchy and the
compromises involved in using such a hierarchy
- know what the principle of locality stands for, how it is used
in a typical memory system, and how the principle can be used in
applications other than computer technology and OSs.
- explain the principles of paging virtual memory (VM) and
describe the datastructures and components (both hardware and
software) that are necessary to implement paging VM
- translate a virtual memory address into a physical address,
given a page table (of a given simple "toy" computer with very tiny
address space); understand and explain how a shared memory area can
be implemented using VM addresses in different processes
- describe how the page fault exception is handled when the reason
for fault is a reference to an existing but swapped-out page, and
the LRU page replacement algorithm is selected
- explain cache thrashing as a phenomenon, identify the
possibility of cache thrashing in a simple code example; describe
means to avoid cache thrashing; given two C code examples, select
the one which presents a smaller chance of thrashing
... with regard to device management, I/O, and file systems:
- describe the layered structure of input/output (I/O) software
and give a broad overview of I/O interrupt handling
- describe the phases required of hardware and software components
for persistent storage and retrieval of persistent data
- understand the idea of direct memory access (DMA) with its
advantages and implications
- understand the role of special files and the "everything looks
like a file" principle in unix-like systems; list examples of
special files in a unix system (e.g., Linux)
- describe the functional principles of (a couple of levels of)
RAID with their benefits and implications
- explain why a naively implemented file system (FS) can be
corrupted upon sudden power loss, and describe (on a general level)
some means by which such corruption can be prevented (journaling
FSs).
- explain one concrete way (traditional unix i-nodes) of
organizing a file system on a physical storage medium
... with regard to applications (shell):
- possess the courage and basic skills to use a unix-like OS,
e.g., Linux, by means of a command line shell and an SSH terminal
connection, without endangering his/her own files or disturbing
other users or compromising the availability of the remote
system.
- use the terminal multiplexer program screen with multiple
"windows" and manipulate data directly on a Linux server machine
over the terminal connection using some commonly used text editor
(such as vi which is always installed)
- know the most common (especially POSIX-compliant) internal
commands and utility programs available in Bourne Again Shell
(bash); use them when "man pages" are available; assess the quality
and safety of examples and instructions found in Internet forums,
blogs, etc.
- understand (i.e., mentally interpret and "dry-run") and build
simple bash command lines that may use pipes (|) and output
redirection (> and >>)
- identify and list purposes for which it is common to use shell
scripts
- know the syntax for using basic programming structures
(variables, conditionals, loops, functions) in the bash shell; know
the typical conditional execution syntaxes of || and &&
- understand the role of command line arguments and environment
variables as the part of the environment of an application program;
provide arguments to utility programs according to their respective
"man pages"; export environment variables in the bash shell.
- read and understand simple bash scripts, modify them in a
controlled way, and produce simple scripts using examples,
tutorials, or hints in Internet forums
- hook a signal handler to a bash script, for the purpose of
removing temporary files and other necessary clean-ups upon
premature exit
- remember some basic utilities that can be used to examine the
status of a unix-type operating system over a terminal connection
and a command line shell; search and locate instructions for similar
tasks from the WWW and evaluate the quality, safety, and suitability
of such examples
... with regard to applications (C language, binary files, OS system calls):
- compile and link C programs using GNU command line tools and
execute the resulting binary program both as a stand-alone process
and via the text-based debugger program GDB
- describe the stages and possible problems in loading, dynamic
linking, and launching of a binary program file
- examine any file using a hex dump; examine the contents of a
binary executable file using the disassembly feature of a text-based
debugger (gdb); make a proper heuristic guess of the possible file
format using a hex dump (for common files, such as plaintext, UTF-8
possibly with BOM, ELF executable, Windows excutable, JPG, PNG, ZIP,
docx)
- explain the typical layout of a process in its virtual address
space (code, data, heap, stack, OS memory) and give a concrete
example of how the segments may be laid out in practice
- read, understand, and meaningfully modify short (ca. 50 lines in
addition to comments) programs in the C language.
- explain the phases of loading and starting a new program image
using typical unix-type system calls (also defined by POSIX) fork()
and exec().
- understand how the activation records in the execution stack can
be used to store function parameters and local variables; apply this
knowledge using a text-based debugger and AMD64 binaries; compare
and contrast the reference types of object-oriented languages (e.g.,
C#, Java) and the crude pointer types (memory addresses) of C
- make use of command line arguments and environment variables in
own C programs and bash scripts to achieve some functionality, using
instructions or examples as reference
- locate some simple OS functionality or data structure in the
current version of the Linux kernel using a WWW-based tool (lxr),
learn (some parts of) the main implementation ideas directly from
the source code, and describe these (in general terms) in English
... with regard to scientific and professional skills:
- follow professional OS discussion for example on the mailing
list "lkml" (i.e., the discussion list of real-life Linux kernel
developers)
- remember publication forums in which new scientific research on
OSs published
- search some of the scientific article databases subscribed to by
the university and find full-text articles regarding OS topics
- read scientific articles on OSs, understanding at least the
introduction and conclusion sections
- identify "hot topics" and open research questions related to OSs
from the recent research articles by others
- formulate a preliminary study plan or topic suggestion for a
Bachelor Thesis project regarding some OS-related topic (an
"ultimate goal" that exceeds all actual learning outcomes of the
course)
We intentionally disregard the following recommended topics, since
they are covered on other courses of our faculty:
- details of information security issues
- performance assessment issues; system performance evaluation
- fault tolerant systems design
- digital forensics
- details of multiprocessor systems, cloud computing
- details of telecommunication systems