Concurrent Programming in Practice

COM S 430
  1. Credits and contact hours: 3 credits, 4 contact hours
  2. Instructor’s or course coordinator’s name: Steve Kautz
  3. Text book, title, author, and yearJava Concurrency in Practice, Brian Goetz, 2006.
  4. Other supplemental materials: None

Specific course information

  1. Brief description of the content of the course: A practical course in concepts, techniques, languages, and frameworks for concurrent and asynchronous systems. Concurrency fundamentals: threads, synchronization locks, waiting and notification, memory visibility. Immutability and thread confinement. Concurrent data structures and utilities, thread pools. Asynchronous programming with callbacks, futures, and message passing. Issues of aliasing, ownership and borrowing. Transactional memory, immutable and versioned data structures. Alternatives to threads and locks: event-driven systems, the actor model, CSP, coroutines. Students will investigate several non-mainstream languages supporting different concurrency models. Oral and written reports.
  2. Prerequisites or co-requisites: COM S 311, COM S 362 or COM S 363, ENGL 250, SP CM 212
  3. Required, elective, or selected elective? Selected Elective

Specific goals for the course

  1. Specific outcomes of instruction:
  • Write correctly synchronized multithreaded code in an object-oriented language. (2)
  • Analyze safety and liveness in a concurrent application and identify errors. (1)
  • Effectively use at least one alternative concurrent programming model not relying on explicit synchronization, e.g., based on confinement, actors, ownership types, immutable data structures, and/or functional programming.
  • Design and/or implement a small distributed application in which components communicate asynchronously using messages, events, or services. (6)
  • Research a programming language, library, or tool used in industry and prepare a professional-level tutorial and presentation on it. (3)

Brief list of topics to be covered

  • Concurrency fundamentals- what are threads, using low-level primitives (such as java synchronization locks), waiting and notification, the problems of memory visibility
  • Utilities and patterns for programming concurrent systems – tread-safe queues, confinement, futures, asynchronous proxies, task management
  • Languages and paradigms for concurrent systems; functional approaches; the actor model; the Panini project.
  • Application integration- the role of middleware, remote procedure calls, remote objects and ORBs, messaging, web services, application servers
  • Patterns and tools for message based, service-oriented, and event-driven systems