Objectives

To master the principles of concurrent and distributed programming and become proficient in applying these principles through programming exercises in multithreading, networking and simulation. Students will develop code using distributed and concurrent facilities that are provided by the operating system (case study: WinAPI with C API and C++ wrappers), language intrinsic (case studies: Java, Perl, and Ada 95), and threading libraries (case study: pthreads)

Prerequisites

Mastery of a high-level programming language such as C++ or Java; expert knowledge of data structure and algorithm design; familiarity with object-oriented programming, computer hardware, and operating systems; some mathematical maturity (this is a graduate class).

Readings

There really isn't any required textbook for this course, but I very strongly recommend you get the book by Ben-Ari and read it; you can also get one of the books from Garg and skim it. Also, as there will be many programming assignments throughout the course, those of you that learn best from books will want to pick a few of the language-specific texts mentioned below as well. In general, read as much as you can from the list below: it might improve your grade!

Theory: You'll want some solid, academic, treatment of distributed algorithms, models for concurrency and distribution, and distributed programming languages. Classic textbooks and journal papers are your best bet here. Examples:

• M. Ben-Ari, Principles of Concurrent and Distributed Programming, Prentice-Hall, 1990. {A fabulous 225-page paperback; fifteen years old but completely relevant today; an oldie but a goodie.}
• Vijay K. Garg, Elements of Distributed Programming, Wiley-IEEE Press, 2002. {Looks like a pretty good text; seems rigorous and complete, but I haven't read it yet.}
• Vijay K. Garg, Concurrent and Distributed Computing in Java, Wiley-IEEE Press, 2004. {Seems to be similar to the previous text, though it uses Java as an implementation language to make the topics concrete.}
• Nancy A. Lynch, Distributed Algorithms, Morgan Kaufmann, 1997. {This text contains just about everything, and features many correctness proofs. What would you expect from this publisher?}
• Gerard Tel, Introduction to Distributed Algorithms, Second Edition, Cambridge University Press, 2001. {A text focusing on algorithms.}
• Henri Bal, Jennifer Steiner, and Andrew S. Tanenbaum, Programming languages for distributed computing systems, Computing Surveys 21(3): 261–322. {A paper that discusses over 90 distributed languages.}
• Rance Cleaveland and Scott Smolka, Strategic Directions in Concurrency Research, Computing Surveys 28(4):607–625.

Java: It seems like most non-trivial Java programs use threads or networking. Fortunately the language was designed with multithreading in mind, and networked code is easy to write.

• Scott Oaks and Henry Wong, Java Threads, 3rd edition, O'Reilly, 2004. {Perhaps the best starter book for Java threading; the third edition covers Java 5 and is a huge improvement over the previous editions.}
• Elliotte Rusty Harold, Java Network Programming 3rd edition, O'Reilly, 2004.{Works great as a Java book; don't expect to learn TCP/IP from it, though. Don't get anything less than the 3rd edition!}
• Doug Lea, Concurrent Programming in Java, 2nd edition, 1999. {Could be considered a classic — this is the design patterns book for concurrency; recommended; not for beginners; Contains an extensive bibliography. Many of the ideas in this book have been incorporated into Java 5.0.}

Ada: Although not as widely used as it was several years ago, Ada remains one of the best case studies for a language that directly supports distributed, concurrent, and real-time features.

• Burns and Wellings, Concurrency in Ada, Cambridge University Press, 1998. {This is a great all-around text; it has plenty of examples with good commentary.}
• Ken Shumate, Understanding Concurrency in Ada, McGraw-Hill, 1990. {I remember having read this book when it first came out and liking it. But it went out of print rather quickly. I remember some fairly cool diagrams and a lot of coverage of real-time issues.}

WinAPI Processes and Threads: You'll need to get good at consulting the online documentation for Windows threads; there aren't too many books, but the one by Beveridge and Weiner is pretty good.

• Microsoft, Windows API, Online documentation. {This is good, and indispensable for programmers but it's a terse reference and some readers may want a book as well.}
• Jim Beveridge and Robert Weiner, Multithreading Applications in Win32, Addison-Wesley Professional, 1996. {Approaching 10 years old, but still okay. I'm not aware of too many texts in this area.}

Perl: I don't know of any good books or papers specifically covering Perl threads, but several presentations are online. As always with Perl, check out the tutorials and references on perl.org especially perlthrtut

Miscellaneous Papers: Here are a few papers we'll look at. They aren't classics.

• Cormac Flanagan and Stephen N. Freund, Type-based race detection for Java, ACM SIGPLAN Notices, 35(5):219–232, 2000.
• Radu Rugina and Martin C. Rinard, Automatic Parallelization of Divide and Conquer Algorithms, Proc. 7th ACM Symposium on Principles and Practice of Parallel Programming, 72–83, 1999.
• Jurgen Lind. Specifying Agent Interaction Protocols with Standard UML. In Agent-Oriented Software Engineering, 136—147, 2001.

Additional papers and readings will be assigned throughout the course (including my own course notes, practice problems, and sample code). If you have projects or papers to work on, you'll have to find some additional readings on your own. Use judgment when researching on the web; a fair amount of information is often wrong, and much of the so-called sample code is especially atrocious. Regardless, you must take the time for effective self-study that includes practicing the craft of programming.

Assignments and Grading

You'll have several homework sets containing in-depth theoretical questions and non-trivial programming problems, and quizzes and a final exam with less difficult material. To help prepare you to meet industry expectations for college graduates, most assignments will take the form of open source software products. Unless otherwise specified, you are required to keep all work in your CVS repository and prepare all homework solutions with LaTeX document preparation system. Exams will cover material from lectures not previously assigned for homework: don't whine about this.

Generally, coursework may be done in groups of no more than two students; however, while only one solution set is turned in per group, both students are responsible for understanding all of its content and may be asked at any time for an oral explanation of any solution. Collaboration with other groups is fine but must be limited: you may share ideas and approaches but nothing resembling a solution (not even pseudocode). You must also acknowledge any help received. Academic dishonesty may result in expulsion; be certain your work meets the standards set forth in the LMU Honor Code.

Your final grade will be weighted as follows:

Letter grades are figured according to the usual scale: 90% or more of the total points gets you an A, 80% a B, 70% a C, and so on. These are minimal requirements; for example, if you get 82 points you are guaranteed a B- or better, though you might still get an A since 82 may be the top score.

Homework is due at the beginning of class; late assignments are docked 30% per class. Missing class just to get an assignment done on time will not be tolerated; the only good excuses for missing class are excellent surf conditions, family problems, sickness, and personal emergencies. Skipping class just puts your fellow students at an advantage: we often spend class time going over things that will be "on the exam".

Your programming style will play a huge part in determining your score on the programming assignments. I will not hesitate to assign D's or F's to working programs which are poorly structured, under-commented, have poor identifier names and abbreviations, contain inappropriate hard-coded values, or are not easily maintainable. Appearance of the grading policy in this syllabus constitutes fair warning of the consequences of poorly written code.

Topics and Tentative Schedule

This is a tentative schedule.

• INTRODUCTION: Motivations for the study of concurrency; examples of concurrent and distributed systems; Basic definitions; Overview of modeling, granularity, scheduling and language integration; Simple examples coded in Java, Ada, Perl, C++/pthreads and C++/WinAPI.
• CORRECTNESS OF CONCURRENT PROGRAMS: Safety and liveness; Race conditions, atomicity, critical regions and mutual exclusion; Deadlock, livelock, starvation, and fairness.
• COMMUNICATION: Synchrony and asynchrony; Shared-variable communication and mutual exclusion: from Peterson's algorithm to test/set to barriers to semaphores to monitors to Ada protected objects; Message-based communication: client/server models (rendezvous, receipt, callback, etc.), channels, mailboxes, and pipes.
• JAVA THREADS: The Thread class and the Runnable and Callable interfaces; Thread creation and termination; Synchronization: volatile fields, atomic classes, locks, and synchronization objects; The concurrent and blocking collections; Threads in graphical applications; Scheduling with thread pools and timers.
• WINDOWS API CONCURRENCY: Overview of WinAPI; processes and threads; Process and thread API; Scheduling, priorities, boosts; Synchronization: kernel object approaches (semaphores, events, mutexes, waitable timers) and non-kernel object approaches.
• ADA CONCURRENCY: Tasks and protected objects; initialization, activation, communication and termination of Ada tasks; events, buffers, blackboards, broadcasting; Asynchronous Transfer of Control (ATC), abort; systems programming: interrupt handling, resource control and periodic scheduling. Real time facilities: priorities, queuing policies and synchronization primitives.
• DISTRIBUTED PROGRAMMING: Network and Internet fundamentals; Protocols and layers; Basic socket-level programming in Java, C and Perl; Ada distributed systems facilities: partitions, RPC, distributed objects, replication and distributed fault tolerance; Windows API interprocess communication: mailslots, slots, clipboard, DDE, messages, and sockets; HTTP and Web Applications; Remoting (RPC, RMI, Hessian/Burlap, Swing HTTP Invoker, Ajax, Web Services).
• JAVA ENTERPRISE COMPUTING: Java EE Overview; JNDI, Java Mail, JMS, Web tier (Java Servlets, Java Server Pages, Java Server Faces, Struts), Java Web Services Technologies (JAXB, JAX-RPC, SAAJ, etc.); The Struts MVC Framework; Persistence technologies (JDBC, JDO, iBATIS, Hibernate). Comparisons with .NET.
• SURVEY OF DISTRIBUTED LANGUAGES: A look at an old paper with 90 of them, supplemented with some modern ones.
• ADVANCED THEORY: Theory of parallel algorithms, covering models for parallel computation, SIMD vs. MIMD, PRAMs vs. connection machines, and the complexity of parallel algorithms (NC and P-completeness).
• MODELING AND VERIFICATION: Using Temporal Logic for specification of concurrent systems; Correctness proofs; Mechanical Verification Systems; Well-known formalisms and Process Algebras (e.g. Milner's p-calculus); a look at some classic distributed algorithms, with a focus on correctness proofs.
• IMPLEMENTATION: How to build a concurrency kernel: single- and multiple-processor implementation issues, and scheduling algorithms; Brief look at threads in the Java Virtual Machine; Parallelism in the Pentium family of processors.

University Links

All students will want to acquaint themselves with the useful information found in the following sources:

• LMU Academic Requirements and Policies (Pay particular attention to the sections on academic dishonesty)
• LMU Disability Support Services Office
• LMU Student Codes and Policies
• LMU Learning Resource Center