Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Telecooperation/RBG Technische Universität Darmstadt Copyrighted material; for TUD student use only Grundlagen der Informatik I Thema 5: Abstraktion von.

Ähnliche Präsentationen


Präsentation zum Thema: "Telecooperation/RBG Technische Universität Darmstadt Copyrighted material; for TUD student use only Grundlagen der Informatik I Thema 5: Abstraktion von."—  Präsentation transkript:

1 Telecooperation/RBG Technische Universität Darmstadt Copyrighted material; for TUD student use only Grundlagen der Informatik I Thema 5: Abstraktion von Design Prof. Dr. Max Mühlhäuser Dr. Guido Rößling 1

2 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Überblick Ähnlichkeiten in Definitionen Funktionen sind Werte Abstraktionen aus Beispielen entwerfen Abstraktionen mit Funktionen als Werten entwerfen Funktionen ad hoc definieren pipes-and-filters Organisation von Berechnungen 2

3 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Ähnlichkeiten in Definitionen Viele Daten- und Funktionsdefinitionen sehen ähnlich aus: –Daten: Symbolliste, Zahlenliste, … –Funktionen: Suche nach speziellem Symbol in einer Symbolliste Suche nach spezieller Zahl in einer Zahlenliste … Wiederholungen sind die Quelle vieler Programmfehler –Der wichtigste Schritt beim Schreiben eines Programms ist Wiederholungen zu eliminieren. Dieser Teil der Vorlesung behandelt folgende Punkte: –Ähnlichkeiten in Daten- und Funktionsdefinitionen –Designrezepte, um abstrakte Funktion zu entwerfen und Wiederholungen zu vermeiden –Die Rolle von Prozeduren höherer Ordnung in diesem Prozess 3

4 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Ähnlichkeiten in Funktionen Die Benutzung derzeitiger Designrezepte leiten die Schablone einer Funktion (die grundlegende Organisation) aus der Datendefinition der Eingabe ab. –Eine Schablone ist eine Methode, um auszudrücken, was wir über die Eingangsdaten wissen. Konsequenz: Funktionen, die die gleiche Art Daten verarbeiten, ähneln sich 4 Wenn Deine Datenstruktur richtig ist, schreibt sich der Rest des Programms von selbst. David Jones

5 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Zwei ähnliche Funktionen 5 ;; contains-doll? : los -> boolean ;; to determine whether alos contains ;; the symbol 'doll (define ( contains-doll? alos) (cond [(empty? alos) false] [else (cond [(symbol=? (first alos) 'doll) true] [else ( contains-doll? (rest alos ))])]))

6 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Zwei ähnliche Funktionen 6 ;; contains-car? : los -> boolean ;; to determine whether alos contains ;; the symbol 'car (define ( contains-car? alos) (cond [(empty? alos) false] [else (cond [(symbol=? (first alos) 'car ) true] [else ( contains-car? (rest alos))])]))

7 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Eine abstraktere Funktion Diese abstraktere Funktion konsumiert einen zusätzlichen Parameter: das Symbol, nach dem wir suchen –Ansonsten gleicht sie den beiden Originalfunktionen 7 ;; contains? : symbol los -> boolean ;; to determine whether alos contains the symbol s (define (contains? s alos) (cond [(empty? alos) false] [else (cond [(symbol=? (first alos) s) true] [else (contains? s (rest alos))])]))

8 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionale Abstraktion Abstrakte Versionen von Funktionen zu definieren ist sehr nützlich: –Eine einzige Funktion kann viele verschiedene Aufgaben erfüllen: contains? kann nach vielen verschiedenen Symbolen suchen, anstatt nur nach einem bestimmten –Eine einzige Funktion kann mehrere ähnliche Probleme auf einmal lösen Den Prozess, zwei ähnliche Funktionen zu einer Definition zusammenzuführen, nennt man funktionale Abstraktion 8

9 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Zwei weitere ähnliche Funktionen 9 ;; less-than: lon number -> lon ;; to construct a list of those numbers ;; in alon that are less than t (define (less-than alon t) (cond [(empty? alon) empty] [else (cond [(< (first alon) t) (cons (first alon) (less-than (rest alon) t))] [else (less-than (rest alon) t)])])) less-than

10 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Zwei weitere ähnliche Funktionen 10 ;; greater-than: lon number -> lon ;; to construct a list of those numbers ;; in alon that are greater than t (define (greater-than alon t) (cond [(empty? alon) empty] [else (cond [(> (first alon) t) (cons (first alon) (greater-than (rest alon) t))] [else (greater-than (rest alon) t)])])) greater-than

11 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Abstraktion der zwei Funktionen Der zusätzliche Parameter rel-op von filter1 steht für den konkreten relationalen Operator in less-than und greater-than : 11 (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))

12 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Originalfunktionen aus der Abstraktion Für filter1 müssen wir 3 Argumente bereitstellen: –Einen relationalen Operator R, der zwei Zahlen vergleicht –Eine Liste L aus Zahlen, und eine Zahl N Die Funktion liefert alle Werte i aus L, für die (R i N) zu true auswertet. 12 ;; less-than: lon number -> lon (define (less-than1 alon t) (filter1 < alon t)) ;; greater-than1: lon number -> lon (define (greater-than 1alon t) (filter1 > alon t)) Wir können nun less-than und greater-than als Einzeiler mit Hilfe von filter1 erhalten –Bei gleicher Eingabe ergeben less-than1 bzw. greater- than 1 das gleiche wie less-than bzw. greater-than

13 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Wiederverwendung abstrakter Funktionen Wir können eine abstrakte Funktion auch anders benutzen –Das erste Argument von filter1 kann irgendeine Funktion sein, die zwei Zahlen erhält und einen boolean Wert ausgibt Beispiele: –(filter1 = alon t) : wählt alle Zahlen n aus alon, für die gilt: n = t –(filter1 <= alon t) : Erzeugt eine Liste von Zahlen n aus alon, für die gilt: n <= t. –(filter1 >= alon t) : Erzeugt die Liste von Zahlen >= t. –Wählt die Zahlen aus ( ), deren Quadrat größer 10 ist. 13 ;; squared>? : number number -> boolean (define (squared>? x c) (> (* x x) c)) (filter1 squared>? (list ) 10)

14 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Ähnlichkeiten bei der Datendefinition Bei ähnlicher Datendefinition sind auch Funktionen ähnlich, die die Elemente dieser Klasse verarbeiten. 14 Eine list-of-numbers ist entweder empty oder (cons n l) n ist eine Zahl l ist eine list-of-numbers Eine list-of-IRs ist entweder empty oder (cons n l) n ist ein IR l ist eine list-of-IRs (define-struct ir (name price)) Ein IR – Inventory Record - ist eine Struktur: (make-ir n p) wobei n ein Symbol und p eine Zahl ist.

15 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Ähnlichkeiten bei der Datendefinition 15 ;; less-than: number lon -> lon ;; to construct a list of those numbers ;; on alon that are less than t (define (less-than alon t) (cond [(empty? alon) empty] [else (cond [(< (first alon) t) (cons (first alon) (less-than (rest alon) t))] [else (less-than (rest alon) t)])]))

16 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Ähnlichkeiten bei der Datendefinition 16 ;; boolean (define (< ir ir p) (< (ir-price ir) p)) ;; less-than-ir : number loIR -> loIR ;; to construct a list of those records ;; on aloir that contain a price less than t (define (less-than-ir aloir t) (cond [(empty? aloir) empty] [else (cond [(< ir (first aloir) t) (cons (first aloir) (less-than-ir (rest aloir) t))] [else (less-than-ir (rest aloir) t)])]))

17 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Polymorphe Funktionen Beim Abstrahieren der zwei Funktionen erhalten wir filter1 Wir können less-than-ir mit filter1 definieren: 17 (define (less-than-ir1 aloir t)(filter1

18 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Polymorphe Funktionen 18 ;; find : loIR symbol -> boolean ;; determines whether aloir contains a record for t (define (find aloir name) (cons? (filter1 eq-ir? aloir name))) ;; eq-ir? : IR symbol -> boolean ;; to compare ir's name and p (define (eq-ir? ir p) (symbol=? (ir-name ir) p)) filter1 arbeitet einheitlich mit vielen Arten von Eingabedaten: –filter1, angewandt auf eine Liste von X, hat als Ergebnis auch eine Liste von X – egal aus welcher Art von Daten X besteht Polymorphe oder generische Funktionen

19 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Parametrische Datendefinitionen Frage: Wie schreiben wir präzise Verträge für polymorphe Funktionen wie filter1 ? Antwort: Benutze Datendefinitionen mit Parametern, auch parametrische Datendefinitionen genannt –Sie spezifizieren nicht alles über eine Datenklasse –Sie benutzen Variablen, um anzudeuten, dass alle Scheme- Daten an einer bestimmten Stelle benutzt werden können 19 Steht für eine beliebige Sammlung von Scheme Daten: Symbole, IRs, etc. Wird ITEM durch einen dieser Namen ersetzt, erhalten wir eine konkrete Instanz dieser abstrakten Datendefinition: –Listen von Symbolen, Listen von IRs, etc. Eine Liste von ITEM ist entweder empty oder (cons s l) s ist ein ITEM l ist eine Liste von ITEM TYP VARIABLE

20 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Verträge für Polymorphe Funktionen Beim Definieren von Verträgen besagt die Abkürzung (listof X), dass eine Funktion auf allen Listen funktioniert 20 ;; length : (listof X) -> number ;; to compute the length of a list (define (length alox) (cond [(empty? alox) 0] [else (+ (length (rest alox)) 1)])) X ist nur eine Variable ein Name, der für eine Datenklasse steht Wenn wir length auf ein Element der Klassen (listof symbol) oder (listof IR) anwenden, erhalten wir eine Zahl

21 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Überblick Ähnlichkeiten in Definitionen Funktionen sind Werte Abstraktionen aus Beispielen entwerfen Abstraktionen mit Funktionen als Werten entwerfen Funktionen ad hoc definieren pipes-and-filters Organisation von Berechnungen 21

22 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Der Wert von Prozeduren Wir haben bereits die Vorteile der Prozeduren diskutiert: –Isolierte Implementierung eines Konzepts: Separation of Concerns statt Wiederholung von Code –Wiederverwendung von Code –Änderungen an nur einer Stelle, etc. –Ermöglicht Rekursion –Einheit für Information Hiding Die Prozeduren, die wir bisher verwendet haben, werden Prozeduren erster Ordnung (engl. first order procedures) genannt In dieser Vorlesung haben wir eine neue Art von Prozeduren verwendet: Prozeduren höherer Ordnung –Prozeduren, die andere Prozeduren als Parameter konsumieren oder als Ergebnisse zurückliefern 22

23 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Prozeduren als generelle Methoden Prozeduren erster Ordnung: Machen Berechnungen unabhängig von den Werten bestimmter Daten (Zahlen/Symbole) usw. Prozeduren höherer Ordnung: Drücken allgemeine Berechnungsmethoden unabhängig von den jeweiligen beteiligten Funktionen aus Werfen wir einen systematischen Blick auf Prozeduren höherer Ordnung –Wir müssen zunächst die Definition vom Scheme anpassen Funktionen höherer Ordnung verletzen die bisherige Definition Wählen sie von nun an in DrScheme das Intermediate Student with Lambda Sprachlevel –Dann diskutieren wir weiter das Thema Verträge für polymorphe Funktionen 23

24 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionen von Funktionen verletzten die Sprachdefinitionen auf zwei Arten 24 (define (find aloir t) (cons? (filter1 eq-ir? aloir t))) Verletzung 1: (filter1 < (cons 4 empty) 5) Funktionsnamen als Argumente in Anwendungen ==== x | alon |... area-of-disk | perimeter |... = | | (... ) | (cond ( )...( )) | (cond ( )...(else )) |... Grund: Ein Argument ist ein Ausdruck und die Klasse der Ausdrücke enthält keine Funktionsnamen

25 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionen von Funktionen verletzen grundlegende Sprachdefinitionen Verletzung 2: 25 Parameter werden an der ersten Stelle von Anwendungen benutzt (als wären sie Funktionen) Grund: Unsere Grammatik erlaubt nur Namen von Funktionen und primitiven Operationen an dieser Stelle, jedoch keine Parameter (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))

26 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 = | | | | (... ) Scheme anpassen 1.Die Namen von Funktionen und primitiven Operationen in die Definition von aufnehmen 2.An der ersten Position in einer Anwendung sollten nicht nur Funktionsnamen und primitive Operationen erlaubt werden: –Variablen, die Funktionsparametern entsprechen –Allgemeiner noch: Irgendein Ausdruck 26

27 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Scheme anpassen Die Anpassung der Grammatik, um Prozeduren höhere Ordnung zu unterstützen, verlängert die Grammatik nicht, sondern macht sie einfacher! 27 = | | | | (... ) = | | (... )

28 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Scheme anpassen Auswertungsregeln ändern sich nicht Was sich ändert, ist die Menge von Werten: sie enthält die Namen von Funktionen und primitiven Operationen 28 = | | | empty | | (names of defined functions) | | =empty | (cons ) =

29 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Intermediate Student Scheme Grammatik 29 =(define (... ) ) | (define ) | (define-struct (... )) = | | | | | | | (... ) | (cond ( )...( )) | (cond ( )...(else )) | (local (... ) ) ==== x | alon |... area-of-disk | circumference |... = true | false = 'a | 'doll | 'sum |... = 1 | -1 | 3/5 | 1.22 |... = + | - | cons | first | rest |... = empty | (cons )

30 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Verträge für abstrakte und polymorphe Funktionen Wo liegt das Problem? –Unsere neuen Funktionen akzeptieren einen Typ von Werten, den wir vorher nie als Daten verwendet haben: Primitive Operationen und andere Funktionen –Um Verträge für Funktionen höherer Ordnung schreiben zu können, benötigen wir eine Methode, um die neue Klasse von Werten beschreiben zu können Daher haben wir das Schreiben von Verträgen für die Funktionen bisher aufgeschoben –Dieses Thema werden wir auf den folgenden Folien behandeln 30

31 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Verträge für abstrakte und polymorphe Funktionen Wir haben Verträge für Prozeduren erster Ordnung 31 ;; rel-op : number number -> boolean Wir sagen beschreibt eine Klasse von Werten: die Klasse der Funktionen –Namen links von legen fest, worauf jeder Element in der Klasse der Funktionen angewendet werden darf –Der Name auf der rechten Seite von bestimmt, was jeder Wert der Klasse produzieren wird, wenn er auf die passenden Werte angewendet wird Allgemein: (A B C) kennzeichnet die Klasse aller Funktionen, die ein Element aus A und eines aus B konsumieren und ein Element in C produzieren. –Sie sind Funktionen von A und B nach C

32 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Beispiel: Vertragsdefinitionen Erste Version von filter1 32 ;; filter1 : (number number -> boolean) lon number -> lon ;; to construct the list of those numbers n on alon for which ;; (rel-op n t) evaluates to true (define (filter1 rel-op alon t)...) Abstraktere Version von filter1 filter1 : (X number -> boolean) (listof X) number -> (listof X) X steht für eine beliebige Klasse von Scheme Daten. Wir können X mit irgendetwas ersetzen, so lange alle drei Vorkommen durch dasselbe ersetzt werden

33 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionen von Funktionen anwenden Ist diese Anwendung sinnvoll? 33 filter1 : (X number -> boolean) (listof X) number -> (listof X) (number number -> boolean) listof number (filter1 < (list ) 2 ) Die zwei Klassen sind identisch zu den ersten beiden Argumentteilen des Vertrags von filter1, wenn X durch number ersetzt wird. Allgemein: Um sicher zu stellen, dass Argumente sinnvoll sind, müssen wir Ersetzungen für die Variablen in Verträgen finden, so dass der Vertrag und die Klassen der Argumente zusammen passen.

34 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Eine neue Anwendung für filter1 filter1 benutzen, um alle Spielzeuge mit gleichem Namen aus einer Liste von Inventareinträgen (inventory records) zu extrahieren: 34 ;; find : (listof IR) symbol -> (listof IR) (define (find aloir t) (filter1 eq-ir? aloir t)) ;; eq-ir? : IR symbol -> boolean (define (eq-ir? ir s) (symbol=? (ir-name ir) s)) Problem: Schwellen-Argument s ist ein symbol, nicht eine number Konflikt mit dem momentanen Vertrag von filter1 Um das Problem zu lösen, führen wir eine neue Variable ein, TH für Schwellen (thresholds), welche für irgendeine Datenklasse steht: filter1 : (X TH -> boolean) (listof X) TH -> (listof X)

35 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Zusammenfassung: Verträge und Typen Funktionsverträge bestehen aus Typen: –Basistyp, z.B. number, symbol, boolean, empty –Definierter Typ, z.B. inventory-record, list-of- numbers, family-tree –Funktionstyp, z.B. (number -> number) –Parametrischer Typ, entweder ein definierter Typ oder ein Funktionstyp mit Typvariablen Um eine Funktion mit einem parametrischen Typ zu benutzen: –Finde Ersetzung für Variablen im Funktionsvertrag mit Typen, welche den Klassen der aktuellen Argumente entsprechen –Ist das nicht möglich, revidiere den Vertrag, oder stelle die Entscheidung in Frage, die Funktion wieder zu verwenden 35

36 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Kurzdarstellung Ähnlichkeiten in Definitionen Funktionen sind Werte Abstraktionen aus Beispielen entwerfen Abstraktionen mit Funktionen als Werten entwerfen Funktionen ad hoc definieren pipes-and-filters Organisation von Berechnungen 36

37 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Rezept für das Abstrahieren von Beispielen Wir haben bereits Designs abstrahiert, z.B. aufgrund zweier konkreter Funktionsdefinitionen: –vergleiche sie, –kennzeichne die Unterschiede, –abstrahiere. Jetzt formulieren wir diese Schritte als Rezept: 1.Vergleiche die Beispiele und rahme Unterschiede ein 2.Abstrahiere, falls die Rahmen Werte enthalten 3.Teste die Gültigkeit der Abstraktion 4.Formuliere den Vertrag der Abstraktion 37

38 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 ;; convertCF : lon -> lon (define (convertCF alon) (cond [(empty? alon) empty] [else (cons (C->F (first alon)) (convertCF (rest alon))] )) ;; names : loIR -> los (define (names aloIR) (cond [(empty? aloIR) empty] [else (cons (IR-name (first aloIR)) (names (rest aloIR)))] )) Beispiele vergleichen 38 Wenn Sie zwei Funktionsdefinitionen finden, die beinahe gleich sind: Vergleiche sie und markieren die Unterschiede in Kästchen Wenn Kästchen Werte enthalten, können wir abstrahieren Jedes Kästchen enthält einen Funktionswert, also können wir abstrahieren...

39 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 (define (names f aloIR) (cond [(empty? aloIR) empty] [else (cons (f (first aloIR)) (names (rest aloIR)))] )) (define (convertCF f alon) (cond [(empty? alon) empty] [else (cons (f (first alon)) (convertCF (rest alon)))] )) Zwei Schritte der Abstraktion 1.Ersetze die Inhalte korrespondierender Kästchenpaare mit neuen Namen und füge diese Namen zur Parameterliste hinzu. –Es werden soviele Namen benötigt, wie es Kästchenpaare gibt 39

40 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Zwei Schritte der Abstraktion 2.Die zwei Definitionen müssen jetzt dieselben sein, bis auf die Funktionsnamen –Um die Abstraktion zu erhalten, ersetze die Funktionsnamen systematisch mit einem neuen Namen 40 (define (map f lon) (cond [(empty? lon) empty] [else (cons (f (first lon)) (map f (rest lon)))])) map stellt ein übliches Pattern für Operationen auf Listen dar es abstrahiert über die Operation, die auf die Listenelemente angewandt werden soll

41 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Die Abstraktion testen Ziel: Sicherstellen, dass die neue Funktion eine korrekte Abstraktion der Originalfunktionen ist. Vorgehen: –Definiere Originalfunktionen mittels Applikation der abstrakten Funktion –Teste die neuen Versionen mit den Beispielen, die beim Entwurf der Originalfunktionen formuliert wurden 41

42 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Die Originalfunktionen als Spezialisierung der Abstraktion definieren Annahmen: –Abstrakte Funktion heißt f-abstract –Eine Originalfunktion heißt f-original und erwartet ein Argument Wenn sich f-original von der anderen konkreten Funktion in der Verwendung eines Wertes unterscheidet, z.B. boxed-value, dann definieren wir die folgende Funktion: Für jeden zulässigen Wert V sollte folgendes gelten: 42 (define (f-from-abstract x) (f-abstract boxed-value x)) (f-from-abstract V) = (f-original V)

43 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Die Originalfunktionen als Spezialisierung der Abstraktion definieren Um sicher zu stellen, dass diese beiden Definitionen zu den alten äquivalent sind, d.h. dass map eine korrekte Abstraktion ist, wende diese beiden Funktionen auf Beispiele an, die für die Entwicklung von convertCF und names spezifiziert wurden 43 ;; convertCF-from-map : lon -> lon (define (convertCF-from-map alon) (map C->F alon)) ;; names-from-map : loIR -> los (define (names-from-map aloIR) (map IR-name aloIR))

44 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Den Vertrag formulieren Ziel: Einen Vertrag für die abstrakte Funktion formulieren Hinweis: –Normalerweise kann man den Vertrag für die abstrakte Funktion nicht formulieren, indem man sie als Abstraktion der einen oder anderen Originalfunktion betrachtet 44 Betrachten wir map als Abstraktion von names, so erhalten wir: (number -> number) (listof number) -> (listof number) Betrachten wir map als Abstraktion von convertCF, so erhalten wir: (IR -> symbol) (listof IR) -> (listof symbol) Der erste Vertrag wäre nutzlos im zweiten Fall und umgekehrt

45 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Allgemeine Verträge formulieren Durch Betrachten der Definition sehen wir: –map wendet sein erstes Argument – eine Funktion f – auf jedes Element des zweiten Arguments – eine Liste l – an Impliziert: –f muss die Daten verarbeiten, die l enthält –Daher hat f den Vertrag X -> ???, wenn l Werte der Klasse X enthält Wenn f Werte in Y produziert, dann produziert map eine Liste von Y s: 45 map : (X -> Y) (listof X) -> (listof Y)

46 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Neue Einsatzmöglichkeiten abstrakter Funktionen Eine abstrakte Funktion ist allgemein in einem breiteren Kontext nützlich, als zunächst angenommen: –So kann map jedesmal benutzt werden, wenn wir eine neue Liste durch Bearbeitung einer bestehenden Liste erzeugen möchten 46 ;; list-of-squares : (listof numbers) -> (listof numbers) ;; constructs the list of squares of the elements of alon (define (list-of-squares alon) (cond [(empty? alon) empty] [else (cons (sqr (first alon)) (list-of-squares (rest alon)))])) (define (list-of-squares list) (map sqr list)) (list-of-squares (list )) --> (list )

47 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Verträge und neue Einsatzmöglichkeiten abstrakter Funktionen Frage: Wie entdecken wir neue Einsatzmöglichkeiten abstrakter Funktionen? –Dafür gibt es kein Rezept –Es ist Übungssache, einen Blick dafür zu entwickeln, ob abstrakte Funktionen zu Situationen passen Die Formulierung des Vertrags ist wichtig, um die Nützlichkeit einer abstrakten Funktion zu erhöhen: –Formuliere Verträge, welche die Anwendbarkeit abstrakter Funktionen im allgemeinst möglichen Kontext beschreiben 47

48 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Allgemeine Verträge formulieren Das Abstrahieren von Verträgen folgt dem gleichen Rezept wie das Abstrahieren von Funktionen: –Vergleiche Verträge von Beispielen, die wir abstrahieren wollen –Ersetze spezifische Klassen an korrespondierenden Positionen, eine nach der anderen, um den Vertrag allgemeiner zu machen –Überprüfe, ob der Vertrag die spezifischen Instanzen der abstrahierten Funktion richtig beschreibt 48 (number -> number) (listof number) -> (listof number) (IR -> symbol) (listof IR) -> (listof symbol) (X -> Y) (listof X) -> (listof Y) XY

49 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 [Wir erinnern uns…] Prozeduren erster Ordnung: Machen Berechnungen unabhängig von den Werten bestimmter Daten (Zahlen/Symbole) usw. Prozeduren höherer Ordnung: Drücken allgemeine Berechnungsmethoden unabhängig von den jeweilig beteiligten Funktionen aus –Schauen wir uns an, was das bedeutet - am Beispiel von map … 49

50 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 map als Abstraktionsbarriere 50 (define (list-of-squares alon) (cond [(empty? alon) empty] [else (cons (sqr (first alon)) (list-of-squares (rest alon)))])) Diese obige Version von list-of-squares ist aus zwei Gründen nicht optimal: Sie hebt die Element-für-Element Verarbeitung der Listen hervor Verrät zu viele Details über die Implementierung der Listen, darüber wie Listenelemente extrahiert und kombiniert werden Die Operation, welche auf jedem Listenelement angewandt wird, ist fest verdrahtet

51 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 map als Abstraktionsbarriere 51 Die map -Version von list-of-squares unterdrückt dieses Detaillevel –Sie betont, dass Quadrieren eine Transformation einer Liste von Elementen in eine andere Liste ist –Höhere Abstraktion beim Umgang mit Listen Computer führt den gleichen Prozess aus Wir denken anders über den Prozess! (define (list-of-squares list) (map sqr list))

52 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionen höherer Ordnung als Abstraktionsbarrieren: Beispiel von map Eine Abstraktionsbarriere isoliert die Implementierung von Prozeduren, die Listen transformieren, von den Details, wie die Elemente der Liste extrahiert und kombiniert werden 52 Unwichtige Details, wie Sequenzen implementiert sind MAP Operation, die Sequenzen in Sequenzen umwandelt Man kann die Implementierung der Listen unabhängig von der Umwandlungsfunktion variieren

53 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Benutzung von map für Bäume map zusammen mit Rekursion ist eine mächtige Abstraktion, um baumartige Datenstrukturen zu bearbeiten 53 ;; scale-tree : (treeof numbers) number -> (treeof numbers) ;; constructs a new list by multiplying ;; each element of tree by num (define (scale-tree tree num) (map (local ((define (scale-st sub-tree) (cond [(cons? sub-tree) (scale-tree sub-tree num)] [else (* sub-tree num)]))) scale-st) tree) )

54 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Abstrahieren von Schablonen Beim Design von Funktionen orientieren wir uns an die Schablone der Datendefinition –Definitionen sehen ähnlich aus; wir abstrahieren sie –Wir könnten direkt von den Schablonen abstrahieren 54 (define (fun-for-l l) (cond [(empty? l)...] [else... (first l)... (fun-for-l (rest l))...])) Eine list-of-numbers ist: entweder empty oder (cons n l) wo n is a number l is a list-of-numbers Um eine konkrete Funktion f abzuleiten, füllen wir zwei Lücken: –Im ersten Fall setzen wir typischerweise einen konkreten Wert ein –Im zweiten Fall kombinieren wir (first l) mit (f (rest l))

55 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Abstrahieren von Schablonen 55 ;; fold : Y (X Y -> Y) (listof X) -> Y (define (fold init combine-op lst) (cond [(empty? lst) init] [else (combine-op (first lst) (fold init combine-op (rest lst)))])) ;; sum : (listof number) -> number (define (sum lst) (fold 0 + lst)) ;; product : (listof number) -> number (define (product lst) (fold 1 * lst)) fold stellt ein übliches Pattern für Operationen auf Listen dar Anwendung einer binären Operation auf dem ersten Element und auf dem Ergebnis der Anwendung von fold auf dem Rest der Liste

56 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 [Notiz: Zusammenfalten in Scheme] Zusammenfalten ist eine sehr häufige Operation über Listen, so dass es dafür zwei vordefinierte Funktion in Scheme gibt: –foldr faltet zusammen von rechts nach links –foldl faltet zusammen von links nach rechts 56 ;; foldr : (X Y -> Y) Y (listof X) -> Y ;; (foldr f base (list x-1... x-n)) = ;;(f x-1... (f x-n base)) (define (foldr f base alox)...) ;; foldl : (X Y -> Y) Y (listof X) -> Y ;; (foldl f base (list x-1... x-n)) = ;;(f x-n... (f x-1 base)) (define (foldl f base alox)...)

57 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 sort von fold ableiten 57 Können wir fold verwenden, um Listen zu sortieren? Erinnern wir uns an insertion sort …

58 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 [Erinnerung insert ] 58 el i, i = [1… j], el i <= n el j+1 el j+2... el n alon n n insert für den Fall, dass alon nicht leer ist: Überspringe alle Elemente in alon bis zu dem ersten Element von alon, e j+1, das größer ist als n. Füge n zwischen el j und el j+1 ein. ;; insert : number list-of-numbers -> list-of-numbers (define (insert n alon) (cond [(empty? alon) (cons n empty)] [(<= n (first alon)) (cons n alon)] [else (cons (first alon) (insert n (rest alon)))])) update: j-Indizes in der Animation leider falsch

59 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 [Erinnerung: insertion sort ] 59 ;; sort : list-of-numbers -> list-of-numbers ;; creates a sorted list of numb. from numbers in alon (define (sort alon) (cond [(empty? alon) empty] [else (insert (first alon) (sort (rest alon)))])) nn sortedunsorted

60 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 sort von fold ableiten 60 ;; sort : (listof number) -> (listof number) (define (sort lst) (local ((define (insert an alon)... ) (fold empty insert lst))) ;; fold : Y (X Y -> Y) (listof X) -> Y (define (fold init combine-op lst) (cond [(empty? lst) init] [else (combine-op (first lst) (fold init combine-op (rest lst)))])) init empty combine-op insert

61 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 work 61 (sort lst) = (fold empty insert (list 3 2 8)) = (insert 3 (fold empty insert (list (2 8)))) = (insert 3 (insert 2 (fold empty insert (list 8)))) = (insert 3 (insert 2 (insert 8 (fold empty insert ())))) = (insert 3 (insert 2 (insert 8 ()))) = (insert 3 (insert 2 (list 8))) = (insert 3 (list 2 8) = (2 3 8) 2 328

62 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Abstraktion und eindeutiger Kontrollpunkt? Eine Abstraktion vereinfacht oft andere Definitionen Der Prozess der Abstraktion kann Probleme mit existierenden Funktionen aufdecken Abstrahierte Funktionsdefinitionen sind flexibler und breiter einsetzbar als spezialisierte Definitionen Der Hauptvorteil von Abstraktion liegt jedoch darin, dass Sie einen eindeutigen Kontrollpunkt für die Funktionalität in einem Programm darstellt –Die Definitionen für eine bestimmte Aufgabe werden (so weit wie möglich) an einem Ort vereint –Separation of Concerns 62

63 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Warum Eindeutiger Kontrollpunkt? Wenn sich alle Definitionen für eine bestimmte Aufgabe sich an einer Stelle befinden, wird das Programm leichter zu warten Unter Wartung eines Programms verstehen wir: –Behebung von Fehlern, so dass es in vorher nicht getesteten Fällen funktioniert –Erweiterung des Programms, um mit neuen oder nicht vorgesehenen Situationen zurechtzukommen –Änderung der Darstellung von Informationen als Daten (z.B. Kalenderdaten) Einige Schätzungen gehen davon aus, dass die Wartung eines erfolgreichen Programms den Hauptteil seiner Lebensdauer ausmacht (60-80%) 63

64 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Warum eindeutiger Kontrollpunkt? Durch Änderung einer einzigen Definition können wir an vielen Stellen Fehler beheben und Verbesserungen erzielen –Ein ebenso wichtiger Vorteil von abstrahierten Definitionen Beispiel: Zwei Änderungen an filter1 auf den nächsten zwei Folien: –Die erste Änderung glättet den geschachtelten cond -Ausdruck –Die zweite Änderung verwendet einen local -Ausdruck, um den geschachtelten cond -Ausdruck lesbarer zu machen 64

65 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Warum eindeutiger Kontrollpunkt? 65 (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])])) (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)]))

66 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Warum eindeutiger Kontrollpunkt? 66 (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (local ((define first-item (first alon)) (define rest-filtered (filter1 rel-op (rest alon) t))) (cond [(rel-op first-item t) (cons first-item rest-filtered)] [else rest-filtered]))])) (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])]))

67 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Warum Eindeutiger Kontrollpunkt? Alle Verwendungen von filter1, inklusive derer, die zur Definition von less-than1 and greater-than1 benutzt werden, profitieren von den Änderungen Es würden alle Verwendungen der Funktion davon profitieren, wenn die Änderung einen logischen Fehler beheben würde Letztendlich ist sogar möglich, einer abstrahierten Funktion neue Aufgaben zuzuweisen, z.B. einen Mechanismus, der zählt, wie viele Elemente gefiltert werden –Alle Verwendungen der Funktion würden von der neuen Funktionalität profitieren 67

68 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Warum Eindeutiger Kontrollpunkt? Wenn alles an einer Stelle steht: –Verstehen, was zu reparieren, erweitern oder zu ändern ist, bedeutet, nur eine einzige Funktion zu verstehen –Einen Fehler zu beheben, bedeutet, ihn in einer Funktion zu beheben, nicht in mehreren ähnlichen Versionen –Die Fähigkeiten einer Funktion zu erweitern, bedeutet, nur eine Funktion zu ändern, und nicht ähnliche Kopien –Eine Datenrepräsentation zu ändern, bedeutet, eine allgemeine Daten-Traversierungs-Funktion zu ändern, und nicht all jene, die von der gleichen Schablone stammen 68 Richtlinie für die Erstellung von Abstraktionen: Erstelle eine Abstraktion, anstatt Teile des Programms zu kopieren und zu verändern

69 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Die Rolle von Abstraktion Die Erfahrung lehrt uns, dass die Wartung von Software teuer ist Programmierer können die Wartungskosten senken, indem sie Programme richtig organisieren Erstes Prinzip: Passe die Struktur der Funktion an die Struktur der Daten an. –Erleichtert Änderungen und Erweiterungen von Funktionen, wenn die Menge der möglichen Eingabedaten sich verändert Zweites Prinzip: Führe angemessene Abstraktionen ein –Jede abstrahierte Funktion erzeugt einen eindeutigen Kontrollpunkt für mindestens zwei verschiedene Funktionen, oft auch für mehr 69

70 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Die Rolle von Abstraktion Die besten Programmierer verändern ihre Programme, um neue Abstraktionen zu erzeugen Unser Designrezept zur Abstraktion von Funktionen ist das grundlegende Werkzeug dazu –Die Anwendung erfordert Übung. Während wir üben, erweitern wir unsere Fähigkeit, Abstraktionen zu erzeugen und zu nutzen Wir benutzen funktionale Abstraktion zum Erlernen dieser Konzepte –Nicht alle Sprachen geben uns die Freiheit, Funktionen so leicht zu abstrahieren wie in Scheme, jedoch verfügen moderne Sprachen oft über ähnliche Konzepte –Mit mächtigen Sprachen wie Scheme zu üben ist die beste Vorbereitung 70

71 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Überblick Ähnlichkeiten in Definitionen Funktionen sind Werte Abstraktionen aus Beispielen entwerfen Abstraktionen mit Funktionen als Werten entwerfen Funktionen ad hoc definieren pipes-and-filters Organisation von Berechnungen 71

72 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionen, die Funktionen erzeugen Ausdrücke können im neuen Scheme zu Funktionen ausgewertet werden Da der Rumpf einer Funktion auch ein Ausdruck ist, kann eine Funktion eine Funktion erzeugen Funktionen, die Funktionen erzeugen, sind besonders dann nützlich, wenn sich die erzeugte Funktion an die Argumente der erzeugenden Funktion zur Zeit der Anwendungerinnert 72 (define (f x) first) (define (g x) f) (define (h x) (cond [(empty? x) f] [(cons? x) g])) (define (add-10 x) (+ x 10)) (define (add-5 x) (+ x 5)) (define (h x) (cond [(< x 5) add-5] [else add-10])) (define addX (h 12)) (addX 7) -> 17

73 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionen mit Gedächtnis Interessante Eigenschaft von add : –Das Ergebnis erinnert sich an den Wert des Arguments x zum Applikationszeitpunkt –Jedes Mal, wenn wir das Ergebnis verwenden, benutzt es den Wert von x zur Zeit der Applikation 73 ;; add : number -> (number -> number) ;; to create a function that adds x to its input (define (add x) (local ((define (x-adder y) (+ x y))) x-adder)) Funktionen mit Gedächtnis entstehen durch die Kombination von local -Ausdrücken und Funktionen höherer Ordnung

74 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionen mit Gedächtnis 74 x (define f (add 5)) = (define f (local ((define (x-adder y) (+ 5 y))) x-adder)) = (define f (local ((define (x-adder5 y) (+ 5 y))) x-adder5)) = (define (x-adder5 y) (+ 5 y)) (define f x-adder5) (f 10) = (x-adder5 10) = (+ 5 10) = 15 add (add 5) (add 8)

75 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Funktionen mit Gedächtnis als Abstraktionsmittel Funktionen mit Gedächtnis können das Rezept zur Erstellung abstrakter Funktionen vereinfachen Bisheriges Rezept: –Vergleiche und rahme Unterschiede ein –Ersetze den Inhalt von Kästchen mit Variablen –Binde diese Variablen, indem sie zur Argumentliste hinzugefügt werden Alternatives Rezept: –Schließe die Definition in ein local ein, wobei der Inhalt der Kästchen mit freien Variablen ersetzt wird –Stelle dem local Block eine Funktion voran, welche die entstandenen freien Variablen bindet 75

76 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Abstrahieren mit Funktionen mit Gedächtnis 76 ;; less-than: lon number -> lon ;; to construct a list of those numbers ;; on alon that are less than t (define (less-than alon t) (cond [(empty? alon) empty] [else (cond [(< (first alon) t) (cons (first alon) (less-than(rest alon) t))] [else (less-than(rest alon) t)])]))

77 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 ;; greater-than: lon number -> lon ;; to construct a list of those numbers ;; on alon that are greater than t (define (greater-than alon t) (cond [(empty? alon) empty] [else (cond [(> (first alon) t) (cons (first alon) (greater-than (rest alon) t))] [else (greater-than (rest alon) t)])])) Abstrahieren mit Funktionen mit Gedächtnis 77

78 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 (define (filter2 rel-op) (local ( (define (abs-fun alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (abs-fun (rest alon) t))] [else (abs-fun (rest alon) t)])]))) abs-fun) ) Abstrahieren mit Funktionen mit Gedächtnis 78 Genau wie add erhält filter2 ein Argument, definiert eine Funktion und gibt sie als Ergebnis zurück. Das Ergebnis erinnert sich an rel-op, für immer.

79 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Alternatives Abstraktionsrezept Die Abstraktion: Stelle eine der Funktionen in eine local -expression und benutze den Namen der Funktion als Body von local: Erzeuge die abstrakte Funktion durch Auflistung der Namen in Kästchen als Parameter: Falls op1 oder op2 ein spezielles Symbol ist, z.B. <, benenne es mit etwas, das im neuen Kontext aussagekräftiger ist 79 (local ((define (concrete-fun x y z)... op1... op2...)) concrete-fun) (define (abs-fun op1 op2) (local ((define (concrete-fun x y z)... op1... op2...)) concrete-fun))

80 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Alternatives Abstraktionsrezept Der Test: Leite die konkreten Funktionen wie zuvor als Instanzen von filter2 ab. –Beispiel: less-than und greater-than als Instanz von filter2 : Der Vertrag: –Der Vertrag einer mit dem neuen Rezept erzeugten abstrakten Funktion enthält zwei Pfeile. Die Funktion erzeugt eine Funktion Um dies darzustellen, muss der Typ auf der rechten Seite des ersten Pfeils einen weiteren Pfeil enthalten. –Beispiel: Der Vertrag für filter2 : 80 (define less-than2 (filter2 <)) (define greater-than2 (filter2 >)) ;; filter2 : (X Y -> boolean) -> ((listof X) Y -> (listof X))

81 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Überblick Ähnlichkeiten in Definitionen Funktionen sind Werte Abstraktionen aus Beispielen entwerfen Abstraktionen mit Funktionen als Werten entwerfen Funktionen ad hoc definieren pipes-and-filters Organisation von Berechnungen 81

82 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Motivation für ad hoc Funktionsdefinitionen Die Applikation abstrakter Funktionen erfordert oft die Definition von Hilfsfunktionen –filter1 ist mit benutzbar 82 ;; find : (listof IR) symbol -> (listof IR) (define (find aloir t) (filter1 eq-ir? aloir t)) ;; eq-ir? : IR symbol -> boolean (define (eq-ir? ir s) (symbol=? (ir-name ir) s)) (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])])) Zur Erinnerung: die Definition von filter1

83 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Motivation für ad hoc Funktionsdefinitionen Falls Hilfsfunktionen nur als Argumente einer abstrakten Funktion f benutzt werden, verwenden wir local 83 ;; find : list-of-IRs symbol -> boolean (define (find aloir t) (local ((define (eq-ir? ir s) (symbol=? (ir-name ir) s))) (filter1 eq-ir? aloir t))) ;; find : list-of-IRs number -> boolean (define (find aloir t) (filter1 (local ((define (

84 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Motivation für ad hoc Funktionsdefinitionen Da gute Programmierer abstrakte Funktionen benutzen und ihre Programme ordentlich organisieren, gibt es in Scheme eine Abkürzung für diese spezielle, häufige Verwendung von local Diese Abkürzung wird lambda -Ausdruck genannt –Das erleichtert die spontane Einführung von Funktionen wie eq-ir? oder

85 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Syntax von lambda Ein lambda -Ausdruck ist ein neuer Typ von Ausdruck, gekennzeichnet durch das Schlüsselwort lambda Ein lambda -Ausdruck definiert eine anonyme Funktion –Die Sequenz von Variablen hinter dem Schlüsselwort lambda sind die Parameter der Funktion –Die dritte Komponente ist der Body der Funktion Beispiele 85 1.(lambda (x c) (> (* x x) c)) 2.(lambda (ir p) (< (ir-price ir) p)) 3.(lambda (ir s) (symbol=? (ir-name ir) s)) =(lambda (... ) ) (define (plus4 x) (+ x 4)) ist gleichbedeutend zu (define plus4 (lambda (x) (+ x 4)))

86 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 (local ((define (a-new-name x-1... x-n) exp)) a-new-name) Scope und Semantik von lambda (lambda (x-1... x-n) exp) führt x-1... x-n als gebundene Variablen ein, deren Scope exp ist. 86 (lambda (x-1... x-n) exp) a-new-name darf nicht in exp vorkommen

87 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 lambda statt local 87 ;; find : list-of-IRs number -> boolean (define (find aloir t) (filter1 (local ((define ( boolean (define (find aloir t) (filter1 (lambda (ir p) (< (ir-price ir) p)) aloir t) )

88 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 lambda statt local 88 Wozu der Zwischenschritt? Besser: direkt den erzeugten Prozedurwert zur ü ckliefern ;; add : number -> (number -> number) ;; to create a function that adds x to its input (define (add x) (local ((define (x-adder y) (+ x y))) x-adder)) ;; add : number -> (number -> number) ;; to create a function that adds x to its input (define (add x) (lambda (y) (+ x y))) Drei Schritte: Erzeuge einen Prozedurwert Assoziiere einen Namen mit dem Wert Werte den Namen aus, um den Wert zur ü ckzuliefern

89 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 lambda statt local 89 (define (filter2 rel-op) (local ( (define (abs-fun alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (abs-fun (rest alon) t))] [else (abs-fun (rest alon) t)])])) ) abs-fun) ) Quiz: Kann ich hier local mit lambda ersetzen?

90 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Semantik von lambda Grundlegendes zur Auswertung von lambda -Expressions: –Ein lambda -Ausdruck ist ein Wert, weil Funktionen Werte sind –Die Anwendung von lambda -Ausdrücken erfolgt nach den üblichen Regeln der Funktionsanwendung, vorausgesetzt, wir werten die Kurzform zuerst aus 90 (lambda (x-1... x-n) exp) (local ((define (a-new-name x-1... x-n) exp)) a-new-name)

91 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Semantik von lambda Zur Erläuterung evaluieren wir die folgende Applikation: 91 (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])])) (filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8) Zur Erinnerung: die Definition von filter1

92 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Scope und Semantik von lambda 92 (filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8)... = (filter1 (local ((define (

93 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Semantik von lambda Wir können die Semantik von lambda direkter erklären: 93 = exp mit x-1... x-n ersetzt durch val-1... val-n ( (lambda (x-1... x-n) exp) val-1... val-n )

94 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Semantik von lambda Zur Erläuterung evaluieren wir erneut die Applikation: 94 (define (filter1 rel-op alon t) (cond [(empty? alon) empty] [else (cond [(rel-op (first alon) t) (cons (first alon) (filter1 rel-op (rest alon) t))] [else (filter1 rel-op (rest alon) t)])])) Zur Erinnerung: die Definition von filter1 (filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8)

95 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Scope und Semantik von lambda 95 (filter1 (lambda (ir p) (< (ir-price ir) p)) (list (make-ir 'doll 10)) 8) = (cond [((lambda (ir p) (< (ir-price ir) p)) (make-ir 'doll 10) 8) (cons (first (list (make-ir 'doll 10))) (filter1 (lambda (ir p) (< (ir-price ir) p)) (rest (list (make-ir 'doll 10))) 8))] [else (filter1 (lambda (ir p) (< (ir-price ir) p)) (rest (list (make-ir 'doll 10))) 8) ]) = (cond [(< (ir-price (make-ir 'doll 10)) 8) (cons (first (list (make-ir 'doll 10))) (filter1 (lambda (ir p) (< (ir-price ir) p)) (rest (list (make-ir 'doll 10))) 8))] [else (filter1 (lambda (ir p) (< (ir-price ir) p)) (rest (list (make-ir 'doll 10))) 8)]) = El. der Liste

96 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Pragmatik von lambda 96 Richtlinie für Lambda Ausdrücke Benutze lambda-Ausdrücke, wenn eine Funktion nicht rekursiv ist und nur einmal, als Argument, gebraucht wird

97 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Warum Lambda ? Das Wort Lambda stammt aus -Kalkül - ein mathematisches Kalkül –Es wurde eingeführt von Alonso Church –Im Wesentlichen der Kern von Scheme (eine minimale aber komplette Sprache): Nur Lambda-Abstraktion und Anwendung Keine primitiven Typen/Prozeduren Keine Spezialformen etc. –Grundlegendes Werkzeug für mathematische Untersuchungen und formale Behandlung von Programmiersprachen Zunächst kann man Lambda als erzeuge-Prozedur betrachten –Aber schauen wir uns kurz an, was man mit Lambda alleine alles machen kann! 97

98 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Das ultimative Lambda … Berechnen ohne primitive Werte/Typen, spezielle Formen? Ja! Alles wird durch Funktionen modelliert … z.B. die primitiven Operatoren and/or 98 (define my-or (lambda (op1 op2) (cond [op1 true] [else (cond [op2 true] [else false])]))) (define my-and (lambda (op1 op2) (cond [op1 (cond [op2 true] [else false])] [else false])))

99 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Das ultimative Lambda … Spezielle Formen können nicht als Parameter einer Prozedur übergeben werden … Zur Illustration schauen wir uns die Scheme Funktionen andmap und ormap an 99 OK, aber wozu soll das gut sein? Um die Komponierbarkeit zu erhöhen Closure-Prinzip!

100 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Das ultimative Lambda … 100 (andmap even? `(2 6)) = true Der Fall andmap und ormap ;; andmap : (X -> boolean) (listof X) -> boolean ;; determines whether p holds for every item on alox ;; (andmap p (list x-1... x-n)) = ;; (and (p x-1) (and... (p x-n))) (define (andmap p alox) (cond [(empty? alox) true] [else (and (p (first alox)) (andmap p (rest alox)))] ) )

101 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Das ultimative Lambda … 101 (ormap even? (list 5 1) = false Der Fall andmap und ormap ;; ormap : (X -> boolean) (listof X) -> boolean ;; determines whether p holds for at least one item ;; on alox ;; (ormap p (list x-1... x-n)) = ;; (or (p x-1) (or... (p x-n))) (define (ormap p alox) (cond [(empty? alox) false] [else (or (p (first alox)) (ormap p (rest alox)))]))

102 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Das ultimative Lambda … Nach unserem Rezept könnten wir in dem Fall abstrahieren, wenn nur and, or Funktionen wären … 102 Der Fall andmap und ormap (define (ormap p alox) (cond [(empty? alox) false ] [else (or (p (first alox)) (ormap p (rest alox)))])) (define (andmap p alox) (cond [(empty? alox) true ] [else (and (p (first alox)) (andmap p (rest alox)))]))

103 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Das ultimative Lambda … 103 Der Fall andmap und ormap Eigentlich haben wir ja bereits eine abstrakte Funktion, die wir wieder verwenden können, um andmap and ormap abzuleiten. Wir bräuchten andormap gar nicht. (define (andormap bool-op init p alox) (cond [(empty? alox) init] [else (bool-op (p (first alox)) (andormap bool-op init p (rest alox)))])) (define (andmap3 p l) (andormap my-and true p l)) (define (ormap3 p l) (andormap my-or false p l))

104 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Das ultimative Lambda … 104 (define (prod alon) (fold 1 * alon)) (define (sum alon) (fold 0 + alon)) (define (andmap4 p alox) (fold true my-and (map p alox))) (define (ormap4 p alox) (fold false my-or (map p alox))) ;; fold : Y (X Y -> Y) (listof X) -> Y (define (fold init combine-op lst) (cond [(empty? lst) init] [else (combine-op (first lst) (fold init combine-op (rest lst)))]))

105 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Überblick Ähnlichkeiten in Definitionen Funktionen sind Werte Abstraktionen aus Beispielen entwerfen Abstraktionen mit Funktionen als Werten entwerfen Funktionen ad hoc definieren pipes-and-filters Organisation von Berechnungen 105

106 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 [Erinnerung: Die Rolle von Abstraktion] Programmierer können die Wartungskosten senken, indem sie Programme richtig organisieren Erstes Prinzip: Passe die Struktur der Funktion an die Struktur der Daten an. –Erleichtert Erweiterungen von Funktionen, wenn die Menge der möglichen Eingabedaten sich verändert Zweites Prinzip: Führe angemessene Abstraktionen ein –Jede abstrahierte Funktion erzeugt einen eindeutigen Kontrollpunkt für mindestens zwei verschiedene Funktionen, oft für mehr 106 Jetzt wo wir Funktionen höherer Ordnung kennen, ist es an der Zeit, das erste Prinzip nochmals zu betrachten …

107 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Addition der Quadrate aller ungeraden Knoten eines Baums … (define (sum-of-odd-squares alon) (cond [(empty? alon) 0] [(not (cons? alon)) (if (odd? alon) (square alon) 0)] [else (+ (sum-of-odd-squares (first alon)) (sum-of-odd-squares (rest alon)))])) 107 Prozessstruktur folgt der Datenstruktur

108 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Sammeln der geraden Fibonacci-Zahlen von 0..n 108 0für n = 0 Fib(n) = 1für n = 1 Fib(n-1) + Fib(n-2)sonst Prozessstruktur folgt der Datenstruktur ;; sammelt die geraden Fib(k) für k = [0..n] (define (even-fibs n) (local ((define (process k) (cond [(> k n) empty] [else (local ((define f (fib k))) (cond [(even? f) (cons f (process (+ k 1)))] [else (process (+ k 1))]))]) )) (process 0)) )

109 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 (define (sum-of-odd-squares tree) (cond ((empty? tree) 0) ((not (cons? tree)) (if (odd? tree) (square tree) 0)) (else (+ (sum-of-odd-squares (first tree)) (sum-of-odd-squares (rest tree)) ) Prozessstruktur folgt der Datenstruktur 109 Können Sie Ähnlichkeiten zwischen den beiden Prozeduren erkennen? (define (even-fibs n) (local ((define (process k) (cond [(> k n) empty] [else (local ((define f (fib k))) (cond [(even? f) (cons f (process (+ k 1)))] [else (process (+ k 1))]))]))) (process 0)))

110 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Fokus auf die Prozessphasen … Eine abstraktere Beschreibung der Berechnung zeigt … sum-of-odd-squares : –Zählt die Blätter eines Baumes auf –Filtert sie, um die ungeraden zu erhalten –Bearbeitet die ungeraden, indem sie quadriert werden –Akkumuliert die Ergebnisse mittels +, Start mit 0 even-fibs : –Zählt die ganzen Zahlen von 0 bis n auf –Bearbeitet jede ganze Zahl, indem die Fibonaccizahl berechnet wird –Filtert sie um die geraden zu bekommen –Akkumuliert die Ergebnisse mittels cons, Start mit der leeren Liste 110

111 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Fokus auf die Prozessphasen … 111 Aufzählen: Blätter Filtern: ungerade? Aufzählen: Zahlen Filtern: even? map: fib map: square Akkumul.: +, 0 Akkumul.: cons, empty sum-of-odd-squares even-fibs

112 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Prozessstruktur folgt der Datenstruktur Die Struktur des Prozessflusses geht bei dieser Strukturierung verloren… Es gibt keine klaren Teile, die zu den Elementen der Prozessflussdarstellung passen; sie sind vermischt 112 enumeration accumulation processing filtering (define (sum-of-odd-squares tree) (cond [(empty? tree) 0] [(not (cons? tree)) (if (odd? tree) (square tree) 0) ] [else (+ (sum-of-odd-squares (first tree)) (sum-of-odd-squares (rest tree)) ) ] )

113 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Zerlegung in Prozessphasen Ein Prozess kann häufig in Sequenzen von Schritten zerlegt werden, z.B.: –Kompilierung –Auffinden von gemeinsamen Wörtern in zwei Textdateien Häufige Arten von Schritten –Aufzählen, filtern, bearbeiten, akkumulieren 113 1)Erstelle eine Liste aller Blätter[aufzählen] 2)Hole die ungeraden Knoten aus der Liste[filtern] 3)Erstelle die Liste der Quadrate[bearbeiten] 4)Addiere die Quadrate[akkumulieren]

114 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Ein Mehrzweck-Filter 114 (define (filter test alox) (cond [(empty? alox) empty] [(test (first alox)) (cons (first alox) (filter test (rest alox)))] [else (filter test (rest alox))])) (filter even? (list )) -> ( ) Abstraktion über den Test, indem das Prädikat als Parameter übergeben wird. Eine Vorlage für den Filter-Prozess

115 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Ein Mehrzweck-Zusammenfalter 115 Abstraktion über den binären Operator ( combine-op ) zum Zusammenfalten, den Initialwert ( init ) und über die Liste, die zusammengefaltet wird ( alox ) Wir wissen nur, dass wir zusammenfalten, indem wir den binären Operator auf die Werte der Liste anwenden. ;; fold : Y (X Y -> Y) (listof X) -> Y (define (fold init combine-op lst) (cond [(empty? lst) init] [else (combine-op (first lst) (fold init combine-op (rest lst)))])) Eine Vorlage für den Akkumulations-Prozess

116 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Datenstruktur bedingt Enumeratoren Die Art, eine Datenstruktur zu durchlaufen, kann nicht unabhängig von der speziellen Datenstruktur sein … 116 (enumerate-interval 3 10) --> ( ) Aufzählung von ganzen Zahlen… (define (enumerate-interval lo hi) (cond [(> lo hi) empty] [else (cons lo (enumerate-interval (+ lo 1) hi))]))

117 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Datenstruktur bedingt Enumeratoren Blätter aufzählen… 117 if x --> ((1 3) 2 (5 (4 6))), then (enumerate-tree x) --> ( ) (define (enumerate-tree tree) (cond [(empty? tree) empty] [(not (cons? tree)) (list tree)] [else (append (enumerate-tree (first tree)) (enumerate-tree (rest tree)))]) )

118 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 sum-of-odd-squares als Komposition von Schritten 118 [transduce] [accumulate] [filter] enumeration accumulation processing filtering (sum-of-odd-squares ((1 3) 2 (5 (4 6))) ) 35 (define (sum-of-odd-squares tree) (fold + 0 (map square (filter odd? (enumerate-tree tree) )

119 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Andere Schritt-basierte Prozesse 119 (define (even-fibs n) (fold cons empty (filter even? (map fib (enumerate-interval 0 n))))) (define (highest-programmer-salary records) (fold max 0 (map salary (filter programmer? records)) )

120 Dr. G. Rößling Prof. Dr. M. Mühlhäuser RBG / Telekooperation © Grundlagen der Informatik I: T5 Vorteile der Zerlegung in Schritte Unterstützung modularer Programmentwürfe –Entwürfe sind aus relativ unabhängigen Teilen (Komponenten) zusammengesetzt Die meisten Schritte können als Mehrzweck-Prozeduren geschrieben werden, die wiederum als Vorlage für eine Vielzahl von Prozessen dienen können. –Einfach zu schreiben und zu verstehen. Förderung modularen Entwurfs durch: –Bibliothek mit Standard-Komponenten –Eine konventionelle Schnittstelle für eine flexible Verbindung der Komponenten. 120 Modulare Konstruktion ist eine mächtige Strategie, um die Komplexität im Entwurf zu kontrollieren. Nachteil bei dieser Art von Entwürfen?


Herunterladen ppt "Telecooperation/RBG Technische Universität Darmstadt Copyrighted material; for TUD student use only Grundlagen der Informatik I Thema 5: Abstraktion von."

Ähnliche Präsentationen


Google-Anzeigen