Travel report ETAPS 98 (CC 98), Lissabon

This year the CC conference was part of ETAPS, a series of 5 conferences and several workshops. Its URL is http://www.di.fc.ul.pt/~llf/etaps98
 
 
  •  Foundations of Software Science and Computation Structures (FoSSaCS)
  •  Fundamental Approaches to Software Engineering (FASE)
  •  European Symposium On Programming (ESOP)
  •  International Conference on Compiler Construction (CC)
  •  Tools and Algorithms for the Construction and Analysis of Systems (TACAS)

    • At least the latter 3 are interesting for the institute. About 380 people attained the ETAPS; you could meet a lot of people, and ETAPS seems to stabilize as major European conference event. Fiadeiro organized very well, almost everything worked out fine, except some beamer demos. The next ETAPS is in Amsterdam, between 22 and 26 of March 1999.  IPD should send somebody there, showing up seems to be important. Attention: also ECOOP 99 is exactly at the same place. Write papers!

    Lisboa is a pretty city, although old and rotten. Wonderful fish for less money (10-12 DM). Salmon, monc fish, eagle fish, calamares, grilled, cooked, and baked, you miss it after you have tasted it. Nice wine: Messias, Dao, Angelus. Wonderful fresh white wines from whom I don't remember the names. But there is a shop Napoleao who ships to here, so who wants to buy with me?
     

    Invited lectures:

     
  •  Kent Beck, CSLife Boulder, CH: Extreme programming ­ a humanistic discipline of programming. Very nice talk on project management. Beck is one of the Smalltalk popes and does projects with Smalltalk. Major message: all software project management models fail in practice; don't use them, only use 'use cases' (he called them stories) and a incremental development process. Implement some working functionality as early as possible, and refactor that with new use cases.  Testing is done along this process, so that you always have a working version.  Support type schema changes during the development. Stories are directly interviewed with the customer, form requirements, and are written down on small card sheets. When you have implemented all stories, the customer is satisfied. Do important stories first.
  • Randy Bryant, Carnegie Mellon University, USA:  Formal verification of pipelined processors. The father of the ordered binary decision diagrams (OBDD). Very successfull in hardware verification. The verification of hardware pipelines should be looked at by VERIFIX.
  • Margaret Burnett, Oregon State University, USA: Challenges and opportunities visual programming languages bring to programming language research Superficial talk on visual programming. Programming by examples. Visual macro definition. (Karlander). Spreadsheet-based (Burnett). Rule-based (COCOA, KidSim, Smith/Cypher). Well, nothing revolutionary.
  • Cliff Jones, Harlequin Ltd, UK: Some mistakes I made and what I learned from them Jones has been a theorist (VDM) but now works for Harlequin (Postscript, Lisp, ML systems, old COMPARE partner). And he made a talk on mistakes. Main message: theory must be put to practice, else it is useless. Be simple, otherwise nobody will understand you: "Some people can't abstract". His talk was very much critisized (due to all the theorists present), but that only enforced his message. Nice paper, read it.
  • Michael Mislove, Tulane University, USA:  Generalizing domain theory: Some new developments in denotational semantics, they work on modules now, since the old style leads to too complex specifications
  • Amir Pnueli, Weizmann Institute, IL:  Practical formal verification: how close are we? Model checking is the major technique for verification. The extension to software verification should be possible.
  • Gert Smolka, University of Saarbruecken, D:  Concurrent constraint programming as an extension of functional programming Nice talk on how to split LISP futures in two simpler concepts: promises and Smolka-futures.  With those other concepts such as streams, closures, partial applications can easily be built. This should be investigated further, but I don't know whether Smolka has a paper. He wants to integrate the concepts into SML. Interesting.

    • Other talks I attended: FASE and TACAS

    Major remarks: Integration of different formal models is trendy: CSP-Z, PetriNets ++, etc. Model checking used everywhere.
     
  • Constructs, concepts and criteria for reuse in concurrent object-oriented languages, U.Lechner (U St.Gallen, CH): Several kinds of inheritance (oo people, have a look). Uses mu-calculus and model checking with bisimulations for conformance checking (->Welf).
  • Navigation expressions in object-oriented modelling, A.Hamie,  J.Howse and S.Kent (U Brighton, UK):  Navigation expressions are path expressions that collect classes. Similar to graph expressions in Databases and Datalog. Nice.
  • Model-checking CSP-Z, A.Mota and A.Sampaio (U Pernambuco, Br): This and the previous talk presented model checkers for CSP.  CSP-Z is aspect-oriented: CSP events are join points of aspect weaving. This is interesting, since it is the first approach I saw where somebody has used aspect orientedness to integrate two formal models. Important!
  • RELVIEW - a system for calculating with relations and relational programming, R.Behnke, R.Berghammer, E. Meyer and P.Schneider (U Kiel, D): A nice system for relational programming. But only a subset of Datalog. Berghammer didn't even know what Datalog is (!). Explicit fixpoint calculations. But nice visualisations, different interchange formats.  Interesting for FAMOOS: ftp://ftp.informatik.uni-kiel.de/pub/kiel/relview   http://www.informatik.uni-kiel.de/~progsys/relview.html
  • Combining finite automata, parallel programs and SDL using Petri nets, B.Grahlmann (U Hildesheim, D): http://www.informatik.uni-hildesheim.de/~pep/HomePage.html
  • Modular model checking of software, K.Laster and O.Grumberg (Technion, IL), Not attended but interesting!

    • CC

    CC was not so interesting this time. A lot of epsilon talks (ith epsilon progress). Annoying. Parallel to CC ESOP was scheduled. This was a major competition which did harm to CC.
     
  • Myths and facts about the efficient implementation of finite automata and lexical analysis, K.Brouwer, W.Gellerich and E.Ploedereder (U Stuttgart, D) :  Comparisons of scanners on ADA benchmark sets.  Waite's method is the fastest: it encodes states into control flow. Table driven scanners are slower! (but not much slower).  This may also depend on the programming language.
  • Generalised recursive descent parsing and follow-determinism, A.Johnstone and E.Scott (U London, UK): Weak talk on a specific LL parser generator. Naja, schwach.
  •   Analyzing direct non-local dependencies in attribute  grammars, JT.Boyland (CMU, USA): Extension of AG with non-local dependencies (graph-like).
  •   Basic-block graphs: living dinosaurs?, J.Knoop, D.Koschützki (U Passau, D) and B.Steffen (U Dortmund, D): Well. Steffen tried to sell that we should use an edge-based control flow graph in which the edges are nodes (and encode state). But it was not really convincing, in particular, since they had not implemented it in a real compiler. Not enough evidence.
  •   Analysis of loops, F.Martin, M.Alt, C.Ferdinand and R.Wilhelm (U Saarlandes, D): One of the best papers: PAG has been extended to handle loops as procedures. Then first and latter iterations can be distinguished in DFA. Nice.
  •   A new approach to control flow analysis, P.Malacaria and C.Hankin (Imperial College, UK)
  •   Flow logics for constraint based analysis, HR.Nielson and F.Nielson (U Aarhus, DK): Again, Nielson did a hard to understand talk, presenting his logic for abstract interpretation. It can be translated to AGs and to constraint systems. However, didactics.. And he could not answer how to compare to other logic-based approaches such as Warren's XSB, Reps, or Optimix. Sigh.
  •   Extended SSA numbering: introducing SSA properties to languages with multi-level pointers, C.Lapkowski and LJ.Hendren (McGill U, CA): Double SSA numbering for pointers: if p is a pointer, *p gets a second SSA number. Martin does it much better!
  • Strength reduction via SSAPRE, R.Kennedy, F.Chow, P.Dahl and M.Streich (Silicon Graphics, USA): Message: without strength reduction bad partial redundancy elimination. Integration of strenght reduction into the Steffen/Knoop analysis.
  • Detecting parallelism in C programs with recursive data structures, R.Ghiya, LJ.Hendren and Y.Zhu (McGill U, CA):  Somewhat annoying talk, since we could parallelize Modula programs on lists already 1992. They can do more, but some parts are very similar to the old PRISMA system.
  • Mooly Sagiv did a talk on how to find statement dependences in linear time from arbitrary alias analyses. Well.
  • A code motion framework for global instruction scheduling, R.Gupta (U Pittsburgh, USA): Very interesting: scheduling explained as data-flow problem in the style of partial redundancy elimination (upsafe, downsafe etc). This could be a very interesting extension of our BURIS code generation: generate the scheduler data flow equations with Optimix, and integrate it into BURIS (->Thilo).
  • VLIW compilation techniques for superscalar architectures, E.Stümpel, M.Thies and U. Kastens (U Paderborn, D): How to adapt a VLIW backend for superscalars.
  • Portable debugging and profiling, M.Pettersson (INRIA, F): Nice talk about how to introduce a virtual debugger into generated code. Normally generated code can be debugged very difficultly. However, one can generate data and statements for a virtual debugger into the generated code (say breakpoints, stack access, etc) and this helps a lot. Important for all tool builders.

    •