Aktuelle Themen aus dem Gebiet der Funktionalen Programmierung
Werbung
Themen und weitere Hinweise für das Seminar: Aktuelle Themen aus dem Gebiet der Funktionalen Programmierung [FP-S] Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2010 Inhaltsverzeichnis 1 Organisatorisches 2 1.1 Vorbesprechung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 Webseite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.3 Modulabschlussprüfung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 2 Allgemeines 2 3 Themen 5 3.1 Language and program design for functional dependencies . . . . . . . . . . . 5 3.2 Lazy evaluation and delimited control . . . . . . . . . . . . . . . . . . . . . . 6 3.3 HMF: Simple type inference for first-class polymorphism . . . . . . . . . . . . 7 3.4 A compositional theory for STM Haskell . . . . . . . . . . . . . . . . . . . . 8 3.5 Typed closure conversion preserves observational equivalence . . . . . . . . . . 9 3.6 Small-step and big-step semantics for call-by-need . . . . . . . . . . . . . . . 10 3.7 Making “Stricterness” More Relevant . . . . . . . . . . . . . . . . . . . . . . 11 3.8 Purely functional lazy non-deterministic programming . . . . . . . . . . . . . 12 3.9 Static contract checking for Haskell . . . . . . . . . . . . . . . . . . . . . . . 13 3.10 Branching vs. Linear Time: Semantical Perspective . . . . . . . . . . . . . . . 14 1 1 Organisatorisches 1.1 Vorbesprechung Für die Teilnahme am Seminar, ist es u.a. notwendig bei der Vorbesprechung anwesend zu sein. Die Vorbesprechung findet am Dienstag, den 9.2.2010, 14 c.t. in Seminarraum 307 (Informatikgebäude, 3. OG) statt. Sollten Sie aus nachvollziehbaren Gründen nicht an der Vorbesprechung teilnehmen können, so teilen Sie dies uns bitte vorher mit! 1.2 Webseite Es existiert eine Webseite zur Veranstaltung, die stets aktuelle Informationen zum Seminar, wie Terminplan, Raumänderungen, Themenliste usw. enthält. Die Seite ist über http://www.ki.informatik.uni-frankfurt.de/lehre/SS2010/FP-S zu finden. 1.3 Modulabschlussprüfung Die Modulabschlussprüfung ist bestanden, falls sowohl die Ausarbeitung als auch der Vortrag mit mindestens ausreichend“ (4.0) bewertet wurden und regelmäßig teilgenom” men wurde. Die Note der Prüfung berechnet sich aus dem Durchschnitt der Note für die Ausarbeitung und der Note für den Vortrag. Die Noten für Vortrag und Ausarbeitung werden erst am Ende der Vorlesungszeit vergeben. 2 Allgemeines Die vorgesehenen Themen für das Seminare sind im Abschnitt 3 dieses Dokuments zu finden. Dort sind auch kurze Beschreibungen der einzelnen Themen sowie Literaturhinweise und Links auf Online-Ressourcen im WWW zu finden. Für das erfolgreiche Absolvieren des Seminars ist folgendes Vorgehen empfohlen bzw. ist folgendes zu beachten: 1. Finden der angegebenen Quellen (möglichst sofort damit beginnen): • Wo gibt es die angegebene Literatur? • Bücher sind eventuell verliehen und müssen vorbestellt werden. • Funktionieren die Links ins WWW? 2. Prüfen der angegebenen Quellen: • Welche Informationen sind dort zu finden? 2 • Welche der gefunden Informationen sind nützlich? • Welche Informationen fehlen oder reichen die vorhandenen Quellen? 3. Suchen eigener Quellen • Literaturrecherche via Bibliotheksdatenbanken (OPAC, Institutsbibliothek) • Literaturrecherche via Internet (Suchmaschinen wie z.B. Google) 4. Erstellen eines Konzepts • Welche Aspekte sollen in die Ausarbeitung? • Gliederung der Ausarbeitung • Stichpunkte zu den einzelnen Unterpunkten • Seitenzahlen abschätzen für die einzelnen Gliederungspunkte. 5. Besprechung des Konzepts mit einem Betreuer Vor der Besprechung muss ein Termin ausgemacht werden. Dies geht am einfachsten via Email. Unklare Punkte sollten rechtzeitig per Email vor der Besprechung angekündigt werden, um dem Betreuer eine Einarbeitung zu ermöglichen. Die Besprechung des Konzepts ist auch dann zu empfehlen, wenn es eigentlich keine ” Fragen“ gibt, denn bei einer solchen Besprechung kann frühzeitig die Arbeit in die richtige Richtung gelenkt werden oder es können Missverständnisse aus dem Weg geräumt werden. 6. Anfertigung der Ausarbeitung Die Ausarbeitung soll eine in eigenen Worten verfasste Darstellung des Themas sein. Insbesondere sollte sie nicht aus einer bloßen Übersetzung eines englischen Orginaltexts bestehen. Der Umfang der Ausarbeitung sollte für PR-BS ca. 10 Seiten, für FP-S ca. 15 Seiten betragen. 7. Abgabe der Ausarbeitung Eine Vorversion der Ausarbeitung sollte 2 Wochen vor dem Vortrag abgegeben werden. 2 Wochen nach dem Vortrag muss die endgültige Ausarbeitung bei der Professur angekommen sein. Sie sollte sowohl in gedruckter Form als auch in elektronischer Version (PDF) abgegeben werden. Anschließend wird sie begutachtet und es werden eventuell Vorschläge zur Nachbesserung gegeben. Die Nachbesserung sollte normalerweise bis zum Vortrag, in Ausnahmefällen bis zwei Wochen nach dem Vortrag, vorgenommen werden. Die Ausarbeitung soll u.U. auf der WWW-Seite der Professur für andere Teilnehmer des Seminars verfügbar gemacht werden. Falls Sie dies nicht wünschen, so teilen Sie uns das bitte mit Ihrer Abgabe mit. 3 8. Präsentation / Vortrag Ziel des Vortrages ist zum einen die Vermittlung des Stoffes an die Teilnehmer, zum anderen dient der Vortrag zum Üben einer Präsentation. Hierbei sollte beachtet werden: Publikum Berücksichtigen Sie, an wen sich Ihr Vortrag richtet. Dies sind im wesentlichen die übrigen Seminarteilnehmer aber auch der Dozent und die Mitarbeiter. Zeitbeschränkung Es ist eine Vortragszeit von 60 Minuten vorgesehen. Diese Begrenzung ist großzügig bemessen, bei wissenschaftlichen Konferenzen haben Sie noch wesentlich weniger Zeit, oft nur 10 - 30 Minuten. Die Zeitbeschränkung lässt es oft nicht zu, das gesamte Thema in allen Einzelheiten zu präsentieren, Sie sollten evtl. Teilthemen weglassen, oder unwichtigere Aspekte derart platzieren, so dass Sie sie nur dann vortragen, wenn noch entsprechend Zeit zur Verfügung steht. Bei der Auswahl des Stoffes sollten die folgenden Fragestellungen berücksichtigt werden: • Was ist besonders wichtig und muss präsentiert werden? • Was ist eher uninteressant und kann bei der Präsentation weggelassen werden? • Was könnte präsentiert werden, falls noch genügend Zeit am Ende Präsentation vorhanden ist? Zusätzlich zur eigentlichen Vortragszeit sind 5 Minuten für Zwischenfragen und Diskussion eingeplant. Folien / Bildschirmpräsentation Die Präsentation kann mithilfe einer Bildschirmpräsentation mit Laptop und Beamer erfolgen. Hierbei sollte die Information pro Folie wohldosiert sein: Statt langer Texte sollten die wichtigsten Fakten stichpunktartig auf den Folien festgehalten werden. Die Folien sollten lesbar sein (enstprechend große Schriftgröße wählen). Die Anzahl der Folien kann je nach Inhalt der Folien variieren, als Maßstab sind ca. 15-20 Folien einzuplanen. Animationen innerhalb der Präsentation sollten Sie weitestgehend vermeiden, und wenn, dann nur sinnvoll einsetzen. Für die Bildschirmdarstellung von Präsentationen sei PDF angeraten, da diese auf jedem Rechner anzeigbar sind. Insbesondere sei zu beachten, dass das Professur-Notebook kein PowerPoint unterstützt. Beim Einsatz von LATEX bietet sich hierfür besonders das Paket “Beamer” http://latexbeamer.sourceforge.net/ an. Es wird empfohlen die Vortragsfolien 1-2 Tage vor dem Vortrag bereits an den Betreuer zu schicken, damit getestet werden kann, ob die Präsentation auf den Systemen der Professur lauffähig ist. Zur Vorbereitung auf den Vortrag wird empfohlen, den Vortrag probeweise vor einem Kommilitonen o.ä. zu halten, insbesondere um zu sehen, ob 4 • der Vortrag zu lang / kurz ist. • der Vortrag verständlich ist. • der Vortrag spannend oder eher ermüdend ist. 9. Teilnahme Von den Teilnehmern wird erwartet, dass Sie bei allen Vorträgen des Seminars anwesend sind, und aktiv am Seminar teilnehmen, indem Sie sich an der Diskussion beteiligen. 3 3.1 Themen Language and program design for functional dependencies Abstract Eight years ago, functional dependencies, a concept from the theory of relational databases, were proposed as a mechanism for avoiding common problems with multiple parameter type classes in Haskell. In this context, functional dependencies give programmers a means to specify the semantics of a type class more precisely, and to obtain more accurate inferred types as a result. As time passed, however, several issues were uncovered - both in the design of a language to support functional dependencies, and in the ways that programmers use them - that led some to search for new, better alternatives. This paper focusses on two related aspects of design for functional dependencies: (i) the design of language/type system extensions that implement them; and (ii) the design of programs that use them. Our goal is to clarify the issues of what functional dependencies are, how they should be used, and how the problems encountered with initial proposals and implementations can be addressed. Literatur Jones, Mark P. und Iavor S. Diatchki: Language and program design for functional dependencies. In: Haskell ’08: Proceedings of the first ACM SIGPLAN symposium on Haskell, Seiten 87–98, New York, NY, USA, 2008. ACM. Aus dem Netz der RBI kostenlos abrufbar über http://doi.acm.org/10.1145/1411286.1411298. 5 3.2 Lazy evaluation and delimited control Abstract The call-by-need lambda calculus provides an equational framework for reasoning syntactically about lazy evaluation. This paper examines its operational characteristics. By a series of reasoning steps, we systematically unpack the standard-order reduction relation of the calculus and discover a novel abstract machine definition which, like the calculus, goes “under lambdas”. We prove that machine evaluation is equivalent to standard-order evaluation. Unlike traditional abstract machines, delimited control plays a significant role in the machine’s behavior. In particular, the machine replaces the manipulation of a heap using store-based effects with disciplined management of the evaluation stack using control-based effects. In short, state is replaced with control. To further articulate this observation, we present a simulation of call-by-need in a call-by-value language using delimited control operations. Literatur Garcia, Ronald, Andrew Lumsdaine und Amr Sabry: Lazy evaluation and delimited control. In: POPL ’09: Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages, Seiten 153–164, New York, NY, USA, 2009. ACM. Aus dem Netz der RBI kostenlos abrufbar über http://doi.acm.org/10.1145/1480881.1480903. 6 3.3 HMF: Simple type inference for first-class polymorphism Abstract HMF is a conservative extension of Hindley-Milner type inference with firstclass polymorphism. In contrast to other proposals, HML uses regular System F types and has a simple type inference algorithm that is just a small extension of the usual Damas-Milner algorithm W. Given the relative simplicity and expressive power, we feel that HMF can be an attractive type system in practice. There is a reference implementation of the type system available online together with a technical report containing proofs (Leijen 2007a,b). Literatur Leijen, Daan: HMF: simple type inference for first-class polymorphism. In: ICFP ’08: Proceeding of the 13th ACM SIGPLAN international conference on Functional programming, Seiten 283–294, New York, NY, USA, 2008. ACM. Aus dem Netz der RBI kostenlos abrufbar über http://doi.acm.org/10.1145/1411204.1411245. 7 3.4 A compositional theory for STM Haskell Abstract We address the problem of reasoning about Haskell programs that use Software Transactional Memory (STM). As a motivating example, we consider Haskell code for a concurrent non-deterministic tree rewriting algorithm implementing the operational semantics of the ambient calculus. The core of our theory is a uniform model, in the spirit of process calculi, of the run-time state of multithreaded STM Haskell programs. The model was designed to simplify both local and compositional reasoning about STM programs. A single reduction relation captures both pure functional computations and also effectful computations in the STM and I/O monads. We state and prove liveness, soundness, completeness, safety, and termination properties relating source processes and their Haskell implementation. Our proof exploits various ideas from concurrency theory, such as the bisimulation technique, but in the setting of a widely used programming language rather than an abstract process calculus. Additionally, we develop an equational theory for reasoning about STM Haskell programs, and establish for the first time equations conjectured by the designers of STM Haskell. We conclude that using a pure functional language extended with STM facilitates reasoning about concurrent implementation code. Literatur Borgström, Johannes, Karthikeyan Bhargavan und Andrew D. Gordon: A compositional theory for STM Haskell. In: Haskell ’09: Proceedings of the 2nd ACM SIGPLAN symposium on Haskell, Seiten 69–80, New York, NY, USA, 2009. ACM. Aus dem Netz der RBI kostenlos abrufbar über http://doi.acm.org/10.1145/1596638.1596648. 8 3.5 Typed closure conversion preserves observational equivalence Abstract Language-based security relies on the assumption that all potential attacks are bound by the rules of the language in question. When programs are compiled into a different language, this is true only if the translation process preserves observational equivalence. We investigate the problem of fully abstract compilation, i.e., compilation that both preserves and reflects observational equivalence. In particular, we prove that typed closure conversion for the polymorphic À-calculus with existential and recursive types is fully abstract. Our proof uses operational techniques in the form of a step-indexed logical relation and construction of certain wrapper terms that “back-translate” from target values to source values. Although typed closure conversion has been assumed to be fully abstract, we are not aware of any previous result that actually proves this. Literatur Ahmed, Amal und Matthias Blume: Typed closure conversion preserves observational equivalence. In: ICFP ’08: Proceeding of the 13th ACM SIGPLAN international conference on Functional programming, Seiten 157–168, New York, NY, USA, 2008. ACM. Aus dem Netz der RBI kostenlos abrufbar über http://doi.acm.org/10.1145/1411204.1411227. 9 3.6 Small-step and big-step semantics for call-by-need Abstract We present natural semantics for acyclic as well as cyclic call-by-need lambda calculi, which are proved equivalent to the reduction semantics given by Ariola and Felleisen. The natural semantics are big-step and use global heaps, where evaluation is suspended and memorized. The reduction semantics are small-step and evaluation is suspended and memorized locally in let-bindings. Thus two styles of formalization describe the call-by-need strategy from different angles. The natural semantics for the acyclic calculus is revised from the previous presentation by Maraist et al. and its adequacy is ascribed to its correspondence with the reduction semantics, which has been proved equivalent to call-by-name by Ariola and Felleisen. The natural semantics for the cyclic calculus is inspired by that of Launchbury and Sestoft and we state its adequacy using a denotational semantics in the style of Launchbury; adequacy of the reduction semantics for the cyclic calculus is in turn ascribed to its correspondence with the natural semantics. Literatur Nakata, Keiko und Masahito Hasegawa: Small-step and big-step semantics for call-by-need. J. Funct. Program., 19(6):699–722, 2009. Preprint kostenlos verfügbar über http://arxiv.org/abs/0907.4640. 10 3.7 Making “Stricterness” More Relevant Abstract Adapting a strictness analyser to have it take into account explicit strictness annotations can be a tricky business. Straightforward extensions of analyses based on relevance typing are likely to either be unsafe or fail to pick the fruits of increases in strictness that are introduced through annotations. We propose a more involved adaptation of relevance typing, that can be used to derive strictness analyses that are both safe and effective in the presence of explicit strictness annotations. The resulting type system provides a firm foundation for implementations of type-based strictness analysers in compilers for lazy programming languages such as Haskell and Clean. Literatur Holdermans, Stefan und Jurriaan Hage: Making “Stricterness” More Relevant. To appear in ACM SIGPLAN 2010 Workshop on Partial Evaluation and Program Manipulation 2010, 2010. Online verfügbar über http://people.cs.uu.nl/stefan/pubs/holdermans10making.html. 11 3.8 Purely functional lazy non-deterministic programming Abstract Functional logic programming and probabilistic programming have demonstrated the broad benefits of combining laziness (non-strict evaluation with sharing of the results) with non-determinism. Yet these benefits are seldom enjoyed in functional programming, because the existing features for non-strictness, sharing, and non-determinism in functional languages are tricky to combine. We present a practical way to write purely functional lazy non-deterministic programs that are efficient and perspicuous. We achieve this goal by embedding the programs into existing languages (such as Haskell, SML, and OCaml) with high-quality implementations, by making choices lazily and representing data with non-deterministic components, by working with custom monadic data types and search strategies, and by providing equational laws for the programmer to reason about their code. Literatur Fischer, Sebastian, Oleg Kiselyov und Chung-chieh Shan: Purely functional lazy non-deterministic programming. In: ICFP ’09: Proceedings of the 14th ACM SIGPLAN international conference on Functional programming, Seiten 11–22, New York, NY, USA, 2009. ACM. Aus dem Netz der RBI kostenlos abrufbar über http://doi.acm.org/10.1145/1596550.1596556. 12 3.9 Static contract checking for Haskell Abstract Program errors are hard to detect and are costly both to programmers who spend significant efforts in debugging, and for systems that are guarded by runtime checks. Static verification techniques have been applied to imperative and object-oriented languages, like Java and C#, but few have been applied to a higher-order lazy functional language, like Haskell. In this paper, we describe a sound and automatic static verification framework for Haskell, that is based on contracts and symbolic execution. Our approach is modular and gives precise blame assignments at compile-time in the presence of higher-order functions and laziness. Literatur Xu, Dana N., Simon Peyton Jones und Koen Claessen: Static contract checking for Haskell. In: POPL ’09: Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages, Seiten 41–52, New York, NY, USA, 2009. ACM. Aus dem Netz der RBI kostenlos abrufbar über http://doi.acm.org/10.1145/1480881.1480889. 13 3.10 Branching vs. Linear Time: Semantical Perspective Abstract The discussion in the computer-science literature of the relative merits of linear- versus branching-time frameworks goes back to early 1980s. One of the beliefs dominating this discussion has been that the linear-time framework is not expressive enough semantically, making linear-time logics lacking in expressiveness. In this work we examine the branching-linear issue from the perspective of process equivalence, which is one of the most fundamental notions in concurrency theory, as defining a notion of process equivalence essentially amounts to defining semantics for processes. Over the last three decades numerous notions of process equivalence have been proposed. Researchers in this area do not anymore try to identify the “right” notion of equivalence. Rather, focus has shifted to providing taxonomic frameworks, such as “the linear-branching spectrum”, for the many proposed notions and trying to determine suitability for different applications. We revisit this issue here from a fresh perspective. We postulate three principles that we view as fundamental to any discussion of process equivalence. First, we borrow from research in denotational semantics and take contextual equivalence as the primary notion of equivalence. This eliminates many testing scenarios as either too strong or too weak. Second, we require the description of a process to fully specify all relevant behavioral aspects of the process. Finally, we require observable process behavior to be reflected in its input/output behavior. Under these postulates the distinctions between the linear and branching semantics tend to evaporate. As an example, we apply these principles to the framework of transducers, a classical notion of statebased processes that dates back to the 1950s and is well suited to hardware modeling. We show that our postulates result in a unique notion of process equivalence, which is trace based, rather than tree based Literatur Nain, Sumit und Moshe Y. Vardi: Branching vs. Linear Time: Semantical Perspective. In: Namjoshi, Kedar S., Tomohiro Yoneda, Teruo Higashino und Yoshio Okamura (Herausgeber): ATVA, Band 4762 der Reihe Lecture Notes in Computer Science, Seiten 19–34. Springer, 2007. Verfügbar über http://www.cs.rice.edu/∼vardi/papers/atva0712.pdf. 14
