ELECTIVE COURSES - CSD:

OTHER COURSES OF INTEREST - OUTSIDE CSD:

Following is the syllabus for Fall 97. This will change some for the Spring 99 version (less networking, different papers), but otherwise the format and topics are broadly the same.

DESCRIPTION: This course studies the design and analysis of operating systems and distributed systems. It covers topics such as concurrency and distributed communication; fault-tolerance, availability, and persistence; security; and operating system structure. Lectures focus on the principles used in the design of operating systems and distributed systems, algorithms and data structures used in their implementation, and techniques used for evaluating them. Readings include case studies, seminal papers, and recent conference and journal articles. Prerequisites for the course are familiarity as a user with an interactive operating system, e.g. Unix, and an understanding of basis concepts in the design and implementation of operating systems, e.g., concurrent processes, semaphores.

Grading:
40% final exam (140 min)
40% project report (groups of two; four written handins)
20% subjective evaluation

Lecture format: The lecture time is long (140 min Monday and Wednesday) so we will insert a mid lecture break. This break and a couple of schedule conflicts encourage us to meet on a few Fridays (1:00 pm in 5409). See the schedule below. Most topics are covered in three parts over the period of about a week: a background lecture, a discussion of about three seminal or comprehensive papers, and a topical research presentation, typically by a guest speaker.

Text: There is no assigned textbook. There is, however, a number of books on reserve in the library for deeper study:

Schedule:

Week 1: Sept 15, 17, 19 (F): Concurrency
Covers process/thread abstractions; resource management synchronization; techniques such as locks, semaphores, and monitors; concerns such as deadlock, priority inversion, and starvation; benefits such as pipelining, multitasking and work deferring; and techniques for minimizing overhead in concurrent programs.
Birrell89: Andrew Birrell, An introduction to programming with threads, DEC technical report TR-35, DEC/SRC, January, 1989.
Hauser93: Carl Hauser, Christian Jacobi, Marvin Theimer, Brent Welch, Mark Weiser, Using threads in interactive systems: A case study, 14th ACM Symp. on Operating Systems Principles (SOSP-14), December 1993.
Massalin89: Henry Massalin, Calton Pu, Threads and input/output in the Synthesis kernel, SOSP-12, December 1989.
Goldstein96: Seth Goldstein, Klaus E. Schauser, David E. Culler, Lazy Threads: Implementing a Fast Parallel Call, J. of Parallel and Distributed Computing, August, 1996.
• 1-2 pm Wed Sept 17: guest speaker, Steve Lucco, foreshadows a later topic
• 2-3 pm Fri Sept 19: guest speaker, Seth Goldstein, Lazy Threads

Week 2: Sept 22, 24: Memory management
Covers dynamic relocation issues such as segmentation, paging, translation buffer management, thrashing avoidance, and replacement algorithms; memory object optimizations such as copy-on-write, shared mappings, and machine independent data structures; cache consistency concerns in uniprocessor caches, virtual memory intereaction with I/O, and multiprocessor caches; overloading of virtual memory hardware for optimizing higher level techniques such as distributed virtual memory.
Rashid87: Richard Rashid, Avadis Tevanian, Michael Young, David Golub, Robert Baron, David Black, William Bolosky, and Jonathan Chew. Machine-Independent Virtual Memory Management for Paged Uni- and Multi-processor Architectures. 2nd ACM Symp on Architectural Support for Programming Lang. and Operating Systems (ASPLOS-2), July 1987.
On-line: /afs/cs/project/mach/public/doc/published/MIvmm.ps.ps
Chen93: J. Bradley Chen, Brian Bershad. The Impact of Operating System Structure on Memory System Performance. SOSP-14, December 1993.
On-line: /afs/cs/project/mach/public/doc/published/os-memorysys.ps
Carter91: J.B. Carter, J.K. Bennett and W. Zwaenepoel, Implementation and Performance of Munin. SOSP-13, October 1991.
On-line: /afs/cs/project/pdl-24/Papers/Rice/Munin.sosp91.ps
Uhlig94: R. Uhlig, D. Nagle, T. Stanley, T. Mudge, S. Sechrest, R. Brown. Design tradeoffs for software-managed TLBs. Trans. on Computer Systems (TOC), 1994.
On-line: /afs/cs/project/pdl-24/Papers/UMich/Mudge/tocs.submit.ps
• Mon Sept 29: guest speaker, David Nagle, software-managed TLBs.
• Friday Sept 26, 12-3 pm, 5409: Emmigration lecture on Technical Writing

Week 3: Sept 29, October 1: Security
Covers case studies of common attacks; basics of common defenses such as monitoring/logging, security levels, cryptography and correctness proofs; challenges of overall security including information flow control and inference attacks; common techniques such as private and public key cryptography for integrity and privacy; BAN logic strengths (formalism, belief logic, freshness) and weaknesses (message atomicity, release of secrets).
Denning79: Dorothy Denning, Peter Denning. Data Security. Computing Surveys, vol 11, no 3, September 1979.
Anderson95: Ross Anderson, Roger Needham. Programming Satan's Computer. Computer Science Today, Springer LNCS vol 1000, Springer Verlag, 1995.
Burrows90: Michael Burrows, Martin Abadi, Roger Needham. A Logic of Authentication. ACM Trans. on Computer Systems (TOCS), vol 8, no 1, February 1990.
There are two short followup articles:
Nessett90: Dan Nessett. A Critique of the Burrows, Abadi and Needham Logic. ACM Operating Systems Review (OSR), vol 24, no 2, April 1990 (unreviewed).
Burrows90b: Michael Burrows, Martin Abadi, Roger Needham. Rejoiner to Nessett. ACM OSR, vol 24, no 2, April 1990 (unreviewed).
• Fri Oct 10: guest speaker, Doug Tygar.

Week 4: October 6, 8: File systems
Secondary storage performance characteristics and implications for program behavior; data structures for efficient access and storage overhead, storage scheduling, file caches and directories; consistent caching and storage management in distributed file systems; configurable functionality through layering of abstraction; performance critical issues such as prefetching and file cache replacement algorithms.
Howard88: J. Howard, M. Kazar, S. Menees, D. Nichols, M. Satyanarayanan, R. Sidebotham, M. West. Scale and Performance in a Distributed File System. TOCS, vol 6, no 1, February 1988.
Heidemann94: J Heidemann, G. Popek. File-System Development with Stackable Layers. TOCS, vol 12, no 1, February 1994.
Patterson95: R.H. Patterson, G. Gibson, E. Ginting, D. Stodolsky, J. Zelenka. Informed Prefetching and Caching. SOSP-15, December 1995.
• guest speaker, Garth Gibson, Informed Prefetching

Week 5: October 10 (F), 15: Networks
Covers layered peer-to-peer comunications protocol stack design and routing algorithms; reliable delivery techniques including sliding windows, flow control, congestion control, and round trip timing; performance interactions with operating systems; techniques to optimize performance by exploiting characteristics of local area networks.
Saltzer84: J. Saltzer, D. Reed, D. Clark. End-to-end Arguments in System Design. TOCS, vol 2, no 4, November 1984.
von Eicken92: T. von Eicken, D. Culler, S. Goldstein, K. Schauser. Active Messages: A Mechanism for Integrated Communication and Computation. 19th ACM Int. Symp. on Computer Architecture (ISCA92), June 1992.
Druschel93: P. Druschel, L. Peterson. Fbufs: A High-Bandwidth Cross-Domain Transfer Facility. SOSP-14, December 1993.
Buzzard96: G. Buzzard, D. Jacobson, M. Mackey, S. Marovich, J. Wilkes. An Implementation of the Hamlyn Sender-Managed Interface Architecture. 2nd Usenix Symp on Operating Systems Design and Implementation (OSDI96), October 1996.
• Monday, October 13 is mid-semester break - no lecture
• Wed, Oct 15: guest speaker, John Wilkes, Hamlyn sender-managed interface

Week 6: October 20, 22: Clocks and Consensus
Covers the basics of what is concurrent, what is unordered and what can be known to be known elsewhere; the arbitrariness of most total orderings and difficulty of finding minimal partial orderings; techniques for general purpose logical clocks and physical clocks; algorithms for achieving consensus given failstop, restart/omission or arbitrary fault models; advantages possible with authenticated messages and bounded message delivery times.
Lamport78: L. Lamport. Time, Clocks, and the Ordering of Events in a Distributed System. Comm of the ACM, vol 21, no 7, July 1978.
Lamport82: L. Lamport, R. Shostak, M. Pease. The Byzantine Generals Problem. ACM Trans. on Programming Lang and Systems, vol 4, no 3, July 1982.

Week 7: October 24 (F), October 31 (F): Project preparation discussions
The basic goal of this project is for class members to design, construct and evaluate an interesting software system. The system should explore issues, solve problems or exploit techniques from classroom discussions or papers. Logistically, you should work in groups of two or three.
• Project proposal due October 31
  Describe in 1-2 pages the project idea/application, how it relates to the course material, what work must be done (suggesting how it can be partitioned among you) and what resources you will need (including software systems you already have access to).
• Project design document due November 14
  This should be about 5 pages. It should report revisions to the project description scope as appropriate. Then present a detailed description of the software design, including module decomposition, packages used, partitioning of work among the group and highlighting the course material relationships. Report logistical obstacles and your approach to overcoming them. Construct a detailed sketch of your evaluation plan - what hypothesis is to be tested, how will your control the test circumstances, what workloads will you apply, why will the test enable resolution of the hypothesis, and what and how will specific metrics be measured.
• Project midterm report due November 25
  This should be a 1-2 page status report. All obstacles should be resolved. The evaluation plan should be finalized. Any major changes in design should be documented. Initial data collection and reporting is strongly encouraged.
• Final project report due December 15
  This is a complete report of about 10 pages. It should report goals, relationship to the course, implementation design, evaluation methodology, results and analysis, discussion of hypothesis outcome, most interesting future work, and a bibliography. Submit code electronically.

Week 8: November 3, 5: Database
Covers entity-based storage abstraction, relational algebra, scheme design and normal forms to avoid lossy joins; ACID properties for transactions: atomicity, consistency, isolation, and durability; two phase locking and timestamp techniques for serializability; indices, B-trees, and concurrent B-trees; weaker serialization exploiting functional commutativity for metadata structures such as concurrent B-trees.
Gray79: R. Bayer, R. Graham, G. Seegmuller, editors. Section 5 of Notes on data base operating systems. Chapter 3 in Lecture Notes in Computer Science: Operating Systems. Springer Verlag, 1978.
Bayer77: R. Bayer, M. Schkolnick. Concurrency of Operations on B-Trees. Acta Informatica, vol 9, no 1, Springer Verlag, 1977.
Bernstein81: P. Bernstein, N. Goodman. Concurrency Control in Distributed Database Systems. ACM Computing Surveys, June 1981.
• Wed Nov 5: guest speaker, Christos Faloutsos, on richly typed databases

Week 9: November 10, 12: Remote execution
Covers remote procedure call implementation; extending RPC function using remote evaluation; optimizing performance by tailoring characteristics of wire interface to application; techniques for dynamic migration of activated functions and inactive objects; safety techniques such as address spaces, sandboxing, trustability proofs and certified code.
Stamos90: J. Stamos, D. Gifford. Remote Evaluation. Trans on Prog Lang and Syst, 1990.
Jul88: E. Jul, H. Levy, N. Hutchinson, A. Black. Fine-Grained Mobility in the Emerald System. TOCS 88.
Franklin96: M. Franklin, B. Jonsson, D. Kossman. Performance Tradeoffs for Client-Server Query Processing. SIGMOD 96.
Necula96: G. Necula, P. Lee. Safe Kernel Extensions Without Run-Time Checking. OSDI96.
• Project design document due November 14
• Wed Nov 12: guest speaker, George Necula, on his paper.

Week 10: November 17, 19: Distributed recovery
Covers use of logging for recovery in databases, file systems and parallel computations; log data structures; UNDO/REDO write ahead logging and two phase commit; interaction with operating systems.
Haskin88: R. Haskin, Y. Malachi, W. Sawdon, G. Chan. Recovery Management in QuickSilver. ACM TOCS, vol 6, no 1, Feb 1988.
Satyanarayanan94: M. Satyanarayanan, H. Mashburn, P. Kumar, D. Steere, J. Kistler. Lightweight Recoverable Virtual Memory. ACM TOCS, vol 12, no 1, Feb 1994.
Elnozahy92: E. Elnozahy, D. Johnson, W. Zwaenepoel. The Performance of Consistent Checkpointing. Proc. of 11th IEEE Symp. on Reliable Distributed Systems, Oct 1992.

Week 11: November 24: slipage
• Project midterm report due November 25

Week 12: December 1, 3: Review and in-class final exam (Dec 3)

Week 14: December 15: Final project report due

DESCRIPTION: TBA

COURSE DESCRIPTION

This course is a graduate level research seminar on automatic verification techniques for concurrent, reactive, and real-time programs. It was last taught in the spring of 1997, but different topics will be covered this semester

The prerequisites for the course are minimal--basic knowledge of elementary logic and automata theory. Students taking the class for graduate credit will be asked to prepare a short project and give one or two lectures. Auditors are also welcomed.

DETAILED COURSE DESCRIPTION: Logical errors in hardware controllers, communication protocols, and real-time programs are becoming an increasingly important problem. They can delay getting a new product on the market or cause the failure of some critical device that is already in use. The most widely used method for verifying such systems is based on extensive simulation and can easily miss significant errors when the program is very complicated.

Many of these programs can be viewed as having only a finite number of states. When this is the case, an alternative verification technique called "model checking" may be used. In this approach specifications are expressed by automata or temporal logic formulas, and programs are modeled as state transition systems. An efficient search procedure is used to determine automatically if the specifications are satisfied by the transition system. The technique has been used in the past to find subtle errors in a number of non-trivial designs. Recently, the size of the state transition systems that can be verified by model checking methods has increased dramatically. By representing transition relations implicitly using Binary Decision Diagrams (BDDs), it has become possible to check some examples with more than 10^100 states!

POSSIBLE TOPICS TO BE COVERED:

1. Modeling concurrent programs with state transition systems
2. Temporal logics
3. The mu-calculus and fixpoint theory
4. The basic model checking algorithm
5. Binary decision graphs and symbolic model checking
6. Using Omega-automata to specify properties of concurrent systems
7. Notions of equivalence for concurrent systems (observational equivalence, etc)
8. Compositional reasoning techniques (e.g. the "assume--guarantee" paradigm)
9. Exploiting abstraction and symmetry
10. Using induction to reason about systems with many similar processes
11. True concurrency and models based on partial orders
12. Extending model checking techniques to handle real-time programs
13. Model checking techniques for the mu-calculus
14. Model checking for security and electronic commerce protocols.

OVERVIEW: This course introduces foundational concepts and techniques of programming language semantics. The main focus is on the {\it principles} of programming languages, their application in program analysis and synthesis, and their relevance in the design and implementation of programming languages. We bring out the key concepts and techniques, building in a modest amount of necessary mathematics and logic as we go. At the same time we illustrate these concepts in settings that involve real programming languages. We aim to demonstrate that there is a scientific approach to programming language theory, and that such an approach is vital in attempting to answer questions about the pro's and con's of various languages, about compiler correctness, and for many other practical purposes.

BACKGROUND: There is a wide variety of programming languages, ranging from low-level machine code and assembler to high-level languages such as C, Java, and Standard ML. A few major {\it paradigms} have been identified (e.g. ``functional'', ``imperative'', ``object-oriented'') and a particular language may belong to one or more of these. Although this type of classification can be useful to a limited extent, it is much more important to understand the relationship between program syntax (what we write) and algorithms (what happens, in abstract terms, when a program runs). This is one of the purposes of programming language semantics.

A semantics for a programming language is a mathematical model that reflects the intended computational behavior of programs. To be useful, a semantics needs to be:

• tractable: as simple as possible without losing the ability to express behavior accurately;
• abstract: uncluttered by irrelevant detail;
• computational: an accurate abstraction from runtime behavior.

To support syntax-directed, or modular, program development and analysis a semantics needs to be compositional.

In addition to its role in validating program correctness, semantics can provide a firm foundation for many activities related to programming and programming languages.

• Semantics can yield answers to questions of programming language design. For example, is Java ``better'' than C++? Many such questions simply don't have an unambiguous yes/no answer. Semantics can help to clarify the picture by allowing us to make rigorous statements about properties of programs and the interactions between program constructs.
• Lessons learned in programming language theory can also guide the design of special-purpose ``little'' languages, such as scripting languages or mark-up languages. Despite their narrow scope of application, such languages still need careful design.
• Semantics can influence language implementors. For example, many code optimization tricks used in compilers (e.g. loop unrolling, code motion, goto-chasing) rely for their soundness on results from programming language theory.
• The theory of programming languages provides foundations for the kind of ``formal methods'' advocated in software engineering, by allowing precise specifications of intended program behavior and permitting proofs that a program does (or perhaps does not) meet its specification.

We will focus on two of the most successful styles of semantic description: denotational and operational semantics. Each style has its advantages and disadvantages, so it is important to be able to discern the pro's and con's of a particular semantics, and it is worth understanding the ideas behind each style. For example, a denotational semantics is automatically compositional, while typically this is not the case for an operational semantics; nevertheless one can usually still justify modular program analysis in the operational style, although the style of semantic presentation tends to make it harder. It is often stated that operational semantics is ``easier to understand'', but this is not a universal truth. Despite these claims, neither style is clearly ``better'' than the other. It is best to regard the two styles as complementary approaches to understanding languages and programs.

As is traditional in semantics texts and research, we do not work with entire ``real'' programming languages like C and Java. Instead we focus on small ``core'' languages with an idealized (and simplified) syntax. Each core language is chosen to exhibit the features common to languages in a specific paradigm, with a minimum of syntactic distraction. In each case, we will show how a semantics can be used to analyze individual programs, to design correct programs, and to prove general laws of program equivalence that can be used to simplify programs while preserving correctness.

We will begin with a simple sequential imperative programming language, since it requires little semantic sophistication and allows us to introduce the major concepts, notation, and techniques painlessly. We then apply and generalize these ideas and techniques to a series of more complex languages. The approach is incremental, studying each feature (e.g. parallelism) in as simple a setting as possible to minimize the potential for confusion and bring out the key issues caused by the feature itself, rather than having to deal with a grab-bag language containing many logically disparate features (like parallelism and modules) and trying to disentangle.

The course will have a strong mathematical flavor, but also a strong emphasis on writing programs. Students will be expected to write programs in Standard ML. Despite its primarily functional nature, ML can be used to illustrate imperative, object-oriented, and concurrent programming issues as well as issues related to functional programming. By limiting to a single language we avoid the need to learn a new language every week. We also use ML to implement semantic definitions for other languages, thus providing a testbed facility for debugging semantic descriptions and for trying out various combinations of language features.

EVALUATION: Grading will be based on homeworks, a midterm examination, a final examination, and (to a lesser, more informal sense) on class participation. Homework will include both written assignments and programming problems. The midterm and final will be open-book, in class.

The course will be graded (for CS graduate students) on a pass/fail basis. Students are encouraged to form study groups to discuss homework problems and course material, but any work turned in for a grade must be solely the work of the individual. It is not acceptable to solve a problem collectively in a group and then write the answers up for individual submission. Copying or adaptation from a published book or article, or from previous core course documentation, is also unacceptable.

SYLLABUS

Here is a tentative outline for the course, subject to change.

1. Introduction.
   • Practical uses of semantics: examples
   • Static semantics (abstract syntax, typing rules, binding and scope)
   • Dynamic semantics: (denotational and operational)
   • Notions of semantic equivalence
2. Sequential imperative programming
   • Using domains and fixed point theory to model recursion
   • Handling local variables
   • Hoare's Logic and programming methodology
   • Jumps and continuations
   • Correctness of code optimizations
3. Functional programming
   • ML programming: introduction
   • Types and polymorphism in ML
   • Call-by-name, call-by-value, and lazy evaluation
   • Static scope and dynamic scope
   • Inductive and co-inductive reasoning
   • Notions of program equivalence
   • Continuations and CPS-transformations
4. Parallel imperative programming
   • Shared-variable programs
   • Communicating processes
   • Dataflow networks
   • Safety and liveness properties, fairness
   • Techniques for reasoning about parallel programs
   • Programming in Concurrent ML (CML)
5. Combining functional and imperative programming
   • Sequential and parallel Algol-like languages
   • References in ML
6. Data abstraction and modularity
   • ML signatures, structures, and functors
   • Opaque vs. transparent implementations
   • Signature matching and sharing constraints
   • Abstract data types as modules
7. Object-oriented programming
   • Classes and objects in Java
   • Sub-classes and inheritance
   • Interfaces and packages
   • Subtyping
   • Objects in Algol-like languages
8. Logic programming (to be included if time permits)
   • Programs as predicates, execution as proof search
   • Unification and resolution
   • Prolog programming
   • Backtracking and cut
   • Implementing logic programming in Standard ML

• Reynolds, Theories of Programming Languages, Cambridge University Press, ISBN 0-521-59414-6 (1998).
• Winskel, The Formal Semantics of Programming Languages: An Introduction, MIT Press, ISBN 0-262-23169-7.
• Paulson, ML for the working programmer, Cambridge University Press, ISBN 0-521-39022-2.

Lecture notes will also be handed out on a regular basis, and we will assemble a collection of papers from the literature on relevant topics.

DESCRIPTION: A major goal of programming-language research is to extend the benefits of higher-order typed programming languages, especially type safety and rigorous program verification, to lower-level languages that give the programmer more control over efficiency. In this course we will explore two approaches to this goal: (1) to start with a higher-order typed language (such as a purely functional, ML-like, or Algol-like language) and introduce features, such as linear types or explicit closures, that give the programmer more control, or (2) to start with a very low-level language (such as a machine language) and introduce a type system or verification methodology.

PREREQUISITES: CS15-711 or equivalent

TEXT: There is no published text. The course will be based upon published papers, preprints, and occasional class notes. See the tentative bibliography given below.

Method of Evaluation: Grading will be based upon either a class presentation or a term paper.

TOPICS TO BE COVERED:

• Linear typing
• Effects as monads
• Specification logic for Algol-like and object-oriented languages
• Reasoning about pointers and aliasing
• Type and proof systems for machine language

REFERENCES:

1. Benton, P. N. A Mixed Linear and Non-Linear Logic: Proofs, Terms and Models (Extended Abstract). In: Computer Science Logic, 8th Workshop, CSL '94, Selected Papers, Kazimierz, Poland, September 25-30, 1994, edited by L. Pacholski and J. Tiuryn. Lecture Notes in Computer Science, vol. 933, Springer-Verlag, Berlin, 1995, pp. 121- 135.
2. Levy, P. B. Call-by-Observable: A Subsuming Paradigm. 1998.
3. Morrisett, C., Walker, D., Crary, K., and Clew, N. From System F to Typed Assembly Language. In: Conference Record of POPL '98: The 25th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, San Diego, January 19-21. ACM Press, New York, 1998, pp. 85-97.
4. Necula, C. C. Proof-Carrying Code. In: Conference Record of POPL '97: The 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programn-iing Languages, Paris, France, January 15-17. ACM Press, New York, 1997, pp. 106-119.
5. Pitts, A. M. and Stark, I. D. B. Observable Properties of Higher Order Functions that Dynamically Create Local Names, or: What's new? In: Mathematical Foundations of Computer Science 1993, 18th International Symposium, Gdaiisk, Poland, August 30-September 3, edited by A. M. Borzyszkowski and S. Sokolowski. Lecture Notes in Computer Science, vol. 711, Springer-Verlag, Berlin, 1993, pp. 122-141.
6. Reddy, U. S. Objects and Classes in Algol-like Languages. June 14, 1998.
7. Reynolds, J. C. Idealized Algol and its Specification Logic. In: Tools and Notions for Program Construction, An advanced course, Nice, France, December 7-18, 1981, edited by D. Neel. Cambridge University Press, Cambridge, England, 1982, pp. 121-161.

COMMENTS:

• Grading option - pass/fail
• Any Ph.D. student may register on-line; others by permission of the instructor only.

COURSE DESCRIPTION

COMMENTS:

• Grading option - Letter Grades
• No Final Exam: Project Course
• Enrollment Limit: 15

DESCRIPTION: Mobile computing devices such as laptop and palmtop computers are becoming widely available at very affordable prices, and many new wireless networking products and services are becoming available based on technologies such as spread-spectrum radio, infrared, cellular, and satellite. Mobile computers today often are as capable as many home or office desktop computers and workstations, featuring powerful CPUs, large main memories, hundreds of megabytes of disk space, multimedia sound capabilities, and color displays. Reasonably high-speed local area wireless networks are commonly available with speeds up to 2 megabits per second, and wide-area wireless networks are available that provide metropolitan or even nationwide service.

However, wireless networks have fundamentally different properties than typical wired networks, including higher error rates, lower bandwidths, nonuniform transmission characteristics, increased usage costs, increased susceptibility to interference and eavesdropping, and higher variability of performance. Similarly, mobile nodes behave differently and have fundamentally different limitations than stationary nodes. For example, mobile nodes generally operate on limited battery power and may move and change their point of connection to the network.

This course will examine the emerging area of mobile and wireless communications, through readings, lectures, class discussions, and a course project. We will address the topic more from the point of view of a computer scientist than a radio or cellular systems engineer, but will also cover the relevant aspects of the physical media. We will concentrate on the network protocols and other systems aspects of mobile and wireless communications.

PREREQUISITES: You should have had at least an undergraduate operating systems course and should have some familiarity with computer networking and networking protocols. Having taken an undergraduate or graduate networking class is preferred.

DESCRIPTION: This course will quickly cover the fundamentals of reconfigurable computing, e.g., current FPGA architectures, reconfigurable fabrics, applications, and CAD tools. We will then focus on the architecture and compilation for processors which integrate reconfigurable function units. During the first third of the semester we will mainly read and discuss three to five papers a week. During the rest of the semester the students will divide into groups, each group working on a project in either compilation or processor architecture. Each week we will discuss project progress as well as continue our readings of the literature. Each group will produce a conference ready paper.

SOME TOPICS TO BE COVERED:

• Rationale for reconfigurable computing
• FPGA architectures
• FPGA circuit basics
• CAD tools for programming FPGAs
• Fine-grained architectures
• Coarse-grained architectures
• Back-end Compilation techniques
• Hardware/Software Partitioning
• Software Pipelining
• Generators
• Processor-RFU integration

PREREQUISITES: Instructor Permission. Some experience on either computer architecture or compilers.

TEXT: Course notes and papers. There is no assigned textbook.

METHOD OF EVALUATION: Grading will be based on class presentations, class projects, and a final paper.

UNITS: 12

DESCRIPTION: TBA

COMMENTS:

• Grading Option: Letter grade only.
• No final exam; is a final project.

DESCRIPTION: Complex software systems must satisfy not only requirements about functionality but also requirements about other critical properties such as reliability, security, safety, and survivability. Achieving these properties draws on the limited resources available for system development, and designers must often trade off one property against another.

The degree to which each property matters can vary from one project to another. Indeed, the overall level of confidence you need in a system may vary from one project to another. Engineering design consists of making tasteful and appropriate choices.

This courses addresses the related questions of what constitutes "good enough" with respect to critical properties, how we design software systems that satisfy these criteria, and how we gather evidence to decide whether a given software system is good enough to use in a particular setting. We will examine properties of systems such as reliability, security, safety, and survivability and design/analysis techniques such as risk analysis, hazard analysis, error recovery, and associated design processes.

DESCRIPTION: TBA

NOTE: May be used for SCS elective credit only one time.

DESCRIPTION: TBA

DESCRIPTION: In this course, we will discuss basic techniques of computer systems performance analysis: experiment design, measurement, simulation, and modeling. The following topics will be covered: performance indices, evaluation techniques, workload design and characterization, instrumentation, experiment design, simulation design, model calibration, statistical analysis and interpretation of results, and analytical modeling. Examples will be drawn for case study from operating system, computer architecture, networks, and I/O systems. We will read a list of research papers and some chapters of Raj Jain's book. Students are expected to do a substantial course project by applying techniques learned from the class to a real world research problem.

PREREQUISITES: Two senior level system courses such as OS, Architecture, or Networking, or special authorization from the instructors.

TOPICS TO BE COVERED:

• System Measurement
  • metric
  • workload
  • monitoring
  • benchmarking
  • data presentation
• Statistics
  • statistical data metrics
  • sample data testing
• Experimental design
  • factorial design
• Simulation
  • design
  • analysis/interpretation of results
• Queueing models
  • Single queue
  • Queueing networks
  • Operational law/Mean Value Analysis/Back-of-Envelope Calculation

EVALUATION:

• Class participation: 10%
• Two exams: 20% each
• Final project: 50%

15-850A Algorithms for Indexing and Searching (Seminar)
Blelloch / Lafferty / Miller
W 3:00 - 5:20, WeH 4601
6 units

DESCRIPTION: With the growth of the Web and other online resources in recent years, the problems associated with managing massive amounts of data have become increasingly interesting and important. A variety of algorithms and techniques have emerged for indexing, filtering, searching, and transmitting these online resources. This course will present a selection of these techniques, with an emphasis on the underlying algorithms and the need to scale up to handle very large data collections. A particular focus of the seminar will be on spectral methods (eigenvalues, singular value decompositions, and graph partitioning) and randomized algorithms (sampling and dimension reduction) for clustering.

The course will be organized as a research seminar, meeting once a week. For each topic, the relevant background material will be followed by a presentation of recent research papers on the topic, together with a discussion of promising areas for future research. Students will be encouraged to participate in the presentation of research papers.

PREREQUISITES: The Computer Science Department's graduate algorithms core course, or equivalent.

TEXT: The seminar will be primarily based on recent research papers, and some course notes will be distributed. A reading list of relevant papers will be provided, as well as references to background material.

METHOD OF EVALUATION: Grading will be based on participation, including giving presentations, and a class project.

TOPICS TO BE COVERED:

• Indexing schemes for massive amounts of data
• Spectral methods for graph analysis
• Clustering and nearest neighbor search in high-dimensional spaces
• Approximation algorithms for singular value decomposition
• Statistical methods for clustering documents
• Efficient near-equality testing using randomized algorithms
• Cache replacement strategies
• Erasure codes for transmitting information

DESCRIPTION: An in-depth study of information processing in real neural systems from a computer science perspective. We will examine a variety of biological structures where processing is now sufficiently well understood that it can be discussed in terms of specific representations and algorithms. We will focus primarily on computer models of these systems, after establishing the necessary anatomical, physiological, and psychophysical context. There will be some neuroscience tutorial lectures for those with no prior background in this area.

COMMENTS:

• Grading Option: Letter grade only.
• Any graduate student may enroll; undergrads require instructor permission.
• There will be a final exam.

CONTENT: In this course we will teach the challenges of building autonomous agents that need to continuously plan, execute their actions, and learn from their interactions with the environment. In its essence, the autonomous agents need to "select actions" to achieve its objectives (and act, and monitor their execution, etc).

The course will be divided into the following main parts:

I. Deliberative Planning

Static and deterministic domains
Classical planning algorithms
Action representation, abstraction, goals, and heuristics
Learning: domain structure, search efficiency, solution quality

II. Planning under Uncertainty

Dynamic and nondeterministic domains
Conditional planning
Probabilistic planning
Learning: models, iterative planning algorithms

III. Plan Execution

Interleaved planning and execution
Reactive planning
Plan Monitoring
Replanning
Learning: model refinement, optimal policy, policy reuse

IV. Planning and Execution under Uncertainty

Uncertainty in state, goals, model, and observations
Markov models, POMDPs
Kalman-Bucy filter, Viterbi algorithm, and extensions
Learning: EM algorithm

EVALUATION: This will be a lecture course. There is no textbook, but students will study research papers. There will be homeworks, a research project, and a final exam.

Grading option - pass/fail or letter grade.

Description: This course is a graduate seminar course. We plan to cover a number of topics, with a special focus on statistical principles and algorithmic implementation in practical settings. We will consider applications such as language modeling, fMRI analysis, and analysis of data extracted from the WWW.

Topics that may be covered at some level include:

• Bayesian networks
• EM and its variants
• MCMC methods
• Population size estimation methods using multiple lists
• Boosting, Bagging, and other ensemble methods
• Support vector machines
• Learning over graphs
• Various models of the learning (function approximation) problem (i.e., minimize mean sq error, structural risk, description length, ...)
• Unsupervised learning

Prerequisite: Students should either have taken a CS course in machine learning and one course in statistics, or the statistics MS courses in intermediate statistics and regression analysis. Students should also have a knowledge of basic programming.

Enrollment will be limited to 25 students.