CS 361 Computer Systems II

Spring 2020

Concurrent systems-software that supports multiple services at the same time-are everywhere.

They allow companies like Visa and Facebook to process billions of transactions per year with great accuracy. They make it possible for BitTorrent to provide efficient world-wide file distribution. Scientists rely on them to build models of complex weather and climate phenomena. However, concurrent software also caused the NASA Mars Polar Lander to crash, destroying over $100,000,000 of equipment. It was also to blame for the 2003 Northeast electrical blackout that left millions of people in New York without power for two weeks. It also contributed to Toyota cars’ uncontrolled acceleration, a flaw that killed almost 100 people in several fatal crashes.

One primary challenge of concurrent and parallel software systems is the sharing of data and other resources. That sharing may occur between threads within the same application, between independent processes on the same machine, or across a network connection. Building safe and reliable systems requires using and applying communication and design patterns correctly for the needed application. At the same time, there is only so much we can achieve with concurrency, and it’s important to understand how we can determine those limits.

In this course, we will explore the models and architectures that are used to build complex systems and communication. We will look at different techniques for exchanging information between threads and processes running on a single computer, and how we make sure that the data doesn’t get corrupted. We will examine how communication protocols make it possible to distribute all of this software across the Internet. We will also consider how to structure software to support a variety of parallel calculations ranging from climate simulations to Bitcoin mining.

Intermediate exploration of modern interrupt-driven computer systems. Explores models of computation and complex systems, techniques for communication and synchronization of parallel and concurrent software, and the protocols that make up the Internet. Prerequisites: Grades of 'C-' or better in CS 240 and CS 261.

Website: https://w3.cs.jmu.edu/kirkpams/361/s20/
Time/Place: T/Th 12:30 - 1:45 PM, ISAT/CS 246 (Section 1)
  T/Th 2:00 - 3:15 PM, ISAT/CS 246 (Section 2)
Textbooks: OpenCSF
Office Hours: M 9:30 - 11 AM, Th 9:00 - 10:30 AM, F 10 AM - 12 PM
Instructor: Prof. Michael S. Kirkpatrick
Email: kirkpams@jmu.edu
Office: ISAT/CS 223

Friday's office hours are subject to frequent change due to other meetings and commitments. If I am in my office during that time, I am available to meet with students. However, I cannot guarantee that I will be in my office by 10:00 those mornings. Please check my Calendar to confirm my availability.

A PDF of the syllabus is available here.


Course Goals

This course provides a solid theoretical foundation of the design and implementation of concurrent software systems.

Mastery of this material allows students to develop a more sophisticated view of computing and the power of high-level software abstractions. Students who complete this course can expect to meet the following objectives:

  • Write safe and robust C code that uses concurrency and synchronization.
  • Accurately assess one's mastery of course material and identify opportunities for improvement.
  • Compare and contrast architectures that are commonly used in concurrent systems.
  • Interpret and implement UML statechart and sequence diagrams of concurrent systems.
  • Make progress toward improving one's technical and interpersonal professional skill set.
  • Summarize the relationship between signals and the process life cycle.
  • Distinguish the relative merits of various forms of IPC and when to use each.
  • Compare and contrast processes and threads as concurrent execution mechanisms.
  • Classify network protocols according to their layer and intended purpose.
  • Select and combine appropriate synchronization mechanisms for solving advanced problems.
  • Distinguish the notions of concurrency and parallelism.
  • Explore a modern systems language with integrated concurrency semantics and mechanisms.
  • Summarize the key challenges and foundational results of distributed systems.
  • Implement a concurrent system based on technical specifications.

Course Structure and Evaluation

This course integrates multiple research-supported teaching strategies that emphasize using class time to apply course material to improve long-term learning and mastery.

Daily warm-ups and in-class activities - Each day will begin with a single warm-up quiz question drawn from the previous class's material. Class time will be used for group-based in-class activities, including problem-solving worksheets and multiple-choice clicker questions (ConcepTests). Mini-lectures will provide additional instruction as needed.

Weekly readings and quizzes - Assigned readings are available in the course textbook and through OpenCSF. Each reading through OpenCSF is accompanied by interactive questions that allow you to practice your understanding of the material. Completing readings is crucial to engage with the in-class activities fully. There are also pre-class Canvas reading quizzes that you can use to test your understanding of the basic concepts.

Metacognitive reflections- Each week will end with a short Canvas quiz with questions asking you to reflect on your learning process for that week.

Programming labs - A central theme of computing is to use code to work with theoretical concepts. To begin this process, there will be nine small programming labs, with a class period devoted to each one. You should set up and begin working on the lab before that class period so you are prepared to ask questions on tricky aspects of the work. All submissions will be through Mercurial and must run on stu.cs.jmu.edu.

Projects - Systems software is inherently large-scale and complex. Throughout the semester, you will work on four projects that will require you to apply what you have learned in the labs toward more realistic systems. The first project will combine finite state machines and signal handlers, two techniques that are commonly used in systems programming. The second project will involve building a command-line tool to check the integrity of multiple files concurrently (use message queues to send data about several bzipped files). The third project will integrate a network-facing server to provide this data remotely. The final project, which can be written in either C or Go, will consist of a concurrent, network-based service.

Exams - There will be two in-class exams and one final exam. All exams are closed-book, closed-note. Each exam will also include a coding portion that involves tasks similar to the labs.


Other course policies are posted in the Syllabus.







© 2011-2020 Michael S. Kirkpatrick. This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.