COSC 108---Representative Syllabus

Project

    This instructor believes that the best way to learn about "Advanced
    Operating Systems" concepts is to look at "Advanced Operating Systems"
    in the real world.  In this course, we use the OpenSolaris system to
    examine design principles, tradeoffs, and behaviors.

    For a successful experience here, students need to be competent in
    systems programming---not just textbook-level, but real empirical
    experience. (E.g., we highly recommend a B+ or higher in our COSC58.)  

Lectures

    We divide the course into a sequence of segments.  Each segment
    consists of a set of lectures, along with research papers (to give
    historical context), Solaris readings (to see explicit realization),
    supported by many empirical demonstrations.  (Systems are where
    thought meets the real world!)

    Segment 1: Strangeness at the Edge of Comfortable Abstraction

    We're used to things just magically happening when we use some OS
    service. But computation doesn't happen in some magical aether; it
    happens on real machines; and complex software in conspires with the
    hw to make this happen. We'll now start using Solaris observability
    tools to dive into that magic.

    Segment 2: Processes, Threads, IPC

    Processes are the abstraction we use to track an executing program and
    its environment; threads are the abstraction that we use to track the
    threads of execution themselves. In this segment, we'll look into
    these in more detail.

    Segment 3: Synchronization

    We just discussed the tools of threads and processes. However, the
    existence of multiple threads of execution raises the challenges of
    concurrency. We'll now go over the standard set tools that help
    address these challenges.

    Segment 4: Memory Management

    The idea of a linear address space is so natural that we easily take
    it for granted. However, address spaces are an illusion provided by a
    conspiracy of the OS and the underlying hardware. We'll review the
    basics here and then take a deeper look at aspects of how Solaris
    engineered a solution.

    Segment 5: Filesystems

    Filesystems are the abstraction the OS provides to access and organize
    long-lived data.

    Segment 6: Scheduling

    At a high level, the magic of an OS lies in multiprogramming: how all
    these independent processes run at the same time. Scheduling embodies
    the strategies and algorithms an OS uses to achieve that magic.

    Segment 7: Security and Virtualization

    Because of the central role an OS plays in protecting users from
    themselves, from other users, and from the rest of the world, security
    has become a critical part of an OS (and vice versa). Because of the
    perennial (and perhaps fundamental) problem in configuring such
    complex systems to actually provide effective protections, the old
    concept of virtualization (in various guises) has emerged as a next
    big thing.


    Segment 8: The Science of Systems

    One of the missions of this course is to help give you a deeper
    understanding of "systems," as you embark on your computer science
    research career. As a lead in to the course wrap-up, we'll go over
    some elements here.