presentation

2024-11-13 19:18:55 +01:00 · 2024-11-13 19:18:55 +01:00 · 89e12bdf9f
commit 89e12bdf9f
parent 3043c83f71
1 changed files with 254 additions and 0 deletions
--- a/docs/presentation/01_funktionale_programmierung.md
+++ b/docs/presentation/01_funktionale_programmierung.md
@ -0,0 +1,254 @@
 **Vergleich und Vorstellung der funktionalen Aspekte von Go und Dart (mit fpdart) sowie Bezug zum Lambda-Kalkül**
 ---
 ### **Einführung**
 Sowohl **Go** als auch **Dart** sind moderne Programmiersprachen, die hauptsächlich imperativ und objektorientiert ausgerichtet sind. Dennoch unterstützen beide Sprachen funktionale Programmierparadigmen in unterschiedlichem Maße. Die Bibliothek **fpdart** erweitert Dart um fortgeschrittene funktionale Programmierkonzepte. Im Folgenden werden die funktionalen Aspekte von Go und Dart (mit fpdart) verglichen und erläutert, wie diese mit dem **Lambda-Kalkül** in Verbindung stehen.
 ---
 ### **Funktionale Programmierung**
 **Funktionale Programmierung** ist ein Programmierparadigma, das Funktionen als zentrale Bausteine betrachtet. Es fördert:
 - **Unveränderlichkeit**: Daten werden nicht verändert, sondern es werden neue Datenstrukturen erzeugt.
 - **Reine Funktionen**: Funktionen ohne Seiteneffekte.
 - **Funktionen höherer Ordnung**: Funktionen, die andere Funktionen als Argumente nehmen oder zurückgeben.
 ---
 ### **Go und funktionale Programmierung**
 **1. Funktionen als erstklassige Objekte**
 - **Definition und Verwendung**: In Go können Funktionen wie Variablen behandelt werden. Sie können zugewiesen, als Parameter übergeben und zurückgegeben werden.
  ```go
  func add(a, b int) int {
      return a + b
  }
  func compute(a int, b int, op func(int, int) int) int {
      return op(a, b)
  }
  result := compute(5, 3, add) // Ergebnis: 8
  ```
 **2. Anonyme Funktionen und Closures**
 - **Anonyme Funktionen**: Go unterstützt anonyme Funktionen, die direkt definiert und verwendet werden können.
  ```go
  func main() {
      increment := func(x int) int {
          return x + 1
      }
      fmt.Println(increment(5)) // Ausgabe: 6
  }
  ```
 - **Closures**: Anonyme Funktionen können auf Variablen aus ihrem umgebenden Kontext zugreifen.
  ```go
  func main() {
      x := 0
      increment := func() int {
          x++
          return x
      }
      fmt.Println(increment()) // Ausgabe: 1
      fmt.Println(increment()) // Ausgabe: 2
  }
  ```
 **3. Fehlende erweiterte funktionale Konzepte**
 - **Keine Immutabilität**: Go fördert nicht standardmäßig unveränderliche Datenstrukturen.
 - **Fehlende Funktionen höherer Ordnung im Standardpaket**: Es gibt keine eingebauten Funktionen wie `map`, `filter` oder `reduce` für Slices oder Arrays.
 - **Seiteneffekte**: Go erlaubt und verwendet häufig Funktionen mit Seiteneffekten.
 ---
 ### **Dart und funktionale Programmierung mit fpdart**
 **1. Funktionen als erstklassige Objekte**
 - **Definition und Verwendung**: Dart behandelt Funktionen ebenfalls als erstklassige Objekte.
  ```dart
  int add(int a, int b) => a + b;
  int compute(int a, int b, int Function(int, int) op) => op(a, b);
  var result = compute(5, 3, add); // Ergebnis: 8
  ```
 **2. Anonyme Funktionen und Closures**
 - **Anonyme Funktionen (Lambdas)**:
  ```dart
  var increment = (int x) => x + 1;
  print(increment(5)); // Ausgabe: 6
  ```
 - **Closures**: Zugriff auf Variablen aus dem umgebenden Kontext.
  ```dart
  void main() {
    var x = 0;
    var increment = () {
      x++;
      return x;
    };
    print(increment()); // Ausgabe: 1
    print(increment()); // Ausgabe: 2
  }
  ```
 **3. fpdart-Bibliothek**
 - **Überblick**:
  - **fpdart** ist eine funktionale Programmierbibliothek für Dart, inspiriert von Haskell und anderen funktionalen Sprachen.
  - Sie bietet Werkzeuge und Datenstrukturen für funktionale Programmierkonzepte wie **Option**, **Either**, **Monad**, **Functor** usw.
 - **Hauptmerkmale**:
  - **Option (Maybe)**: Umgang mit optionalen Werten, die vorhanden sein können oder nicht.
    ```dart
    Option<int> parseInt(String str) {
      final value = int.tryParse(str);
      return value != null ? Some(value) : None<int>();
    }
    ```
  - **Either**: Behandlung von Berechnungen, die entweder einen Wert oder einen Fehler liefern.
    ```dart
    Either<String, int> divide(int a, int b) {
      return b == 0 ? Left('Division durch Null') : Right(a ~/ b);
    }
    ```
  - **Functor und Monad**: Unterstützung für Funktionstransformationen und Sequenzierung von Berechnungen.
 - **Vorteile**:
  - **Immutabilität**: Fördert unveränderliche Datenstrukturen.
  - **Reine Funktionen**: Ermutigt zur Verwendung von Funktionen ohne Seiteneffekte.
  - **Typensicherheit**: Durch generische Typen und klare Strukturen werden Laufzeitfehler reduziert.
 ---
 ### **Vergleich zwischen Go und Dart (mit fpdart)**
 **1. Sprachdesign und Paradigmen**
 - **Go**:
  - Primär eine imperative Sprache mit einigen funktionalen Merkmalen.
  - Legt Wert auf Einfachheit, Leistung und Parallelität.
  - Funktionale Programmierung ist möglich, aber nicht im Fokus.
 - **Dart (mit fpdart)**:
  - Unterstützt objektorientierte und funktionale Programmierung.
  - Durch fpdart werden fortgeschrittene funktionale Konzepte zugänglich.
  - Ideal für Anwendungen, die von funktionaler Programmierung profitieren, z. B. bei der Entwicklung mit Flutter.
 **2. Funktionale Features**
 - **Go**:
  - Funktionen als Werte, anonyme Funktionen, Closures.
  - Keine eingebauten funktionalen Datenstrukturen oder Monaden.
  - Keine direkte Unterstützung für Immutabilität oder reine Funktionen.
 - **Dart (mit fpdart)**:
  - Erweiterte funktionale Bibliothek mit Monaden, Funktoren, Option, Either usw.
  - Förderung von Immutabilität und reinen Funktionen.
  - Bessere Unterstützung für funktionale Programmiermuster.
 **3. Community und Ökosystem**
 - **Go**:
  - Starkes Ökosystem für serverseitige Anwendungen und Systemprogrammierung.
  - Funktionale Programmierung wird weniger betont, aber es gibt Drittanbieterbibliotheken.
 - **Dart (mit fpdart)**:
  - Wachsende Community, insbesondere durch Flutter.
  - fpdart ist aktiv entwickelt und erweitert die Möglichkeiten von Dart in Richtung funktionaler Programmierung.
 ---
 ### **Bezug zum Lambda-Kalkül**
 **1. Was ist das Lambda-Kalkül?**
 - **Lambda-Kalkül** ist ein formales System aus der mathematischen Logik zur Untersuchung von Funktionen und deren Anwendung.
 - Es bildet die theoretische Grundlage für die funktionale Programmierung.
 - Zentral sind anonyme Funktionen (Lambdas) und die Auswertung durch Funktionsanwendung.
 **2. Anwendung in Go und Dart**
 - **Anonyme Funktionen**:
  - Beide Sprachen unterstützen anonyme Funktionen, die direkt aus dem Lambda-Kalkül abgeleitet sind.
  - Diese ermöglichen Funktionen ohne Namen, die wie Variablen behandelt werden können.
 - **Funktionen höherer Ordnung**:
  - Funktionen, die andere Funktionen als Argumente nehmen oder zurückgeben.
  - Wesentlich für die Ausdruckskraft des Lambda-Kalküls und in beiden Sprachen verfügbar.
 **3. Erweiterte Konzepte mit fpdart**
 - **Monaden und Funktoren**:
  - Konzepte aus der Kategorie-Theorie, eng verwandt mit dem Lambda-Kalkül.
  - Erlauben das Sequenzieren und Komponieren von Berechnungen auf abstrakte Weise.
  - fpdart implementiert diese Konzepte in Dart und erweitert somit die Ausdruckskraft der Sprache im Sinne des Lambda-Kalküls.
 **4. Relevanz**
 - **Go**:
  - Unterstützt grundlegende Konzepte des Lambda-Kalküls, aber ohne tiefe Integration.
  - Eignet sich für pragmatische Anwendungen, bei denen funktionale Programmierung nicht im Vordergrund steht.
 - **Dart (mit fpdart)**:
  - Ermöglicht die Anwendung komplexerer Konzepte des Lambda-Kalküls.
  - Bietet eine reichhaltigere Plattform für funktionale Programmierung.
 ---
 ### **Fazit**
 - **Go** bietet grundlegende funktionale Programmiermöglichkeiten, aber der Schwerpunkt liegt auf imperativer und prozeduraler Programmierung.
 - **Dart**, insbesondere mit der **fpdart**-Bibliothek, bietet erweiterte Unterstützung für funktionale Programmierung und ermöglicht die Nutzung fortgeschrittener Konzepte wie Monaden, Funktoren und unveränderliche Datenstrukturen.
 - **Lambda-Kalkül** bildet die theoretische Basis für funktionale Programmierung und ist in beiden Sprachen durch anonyme Funktionen und Funktionen höherer Ordnung präsent. Mit fpdart wird Dart jedoch stärker an die Prinzipien des Lambda-Kalküls angelehnt.
 ---
 ### **Empfehlung**
 Wenn Sie an funktionaler Programmierung interessiert sind und diese Konzepte in Ihrer Arbeit einsetzen möchten, ist **Dart mit fpdart** eine geeignete Wahl. Es bietet eine umfangreiche Bibliothek, um funktionale Paradigmen effektiv zu nutzen. **Go** ist hingegen ideal, wenn Sie eine einfache und performante Sprache für systemnahe Anwendungen benötigen, bei denen funktionale Programmierung nicht im Mittelpunkt steht.
 ---
 ### **Weiterführende Ressourcen**
 - **fpdart GitHub-Repository**: [https://github.com/SandroMaglione/fpdart](https://github.com/SandroMaglione/fpdart)
 - **Offizielle Go-Dokumentation**: [https://golang.org/doc/](https://golang.org/doc/)
 - **Dart Programmierung**: [https://dart.dev/](https://dart.dev/)
 - **Einführung in funktionale Programmierung und Lambda-Kalkül**:
  - **Buch**: "Funktionale Programmierung in Scala" (auch für andere Sprachen hilfreich)
  - **Online-Ressourcen**: Suchen Sie nach Tutorials zu funktionaler Programmierung und Lambda-Kalkül.