Since I have to write a trip report anyway, here are my comments for a
wider audience. I apologize for anything I may have misunderstood or
wrongfully criticized - maybe we'll get another flame war going!

Uwe Kastens opened the conference introducing the keynote speaker, the
"father" of Pascal, Niklaus Wirth. [BTW, what ever happened to the
mother, Kathleen Jensen?]

He spoke on "30 Years of Programming Languages and Compilers", which
included some controversial points and a lot of C-bashing ("Thirty years
undone by C"). Important points were the demand that software designers be
made to work with slow machines (the audience approved!), and admonitions
to be intolerant of mediocre software, to use the tools you develop
yourself, to emphasize the value of clarity and abstraction, and to write
programs as if they were to be published.

The following is a list of the talks with some notes I made;

* Creation of a Family of Compilers and Runtime Environments by Combining
Reusable Components. Christian Weber (Siemens, Muenchen), a variation of
the universal compiler with an application level protocoll to decouple
compilers from the run-time environment

* The LDL - Language Development Laboratory. Guenter Riedewald (Rostock)
uses a Prolog-like specification of languages and attribute grammars to
generate prototypes and a test set for the language defined.

* Transformation of Attributed Trees Using Pattern Matching. Josef Grosch
(GMD Karlsruhe) all about Puma, a tree transformation part of the GMD
Cocktail

* Generating LR(1) Parsers of Small Size. Jose Fortes Galvez (Valbonne)
presented by O. Lecarme. The method looks back into the stack at parse
time to determine the parsing action. Unclear how this differs from usual
construction of parser using viable prefixes, and why one would sacrifice
time to save space anymore.

* Integrated Graphic Environment to develop Applications based on
Attribute Grammars. Tibor Gyimothy, Zoltan Alexin (Szeged, Hungary).
Pictures of attributed grammars in C for Windows for use in teaching.

* Implementing High-Level Identification Specifications. Arnd
Poetzsch-Heffter (TU Muenchen). Specification of the visibility of
identifiers. Seems to work okay for declare-before-use languages, but
under questioning it was determined that it might not work for FORTRAN.

* Another Kind of Modular Attribute Grammars. Beate Baum (Rostock).
Something to do with attribute evaluation across module boundries, but the
slides were so full of tiny script my old eyes couldn't decipher much.

The Workshop Dinner was delicious, and at our table we used up all our
napkins drawing pictures of parsing techniques and register coloring
algorithms and such.

* The Interprocedural Coincidence Theorem. Jens Knoop, Bernhard Steffen
(Kiel, Aachen). A stack-based approach to interprocedural data-flow
analysis, can even handle programs with mutually recursive procedures,
global and local variables, and formal parameters, but not dynamic data
structures. Uses a stack of lattices, not a lattice.

* Provably Correct Compiler Development and Implementation. Bettina Buth,
K.-H. Buth, M. Fraenzle, B. V. Karger, Y. Lakhneche, K. Langmaack, M.
Mueller-Olm (Kiel). Describes how to boot-strap a provable correct
compiler using an untrusted compiler. The goal is a proven correct
compiler for a subset of occam written in a subset of Lisp on the
transputer.

* Testing Completeness of Code Selector Specifications. Helmut Emmelmann
(GMD Karlsruhe). A tree pattern matcher to test the completeness of code
selection. Using the method they found a code selection that was wrong,
but had survived the boot-strap, as it was not used in the boot-strap.

* Scheduling Instructions by Direct Placement. Robert Griesemer
(Zuerich). Seemed to be the method that one would pick naively, and didn't
exactly win prizes for speed.

* A Term Pattern-Match Compiler Inspired by Finite Automata Theory.
Mikael Pettersson (Linkoeping). A complicated method that purports to use
regular expressions (without Kleene star) and FDA to factor out common
sub-expressions in a functional language and achieve absolutely no
reduction in code size.

* Improving the Performance of Parallel LISP by Compile Time Analysis.
Juergen Knopp (Siemens, Muenchen) using intra-procedural abstract
interpretation to eliminate some of the overhead in Parallel LISP.

* FCG: A Code Generator for Lazy Functional Languages. Koen Langendoen,
Pieter Hartel (Amsterdam). The young man with a rather large ego tried to
explain functional programming to us. His method isn't actually for lazy
languages (the front- end takes care of that) and he compiles rather
simple-mindedly to C and uses the optimizations of the C compiler to get
some good-looking numbers that are compared to numbers from incomparable
systems. He was not aware of any of the related work pointedly asked
about in the question session.

* Compiling Flang. Andrei Mantsivoda, Vyacheslav Petukhin (Irkutsk).
Flang offers both functional and logic programming, but it was not
entirely clear how the functional part was integrated. The language is
similar to Prolog and compiles to the FAM, the Flang Abstract Machine
which is similar to the Warren Abstract machine.

* The Implementation of ObjectMath - a High-Level Programming Environment
for Scientific Computing. Lars Viklund, Johan Herber, Peter Fritzson
(Linkoeping). A wonderful combination of Mathematica, emacs, an object
browser and C++ for developing and visualizing mathematical models for
scientific programming. Has been sucessfully used industrially for some
tasks in machine element analysis. Seems to be a very sucessful method for
computer-aided engineering.

It was a wonderfully organized conference (thanks to Peter Pfahler and his
crew!), the next CC will be held in Edinburgh in 1994.