COP 5021 lecture -*- Outline -*-

* summary and review

** what to read in the rest of the book
   rest of chapter 4: systematic design of Galois connections,
      how to use the theory to calculate (induce) an analysis
   chapter 5 describes type and effect systems,
      including type inference and effect analysis
   chapter 3 treats constraint-based analysis,
      including control flow analysis (0-CFA),
       and SOS for a functional language,
       k-CFA (using contexts, as in interprocedural),
       this can be usefully applied to OOP as well
   chapter 6 deals with algorithms

   might want to reread chapter 1 for review

** technical ideas
   Q: what technical ideas did we discuss?
   dataflow analysis:
      blocks and data flow graph
      dataflow equations/constraints, summarized by generating function
      chaotic iteration for solving equations/constraints

      property space
      monotone functions
      least fixed points

      kill and gen functions
      ud and du chains

   abstract interpretation
      abstraction (rep function), concretization (correctness relation)
      collecting semantics
      Galois connections, adjunctions
      logical relation
      approximation of fixed points using widening operator

   type and effect systems
      type inference rules and axioms
      subsumption

   theory
      denotational semantics
      structural operational semantics

   monotone frameworks
      complete lattice
      ascending chain condition

   interprocedural analysis
      context information
      store + environment
      scope rules
      flow insensitive analysis

   shape analysis
      location, abstract location
      heap, abstract heap
      compatible shape graph

** intuitions
   Q: what intuitions did we discuss?
      safe approximations (and relation to lattice ordering)
      precision
      "may" and "must" analysis
      forward and backwards analysis
      property space and correctness relation/representation function

** relationships/questions
   Q: what kind of questions did we ask?
      Is the analysis correct?
      How precise?  (relational analysis vs. independent)
      How efficient?

** limits
   Q: what are the limits of the theory that we've studied so far?
      mostly applied to procedural languages (but see book for more...)
      haven't dealt with OO features much (references, dynamic dispatch,...)

      have basically done without extra annotations
      no interaction with dynamic execution (runtime checking)

** research
   Q: How does this relate to your research?