From: dww@inf.fu-berlin.de
Newsgroups: comp.compilers
Subject: Subjective report on the Compiler Construction '92
Keywords: conference
Date: 12 Oct 92 21:41:16 GMT
Reply-To: dww@inf.fu-berlin.de
Organization: Free University of Berlin

Trip report: INTERNATIONAL WORKSHOP ON COMPILER CONSTRUCTION: CC'92

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

* ACTRESS: an Action Semantics Directed Compiler Generator.  Deryck F.
Brown, Hermano Moura, David A. Watt (Glasgow) uses action semantics
(similar to denotational semantics) to specify a compiler.

* 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.

* Syntax Directed Translation with LR Parsing.  Borivoj Melichar (Prague).
Just seemed to be attribute grammars with output actions.

* Attribute-Directed Top-Down Parsing.  Karel Mueller (Prague) Gave an
example of parsing a^n b^n c^n with an attributed context free grammar
using an attribute stack.

* Compiler Implementation of ADTs Using Profile Data.  A. Dain Samples
(Cincinnati). Uses profiles of actual program runs to select concrete
implementations of abstract data types and then recompile.

* 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.

* Another Solution of Scoping Problems in Symbol Tables.  Werner Assmann
(Berlin) using visibility sets and overload resolution tables.

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.

* On Interprocedural Data Flow Analysis for Object-Oriented Languages.
Mario Suedholt, Christoph Steigner (Koblenz) More data-flow analysis.

* 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.

* A Register Allocation Framework Based on Hierarchical Cyclic Interval
Graphs.  Laurie J. Hendren, Guang R. Gao, Erik R.  Altman, Chandrika
Mukerji (McGill, Montreal). A method for coloring registers using cyclic
interval graphs and "chameleon intervals" that change color. Laurie wins
the prize for the most entertaining presentation!

* Register Pipelining: An Integrated Approach to Register Allocation for
Scalar and Subscripted Variables.  Evelyn Duesterwald, Rajiv Gupta, Mary
Lou Soffa (Univ. of Pittsburgh) Live range analysis, recognition of
aliasing, iteration distance.  Avoiding redundant loads of array elements.

* Instruction Scheduling for Complex Pipelines.  M. Anton Ertl, Andreas
Krall (Wien). Avoiding pipeline stalls, data hazards and strutural
hazards.

* Comparing Software Pipelining for an Operation-Triggered and a
Transport-Triggered Architecture.  Jan Hoogerbrugge, Henk Corporaal
(Delft) Compiles directly to register-register transports. Useful for
superpipelining.

* 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.

* Compile-Time Analysis of Object-Oriented Programs.  J.  Vitek, R. N.
Horspool, J. Uhl (Victoria, Canada). Attempt to determine at compile time
which methods will be used.

* Partial Evaluation of C and Automatic Compiler Generation.  Lars Ole
Andersen (Copenhagen). Uses partial evaluation to reinvent a scanner
generator.

* 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. 

The proceedings appear in LNCS.
-- 
Debora Weber-Wulff                       dww@inf.fu-berlin.de
Institut fuer Informatik                 +49 30 89691 124
Nestorstr. 8-9
D-W-1000 Berlin 31
-- 
Send compilers articles to compilers@iecc.cambridge.ma.us or
{ima | spdcc | world}!iecc!compilers.  Meta-mail to compilers-request.
Newsgroups: comp.compilers