CSE 788Q07

• General:
  • Course Information
  • First day quiz
  • No class on Tuesday, October 6.

• Slides:
  • Part 1 (ppt)
  • part 2 (ppt)
  • part 3 (ppt)
  • part 4 (ppt) (very much under construction)

• References:

  • Languages:
    • Paper by Cardelli, Wegner: This is an important paper on polymorphism, types, etc. Cardelli later wrote a book called "Theory of objects"; rather hard to read without a strong math logic background.
    • Slides by Cardelli on class-based vs. object-based languages; reasonable paper on delegation-based languages.
    • Block structure and OO languages, Madsen.

    • I just came across this site on Smalltalk; free online books! If you scroll down the page you will see (different versions of) a book by Goldberg and Robson. That is the original Smalltalk book. If you haven't come across the language, it is worth exploring. Squeak is (sort of) a dialect of Smalltalk. I thought we had an implementation on the stdsun but I seem to have been mistaken. Anyway, you should be able to download implementations for Windows or Linux if you want to play with it.
    • Ruby book.
    • Self: one of the main prototype-based OO languages. See also the Wikipedia page on the topic. Also useful is the Wikipedia article on types (and static vs. dynamic typing).

    • SML: SML is "standard ML", ML being a rather influential language that was designed in the seventies. Not only did it introduce a very clean type structure, it also introduced the idea of type inferencing. Very much worth looking into.
    • Elements of ML programming, Ullman: good book on ML.
    • CAML: OCAML is the object oriented version of ML; has many fans.
    • Standard book on Haskell. Also see this page.

    • Art of the metaobject protocol, Kiczales and others: This is a rather important book that introduced many ideas that went into Java and, more recently, into AspectJ. Many people consider MOP's facilities as very much superior to Java's and AspectJ's facilities. Definitely worth reading.
    • AspectJ in Action (widely used reference for AspectJ)

  • Models of concurrency:
    • Original CSP paper: If you do a search on "communicating sequential processes", you will get many hits. But this original paper is worth reading.
    • UNITY etc.: Somewhat more (and less?) than a language; very influential in reasoning-related research. The original UNITY book is, K. Mani Chandy and Jayadev Misra. Parallel Program Design: A Foundation. Addison-Wesley, 1988. Other useful references:
      • B. Sanders, Eliminating the substitution axiom from UNITY logic. Formal Aspects of Computing, 3(2):189-205, April-June 1991.
      • A long series of papers on UNITY.
    • J. Misra, A logic for concurrent programming: Progress. Journal of Computer and Software Engineering, 3(2):273-300, 1995.
    • Pi calculus:
      • Spi calculus.
      • The original pi-calculus paper (don't miss part 2 of the paper).
      • All things about pi-caluclus?

    • Survey of inh. anomaly and original inh. anomaly paper: This is about problems involving synchronization conditions (in concurrent programs) and inheritance (of OO languages).

  • Patterns related: [Note: I have copies of most of these books that you are welcome to borrow.]
    • The original book on patterns by Gamma, Helm, Johnson, Vlissides ("Gang of Four" book)
    • Book by Shalloway and Trott: Bit easier to read.
    • "POSA" books (I know only about the first two volumes; there are apparently two more now).
    • "Head first book on patterns": Some people hate this book; others love it.
    • Meyer book ("OOSC")
    • Horstmann's book on OO design in C++
    • Design Pattern Implementation in Java and AspectJ, Hanneman, Kiczales (OOPSLA '02): shows how patterns can be implemented.

  • Methodologies etc.:
    • Fairly decent set of faqs on XP (includes links to JUnit etc.). (There is a lot of controversy about XP, including whether it is simply glorified hacking; if you are interested in methodologies, this would be be an interesting topic to explore.
    • UML, RUP.
    • Comparison of methodologies.

  • Reasoning related:
    • Separation logic: This is an approach to reasoning about situations where aliasing may occur. The approach has been extended to deal with various problems. See, for example:
      • Separation logic and abstraction
      • Enhancing modular OO verification with separation logic (definitely worth reading but kind of involved);
      • Resources, Concurrency and Local Reasoning; etc.
      This is a good topic for your second paper. Important problem, fairly focused discussion/approach.
    • Jones book
    • Paper on refinement calculus; see also: tutorial on ref. calc.
    • Behavioral notion of subtyping (Liskov, Wing): This is an important paper on reasoning about OO systems.
    • Paper by Hoffman, Snodgrass on trace specs
    • On object systems and behavioral inheritance (Harel, Kupferman): An interesting paper that takes a different approach to defining behaviors of OO systems.
    • Covariance and contravariance: conflict without a cause: Discusses the question of covariance vs. contravariance. See also later papers by Bruce, Chambers, Leavens etc.
    • Weide et al., On the Practical Need for Abstraction Relations to Verify Abstract Data Type Representations, IEEE TSE, 1997: Considers some involved situations with respect to rep and retr functions.
    • Guarded Commands, Nondeterminacy and Formal Derivation of Programs, Dijkstra, CACM, Vol. 18, no. 8, pp. 453--457, 1975; also, Discipline of programming, book by Dijkstra.
    • Paper on completeness (scanned)
    • Proofs of networks of processes, Misra and Chandy: Important paper but difficult to read!
    • Proof System for Communicating Sequential Processes: Easier to read but not as good a system.
    • Verifying properties of parallel programs: an axiomatic approach: Classic paper, difficult to read.
    • Good survey paper on rely-guarantee methods.
    • My paper on CSP proof system: Easy to read but the Misra, Chandy paper above is a much better system.
    • Paper on full abstraction; there seems to be a controversy about full abstraction with some people arguing that it is not a good idea. This (controversy) may be a good topic for the second paper. Do a search.
    • Formalizing patterns, Mikkonen: One of the early papers on formalizing patterns.
    • My paper (with Jason Hallstrom) on formalizing patterns. (Some other papers in ~neelam/papers). (Another formalization paper: by Aline Lucia Baroni).
    • For fun: Social processes and proofs of theorems and programs, deMillo, Lipton, Perlis, CACM, 1979; see also this one.

  • Other:
    • Model checking is an important approach to checking the behavior of programs. The approach works as follows: You build a (usually highly simplified) model of the system you are interested in. You specify some property that the (model of the) system should exhibit; this is usually expressed using a temporal logic although this is not a requirement of the approach. An automated system can then "run" the model in all possible ways to check if in each of those paths the specified property holds. If it finds a counterexample, it displays that and you know you have a problem. If not, you can conclude that the property is satisfied (because the system has checked all possible paths). The Wikipedia article on "model checking" seems to be decent and has the links to some key references including the main 1986 paper by Clarke, Emersen, and Sistla. The main innovation of their work was finding ways to do this efficiently because the "state explosion" problem makes naive exhaustive approaches totally unworkable.

      Recently I came aross this book called "Software abstractions: logic, language, and anlysis" by Jackson. The book presents a specification language called "Alloy" that Jackson (and others) have developed. Much of the work in model checking uses (in my opinion) unreadable temporal logic notations. By contrast, Alloy is similar to languages such as "Z" (pronounced "zed"; look for paper by Jackson: A comparison of object modelling notations: Alloy, UML/OCL, and Z) and allows you to write readable models and properties. But unlike Z, Alloy has a tool that uses model checking-like approaches to allow you to test whether the model satisfies the specified properties. Except that it is not {\em exhaustive} (unlike standard model checking systems); so even if a given system does not satisfy a specified property, the Alloy checker may not find a counterexample . Nevertheless, Alloy seems fairly powerful and Jackson's book is very readable.

      One could easily write both the papers for the class on this topic. The first paper could be on modeling languages such as Z, Alloy, even UML. The second paper could be on model checking approaches.

    • Testing OO programs is also an interesting area with quite a bit of work in it. (Nasko is very active in this area.) Testing Object-Oriented Systems: Models, Patterns, and Tools by Binder is a standard reference. But there are many other (and much shorter) discussions of the topic. This site seems a decent one with links to many other relevant sites.