\def\LBild#1#2{{\line{\psfig{figure=#1.eps}\hfill}\vskip #2truecm}} \def\RBild#1#2{{\line{\hfill\psfig{figure=#1.eps}}\vskip #2truecm}} \def\CBild#1#2{{\line{\hfill\psfig{figure=#1.eps}\hfill}\vskip #2truecm}} \def\at{\char'100} \input psfig \hfuzz=3pt \hsize=12truecm \vsize=20truecm \nopagenumbers % \font\tenrm=cmr10 scaled\magstep0 \font\tensl=cmsl10 scaled\magstep0 \font\btwelferm=cmbx12 scaled\magstep0 \font\btenrm=cmbx10 scaled\magstep0 \font\seventeenrm=cmbx10 scaled\magstep2 \baselineskip=12pt \parskip=5pt \parindent=0pt \tolerance=4000 \tenrm % \vbox to44pt{ \vfill \leftline{\seventeenrm Forschungs- und Lehreinheit Informatik II:} \vskip0pt \leftline{\seventeenrm Formale Sprachen, \"Ubersetzer, Software-Konstruktion} \vfill\hrule} % \vskip4pt \leftline{\btenrm Prof. Dr. J. Eickel, Ordinarius} \leftline{Tel.: +49-89-2105-8262\hskip 1truecm Email:eickel\at informatik.tu.muenchen.de} \vskip22pt \leftline{\btwelferm 1. Schwerpunkte in Forschung und Lehre} \vskip12pt \leftline{$\bullet$ Spezifikation und Methoden zur Softwaregenerierung} \leftline{$\bullet$ Compiler und Compilergenerierung} \leftline{$\bullet$ Strukturelle Musterverarbeitung} \leftline{$\bullet$ Spezifikation und Generierung intelligenter Benutzungs\-ober\-fl\"a\-chen,} \leftline{\hskip 0.3truecm FUSE Sy\-stem} \leftline{$\bullet$ Dokumentarchitektur und Hypertext} \leftline{$\bullet$ Compilerunterst\"utzung der Programmierung (massiv-) paralleler} \leftline{\hskip 0.3truecm und verteilter Systeme} \leftline{$\bullet$ Algebraische Spezifikationen und dynamische attributierte Grammatiken} \vskip10pt {\btwelferm 2. Forschungs- und Entwicklungsprojekte} \vskip10pt Ein zentrales Ziel besteht darin, {\tensl Methoden} und {\tensl Werkzeuge} zu entwickeln, erweitern, analysieren, implementieren und in verschiedenen Bereichen anzuwenden, die es erm\"oglichen, aus hohen deklarativen Spezifikationen automatisch effiziente batchorientierte sowie interaktive Verarbeitungsprogramme zu generieren. M\"ogliche Anwendungsbereiche sind durch Verarbeitung komplexer rekursiver Datenstrukturen gekennzeichnet, die man am besten durch lineare- oder Graph-Grammatiken beschreibt. (Quell- bzw. Zielsprachprogramme in \"Ubersetzern, logische- bzw. Layout-Strukturen in Dokumenten, Applikationsstruktur bzw. Visualisierungstruktur bei Bedienoberfl\"achen usw.) Zur Spezifikation der Semantik wurde das Konzept der attributierten Grammatiken in verschiedenster Weise erweitert und herangezogen. Durch diesen deklarativen Ansatz lassen sich Klassen \"ahnlicher Softwareprodukte durch einheitliche Spezifikationen \hbox{und} Algorithmen realisieren. Neben der Sicherheit dieser Spezifikationsmethode ergeben sich als wesentliche Vorteile Modularit\"at, Flexibilit\"at gegen\"uber Modifikationen, einfache Integrationsm\"oglichkeit verschiedener Konzepte sowie Offenheit zu anderen Implementierungen und Implementierungsmethoden. Effizienzverbesserungen werden durch Transformation der Datenstruktur und aus der Analyse der semantischen Struktur nach problemunabh\"angigen Methoden gewonnen. Theoretische Untersuchungen zielen darauf ab, die syntaktischen und semantischen Methoden zu vereinheitlichen und sie mit anderen formalen Konzepten zu kombinieren, um den Spezifiaktionskomfort zu verbessern und in nat\"urlicher Weise weitere Anwendungsbereiche zu erschlie\ss en. Erstes Ergebnis in dieser Richtung ist eine neue Methode zur eleganten und knappen Spezifikation der statischen Semantik von Programmiersprachen basierend auf einer Kombination aus Pr\"adikatenlogik und Attributgrammatiken. Die aktuellen Arbeiten konzentrieren sich auf die Integration von Inferenzmechanismen in die Attributauswertung. Ziel einer derartigen Erweiterung ist zum einen die Behandlung dynamischer Semantik (z.B. Interpretergenerierung), zum anderen der Einbau von Logikkalk\"ulen in generierte Programmierumgebungen, so da\ss\ Programme mit Hilfe von benutzerdefinierten Anfragen analysiert und die Korrektheit von Zusicherungen bewiesen werden kann. %------------------------------------------------------------------------------- {\btenrm MUG, MAGIC, GMUG, MAX} Ausgehend von der Entwicklung und Implementierung von Generatoren zur syntaktischen Analyse in den 60er Jahren wurden in den 70er Jahren im Rahmen eines Sonderforschungsprojekts verschiedene \"Ubersetzergeneratoren unter der Bezeichnung MUG (Modularer bzw. M\"unchner \"Ubersetzer-Generator) entwickelt, die alle Phasen eines \"Ubersetzers generativ unterst\"utzen (Abbildung 1). Seit 1975 wird MUG u. a. regelm\"a\ss ig in Kursen zu etwa 50 Studenten zur Erstellung von verschiedenartigen Compilern eingesetzt. Als Sprachkonzepte werden u. a. auch Kommunikations- und Synchronisationsmechanismen gew\"ahlt. \vskip 0.3truecm \CBild{mug}{0} Neben klassischen operativen Quellsprachen werden auch logische, funktionale und objektorientierte Sprachen spezifiziert und untersucht. Ein wichtiger \hbox{Aspekt} ist dabei Parallelit\"at und Verteiltheit. Auf Zielsprachenebene wird die Spezifikation und Generierung von Code f\"ur parallele Architekturen sowie Optimierung durch Nutzung von Daten- und Speichercaches untersucht. In den 80er Jahren wurde MUG um die Komponente MAGIC (modulare, attributierte, graphische interaktive Spezifikation von Compilern) erweitert, die eine Entwicklungsumgebung f\"ur die Erstellung von graphischen Spezifikationen in Form abstrakter, attributierter Objektbeschreibungen darstellt. Das GMUG-System (1993) unterst\"utzt die Arbeit mit attributierten Graph-Grammatiken. Anwendungen hierzu finden sich bei Problemen wie z.B. der r\"aumlichen Analyse und Darstellung von chemischen Strukturen (s. folgende Abbildung) . \vskip 0.3truecm \CBild{vollath}{0} Auf der Basis der oben skizzierten Kombination aus Pr\"adikatenlogik und Attributgrammatiken wurde au\ss erdem das System MAX (M\"unchner Attributierungssystem f\"ur Unix) entwickelt. Es erlaubt zum einen knappere Spezifikationen auf h\"oherem Niveau, zum anderen macht es die analysierten und attributierten Syntaxb\"aume f\"ur nachfolgende Anwendungen vollst\"andig transparent. %------------------------------------------------------------------------------- {\btenrm Spezifikation und Generierung intelligenter Benutzungs\-ober\-fl\"a\-chen, FUSE Sy\-stem} Mit den heute verf\"ugbaren layout-orientierten Benutzungsober\-fl\"a\-chen-Werk\-zeu\-gen (Ober\-fl\"a\-chen-Bauk\"asten, Ober\-fl\"a\-chen-Edi\-to\-ren, User Interface Management Systeme) bleibt die Erstellung von graphischen Benutzungsober\-fl\"a\-chen aufwendig und fehleranf\"allig. Am Lehrstuhl werden daher neue Methoden, Modelle und Werkzeuge zur Spezifikation und Generierung von Benutzungsober\-fl\"a\-chen entwickelt. Die hierbei verfolgten Ziele lassen sich wie folgt zusammenfassen: \leftline{$\bullet$ Werkzeugunterst\"utzung f\"ur alle Phasen des Ober\-fl\"a\-chenentwicklungs-} \leftline{\hskip 0.3truecm prozesses (Anforderungsanalyse, Design, Implementierung),} \leftline{\hskip 0.3truecm M\"oglichkeit der Prototypen-Generierung} \leftline{\hskip 0.3truecm auch in fr\"uhen Phasen des Entwicklungsprozesses (Rapid Prototyping)} \leftline{$\bullet$ Normierung der Benutzungsober\-fl\"a\-chen} \leftline{\hskip 0.3truecm durch formale Spezifikation von software-ergonomischen Gestaltungs-} \leftline{\hskip 0.3truecm richtlinien (Definition von Styleguides)} \leftline{$\bullet$ Integration von Konzepten zur intelligenten Benutzerf\"uhrung und} \leftline{$\bullet$ Gew\"ahrleistung der Korrektheit von Benutzungsober\-fl\"a\-chen.} Diese Ziele werden erreicht, indem die Benutzungsober\-fl\"a\-che automatisch generiert wird aus formalen Spezifikationen der Applikation, der Benutzeraufgaben, der Funktionalit\"at f\"ur einzelne Benutzergruppen und der Dialog- und Layout\-richtlinien. Das zur Zeit im Arbeitsbereich entwickelte Gesamtsystem FUSE (Formal \hbox{User} Interface Specification Environment) besteht aus den Komponenten BOSS, FLUID und PLUG-IN. Die Architektur von FUSE l\"a\ss t sich wie folgt darstellen: \vskip 0.3truecm \CBild{fuse}{0} Den Ausgangspunkt der Benutzungsober\-fl\"a\-chengenerierung bildet eine formale Spezifikation der Applikationsschnittstelle, um so einen einheitlichen Rahmen f\"ur die Benutzungsober\-fl\"a\-chenentwicklung und die Applikationsentwicklung zu besitzen. Dar\"uberhinaus wird die Funktionalit\"at f\"ur verschiedene Benutzergruppen sowie die Spezifikation der Benutzeraufgaben als Grundlage f\"ur die Benutzungsober\-fl\"a\-chengenerierung verwendet. F\"ur eine Klasse von Benutzungsober\-fl\"a\-chen werden software-ergonomische Gestaltungsrichtlinien (Benutzungsober\-fl\"a\-chen-Styleguides) in Form von Layout- und Dialogrichtlinien spezifiziert. Mit dem FLUID-Generator (FormaL User Interface Development) ist es m\"oglich, aus der Spezifikation der Applikation die Dynamik-Beschreibung (Dialogablauf-Beschreibung) der Benutzungsober\-fl\"a\-che zu erzeugen. Der \hbox{FLUID}-Theorembeweiser erlaubt es, die Korrektheit der durch den Dialogdesigner modifizierten Dialogablaufbeschreibungen zu beweisen. Der gerade bei komplexen Benutzungsober\-fl\"a\-chen fehleranf\"allige und aufwendige Proze\ss\ des manuellen Dialog-Designs entf\"allt. Die Spezifikation der Layoutrichtlinien dient zusammen mit der von \hbox{FLUID} erzeugten Spezifikation der Benutzungsober\-fl\"a\-chendynamik als Eingabe f\"ur BOSS (Bedienoberfl\"achen-Spezifikationssystem), das daraus die ablauff\"ahige Be\-nut\-zungs\-ober\-fl\"a\-che in dem durch die Layoutrichtlinien beschriebenen Ober\-fl\"a\-chenstil erzeugt. Mit Hilfe der von FLUID generierten Spezifikation der Benutzungsober\-fl\"a\-chendynamik und der Spezifikation der Benutzeraufgaben wird mit PLUG-IN (Plan-Based User Guidance for Intelligent Navigation) eine intelligente Benutzerf\"uhrungskomponente erzeugt und an die von BOSS generierte Benutzungsober\-fl\"a\-che gekoppelt. Die Benutzerf\"uhrungskomponente unterst\"utzt den Benutzer w\"ahrend seiner Arbeit durch eine zustandsorientierte, abstrakte Benutzungsober\-fl\"a\-che sowie kontext-sensitive Hypertext-Hilfeseiten und Animationssequenzen. Als Beispiel ist in der Mitte der Abbildung~4 eine mit BOSS und FLUID generierte Benutzungsober\-fl\"a\-che f\"ur eine ISDN-Telefonsimulation dargestellt. Mit der von PLUG-IN generierten Hilfeseite (rechts) wird beschrieben, in welchem Zustand sich die generierte Benutzungsober\-fl\"a\-che befindet und welche Aktionen der Benutzer in diesem Zustand durchf\"uhren kann. Der aktuelle Zustand wird in einem von PLUG-IN verwalteten Zustands\"ubergangsdiagramm (links) hervorgehoben. Durch Interaktionen des Benutzers mit den Hypertext-Hilfeseiten bzw. der abstrakten Benutzungsober\-fl\"a\-che werden von PLUG-IN Ani\-ma\-tionssequenzen erzeugt, die unter Ber\"ucksichtigung des gew\"ahlten Layout-Stils zeigen, wie die Aktionen auf der Benutzungsober\-fl\"a\-che durchgef\"uhrt werden (s. Abbildung 4). %---------------------------------------------------------------------------------- {\btenrm Dokumentarchitektur und Hypertext} Logische Strukturen und Layoutstrukturen von Dokumenten lassen sich in nat\"urlicher Weise durch attributierte Grammatiken spezifizieren. Aus solchen Beschreibungen k\"onnen \"ahnlich wie bei Compilern effiziente Dokumentverarbeitungssysteme generiert werden. So wurde im Sommersemester 1993 erstmals im Rahmen des \"Ubersetzerbaupraktikums ein Mehrphasen\"ubersetzer f\"ur eine Dokumentverarbeitungssprache erstellt. Der Anwendungsbereich Dokumentarchitektur beinhaltet gegen\"uber Compilern komplexere Attributabh\"angigkeiten sowie eine nat\"urliche Erweiterung der logischen Struktur auf Graphen (Hypertext). Ein wichtiger Aspekt der laufenden Untersuchungen besteht darin, eine volle Symmetrie in der Spezifikation von Frontend (logische Struktur) und Backend (Layoutstruktur) von Dokumentverarbeitungssystemen herzustellen. Als Ergebnis dieser Untersuchungen steht seit 1995 mit AGENDA ("A Generative Approach To Document Architecture") ein Werkzeug zur Verf\"ugung, das die Generierung eines Dokumentverarbeitungssystems aus der Spezifikation der zugrundeliegenden Dokumentarchitektur erlaubt. %---------------------------------------------------------------------------------- {\btenrm Compilerunterst\"utzung der Programmierung (massiv-) paralleler \hbox{und} verteilter Systeme} Parallele, insbesondere massiv-parallele, und verteilte Systeme gewinnen mehr und mehr an Bedeutung. Neben den bekannten Vorteilen bleibt als Hauptproblem die hohe Komplexit\"at der Programmierung dieser Systeme. Eine Vereinfachung der Programmierung und eine Optimierung von parallelen \hbox{und} verteilten Programmen kann besonders \"uber Methoden des Compilerbaus erreicht werden. In dem aktuellen Forschungsprojekt "Konzepte zur Compilerunterst\"utzung der Programmierung massiv-paralleler und verteilter Systeme" werden entsprechende Konzepte entworfen, mittels der am Lehrstuhl entwickelten Distributed C Entwicklungsumgebung realisiert und an verschiedenen praktischen Beispielen untersucht. %---------------------------------------------------------------------------------- {\btenrm Strukturelle Musterverarbeitung} Die strukturelle Musterverarbeitung besch\"aftigt sich mit dem Erkennen, Auswerten und Ver\"andern von Relationen in komplexen Systemen. Um diese Aufgaben formal beschreiben zu k\"onnen, bedient man sich verschiedener, aus dem \"Ubersetzerbau bekannter, Standardverfahren, wie z.B. Syntaxanalyse, Attributierung und Baumtransformation. Ihre Anwendungen findet sie neben den klassischen Einsatzgebieten wie der Bildverarbeitung und -interpretation, auch in naturwissenschaftlichen Disziplinen wie Biologie, Chemie und Physik, da hier ebenfalls komplexe strukturierte Systeme wie z.B. Makromolek\"ule und Atomansammlungen untersuchen werden. Hierbei ist im speziellen das dynamische Verhalten der Systeme von gro\ss em Interesse. So untersucht man beispielsweise bei Problemen der Proteindynamik die Wechselwirkungen der die Struktur bestimmenden Atome. Da es sich bei einer Vielzahl dieser Problemstellungen um mutierende graphartige Gebilde handelt, bieten sich Graphgrammatiken bzw. -ersetzungssysteme als ad\"aquates Beschreibungsmittel f\"ur deren Struktur und Dynamik an. Durch die inh\"arente Komplexit\"at dieser Systeme ist f\"ur die effiziente Berechnung eine verteilte Verarbeitung sinnvoll. Im Rahmen des Forschungsprojekts "Verteilte Realisierung von Spezifikationsmodellen aus dem Compilerbau und Compiler f\"ur verteilte Programmierung" wird untersucht, inwieweit die den Systemen zugrundeliegenden Strukturen, welche mittels Graphgrammatiken formal spezifiziert werden, f\"ur eine optimale Verteilung der Berechnungen ausgen\"utzt werden k\"onnen. Aus der verteilten Realisierung eines formalen Graph\-ersetzungssystems erh\"alt man somit eine Plattform, auf welcher eine gro\ss e Klasse von Anwendungen automatisch verteilt umgesetzt werden kann. %---------------------------------------------------------------------------------- {\btenrm Algebraische Spezifikationen und dynamische attributierte Grammatiken} Es wird der Einsatz \"ubersetzererzeugender Methoden und Werkzeuge zur Implementierung h\"oherer semantischer Modelle untersucht. Insbesondere werden dabei die Vorteile der algebraischen Spezifikationen, wie z.B. Korrektheit, sowie der attributierten Grammatiken, wie etwa Effizienz, vereint. Bei der Verbindung der beiden Konzepte bietet es sich an, attributierte Grammatiken zu dynamischen attributierten Grammatiken zu erweitern. Dar\"uberhinaus werden dabei Aspekte untersucht, die f\"ur aktuelle Anwendungsgebiete von hohem praktischen Nutzen sind, wie etwa die Korrektheit von Compilern, Beobachtbarkeit bei Bedien\-ober\-fl\"a\-chen oder attributgesteuerter Datenstrukturaufbau f\"ur adaptive Berechnungen. Diese neu entwickelten Ans\"atze werden durch prototypm\"a\ss ige Realisierungen erprobt. \CBild{plug_in4}{0} \vfill \supereject \end