Gregor Trefs - Funktionale Programmierung, Konferenzvorträge, Fachartikel

Gregor Trefs über funktionale Programmierung, Konferenzen und Fachartikel – Anwendungsentwickler-Podcast #106

Funktionale Programmierung, Konferenzvorträge und Fachartikel im Gespräch mit Gregor Trefs sind das Thema der einhundertsechsten Episode des Anwendungsentwickler-Podcasts.

Inhalt

Folgende Fragen gehen wir im Verlaufe des Interviews durch.

Allgemeines zur Person

  • Wie ist dein Name und wo arbeitest du?
    • Gregor Trefs, 31 Jahre alt
    • Momentan bin ich freiberuflich unterwegs
    • Themen: Java und Security
  • Wie bist du zur Informatik bzw. Softwareentwicklung gekommen?
    • Computer fand ich interessant
    • Erster Rechner: 486
    • Erstes Programm mit 12 Jahren geschrieben: Text-Adventure in Basic
    • Viel Macromedia Flash: ActionScript 2 (ECMA Script Derivat)
    • Mit 16 auf ein technisches Gymnasium gegangen
    • Software und Hardware
    • Design
    • Hauptsächlich Java
  • Welche Ausbildung bzw. Studium im Bereich der Informatik hast du absolviert?
    • Studium Wirtschaftsinformatik
    • Viel Abwechslung
    • Nie das Interesse verloren
    • Tutorentätigkeit in Softwaretechnik
    • Masterarbeit im Bereich künstliche Intelligenz
      • Semantic Web Technolgies
      • Hadoop
  • Mit welcher Programmiersprache arbeitest du im Alltag?
    • Hauptsächlich Java
    • Nebenbei Kotlin und Scala
  • Lieblingsprogrammiersprache
    • Klar man arbeitet mit manchen Sprachen lieber als mit anderen.
    • Jedoch ist das nicht einfach
      • Immer eine Frage wie vertraut man mit der Sprache ist
    • Faszinierend finde ich Scala
      • Sehr viel dabei
      • Stichwort: Typelevel Programming
      • Jedoch: Steile Lernkurve und manchmal eine Sytax zum Wegrennen
      • Auch sehr wissenschaftlich orientiert
      • Forschungssprache etc.
      • Compiler finde ich toll
      • Tolle Inferenz
      • Hier möchte ich noch mehr lernen
    • Praktikabel finde ich Kotlin
      • Kompatibel mit Java und der Compiler hilft mehr
      • Typinferenz val/var etc.
      • Nulltypes ist interessant
      • Kein Fan der Lamdba-Syntax, da geschweifte Klammer für mich zu überladen wirkt
      • Geht schnell voran
      • Coroutines sehen toll aus
      • Bessere Abstraktion für parallele Programmierung im Vergleich mit Java
    • JavaScript
      • Ich möchte mal wirklich was Nettes mit machen
      • Leider nie wirklich die Zeit gefunden
      • Ich finde Flow Types toll und auch normale Linter
      • JSON in Javascript fühlt sich einfach besser an
    • Haskell
      • Verdreht einem den Kopf 😉
      • Gut zum Lernen von FP
      • Verständnis für Equational Reasoning steigt
      • Angst vor Monaden wird genommen, da Monaden einen klaren Zweck erfüllen
      • Bspw. pure functional IO -> IO Monade
      • Nie produktiv eingesetzt
    • Java
      • Kenne ich am besten
      • Entdecke doch immer was Neues (z.B. java.nio)
      • Lambda-Syntax sehr angenehm
      • Leider etwas komplexes Typsystem
      • Referenz- vs. primitive Typen
      • Type Erasure
      • Sehr große Community

Funktionale Programmierung

  • Wie würdest du die funktionale Programmierung (FP) einem Einsteiger erklären?
    • FP ist ein Programmierparadigma
    • Eine bestimmte Ansicht wie ein Computerprogramm gestaltet wird
    • Grundlegendes Element: Funktion
    • Es basiert auf dem Lambda-Kalkül von Alonzo Church
    • Formale Sprache zur Untersuchung von Funktionen
    • Formal: Grammatik und Alphabet unwidersprüchlich durch Mathematik ausgedrückt
    • Beschreibt Umwandlungsregeln wie Funktionen bspw. auf Argumente angewendet werden
    • Verzicht auf die Änderung eines globalen Zustands
    • Unterschied zu imperativ: Zustandsänderung durch Imperative
    • Erleichtert semantische Analyse
    • Bedeutung? Ersetze Funktionen rekursiv durch ihren Rückgabewert
    • Form der Auswertung: Subsitutionsmodell
    • Problem: I/O
    • Im Lambda-Calculus geht es um die Anwendung von Umformungsregeln auf Lambda-Ausdrücken bis keine Regel mehr anwendbar ist
    • Wenn wir aber nur Umformungsregeln haben, wie modellieren wir dann Input und Output und bleiben dem Lambda-Kalkül treu?
    • Anders gefragt, wie bleibt eine funktionale Sprache mit I/O pur?
    • Verschiedene Lösungen
      • Prozeduren kümmern sich um Input und Output und „füttern“ einen funktionelen Kern
      • Beschreibung des Effektes mit puren Funktionen welche dann mit einem Interpreter ausgeführt werden (Stichwort: Monaden)
      • Seiteneffekte am Rand der Applikation und wohldefiniert
    • Ohne Angst an die Materie herangehen und Verständnisfehler akzeptieren
  • Welche wichtigen Konzepte zeichnen die FP aus?
    • Einfaches Nachvollziehen von Verhalten (Substitutionsmodell)
    • Trennung von Beschreibung und eigentlicher Ausführung
    • Kein geteilter globaler Zustand
    • Komposition von Funktionen
    • Funktionen höherer Ordnung
    • Klare Trennung von Verantwortlichkeiten
    • Implizite Informationen können explizit modelliert werden
  • FP ist ja eigentlich schon uralt! Warum sollte man sich heute (wieder) damit beschäftigen?
    • Neues Paradigma: Neue Lösungen für alte Probleme
    • Mehrkern-Prozessoren: Funktionen auf je einem Kern ausführen
    • Vgl. John Carmack: „My pragmatic summary: A large fraction of the flaws in software development are due to programmers not fully understanding all the possible states their code may execute in. In a multithreaded environment, the lack of understanding and the resulting problems are greatly amplified, almost to the point of panic if you are paying attention. Programming in a functional style makes the state presented to your code explicit, which makes it much easier to reason about, and, in a completely pure system, makes thread race conditions impossible.“
    • Spaß
  • Welche Vorteile hat FP gegenüber der Objektorientierung (OO)?
    • Meine Meinung
    • Keine Seiteneffekte, dadurch einfacheres Nachvollziehen
    • Funktionen sind per se kompositionierbar
    • Keine Seiteneffekte, dadurch bessere Testbarkeit
      • Input -> Output
    • Funktionen in einem Kontext ausführen
      • Beispiel: Transaktionen
      • Imperativ: begin -> code -> end
      • Funktional: Transaction(f) map(g) flatMap(Transaction(h)) run
    • Man arbeitet mit Werten
      • Einmal erstellt ändern sich diese nicht
    • Gegenargumente
    • Mit OOP lassen sich Klassen modellieren, die einer Funktion ähneln
      • Specification Pattern: Create Specification and run against Candidate
    • Veränderbare Strukturen dominant in Java
      • Immutables keine Alternative: Speicher
      • Lösung: Purely functional data structures (siehe vavr)
      • Immutable: Keine Änderung -> neue Instanz, jedoch Structural Sharing
      • Persistent: Alte Struktur bleibt erhalten
  • Wie schwer fiel/fällt dir der Wechsel zwischen FP und OOP?
    • Ökonomische Sicht: Solange FP bis Kosten größer als anderes Paradigma
    • Sprache?
    • FP Wissen?
      • Am Anfang eine riesen Lernkurve
      • Viele Konzepte, die erst verstanden werden müssen und eingeordnet
      • Historische Recherche hat mir auch ein bisschen dabei geholfen
      • Ich kann nicht alles in FP
      • Das FP gibt es auch nicht
      • Bspw. sind LISP und Clojure untypisiert
      • OCAML und Haskell stark typisiert
      • Ähnlicher Kampf wie bspw. JavaScript vs. Java
      • Aber auch Scala vs. Java
    • Ziel: Produktiv arbeiten. Code der unseren Ansprüchen genügt.
    • Ich benutze FP da, wo es Sinn macht und soweit mein Verständnis mich trägt
  • Nutzt du im Alltag nur Konzepte der FP in OO-Sprachen oder rein funktionale Sprachen?
    • Primäre Sprache: Java
    • Java ist keine funktionale Sprache
    • Die Bedeutung eines Java-Programs ist definiert durch das Memory Model
    • Das Memory Model regelt, wie Threads durch Speicher miteinander kommunizieren
    • D.h. per se gibt es shared mutable state
    • Jedoch funktionale Konzepte
    • Unveränderliche Werte
    • Funktionen benutzen
    • Monaden
    • Combinatoren
    • Ich nutze Kotlin und Java
  • Magst du persönlich lieber FP, OO oder eine Kombination aus beiden und warum?
    • Mir gefällt die Idee von FP besser
    • OOP hatte ein paar Versprechen die nicht ganz eingehalten wurden
    • siehe lambdafy
    • Code Reuse: Compose functions
  • Wie können auch unerfahrene Entwickler mit FP beginnen?
    • Code-Katas: Probleme mit Funktionen lösen
    • Online Kurse: Coursera, EDX, etc.
    • Bücher: Learn you a Haskell for a greater good (Miran Lipovaca) Functional Programming in Scala (Paul Chiusano, Rúnar Bjarnason)

Vorträge auf Konferenzen

  • Worum ging es in deinem Vortrag auf der JavaLand?
    • Es ging um das Combinator Pattern in Java 8
  • Wie kam es zu deinem Vortag auf der Javaland?
    • Ich war letztes Jahr auf der Javaland und habe Leute auf dem Newcomer-Track gesehen
    • Ich fand das toll. Stellenweise besser als die „Etablierten“
    • Da war mir klar: Das willst du machen.
  • Was ist der Newcomer-Track und wie wurdest du betreut?
    • Die JavaLand möchte den Nachwuchs förden
    • In diesem Rahmen gibt es den Newcomer-Track
    • Leute, die zuvor nicht auf einer Konferenz gesprochen haben
    • Man meldet sich mit Thema und Mentor an
    • Der Track geht über beide Konferenztage hinweg
    • Ich habe mich mit meinem Thema beworben und mit Johannes Link als Mentor
    • Falls man keinen Mentor angibt, bekommt man einen zugeteilt
    • Johannes kenne ich schon seit ca. 2-3 Jahren
    • Er hat in Heidelberg ein Code Dojo für Kinder veranstaltet und ich war mit dabei als Mentor
      • An das Mentoring bin ich über Walery Strauch gekommen, einer unserer Mitorganisatoren
    • Um ehrlich zu sein, wusste ich beim Kennenlernen nicht, dass er recht bekannt ist und ein Fachbuch über TDD geschrieben hat
    • Hier auch mal Grüße an euch Johannes und Walery 🙂
  • Wie hast du das Thema deines Vortrags gefunden?
    • Ich hatte etwas mit FP in Java eingereicht
    • Artem Kozlov und ich hatten bereits bei der majug einen ähnlichen Vortrag gehalten
    • Nach dem ersten Treffen mit Johannes war klar, dass das viel zu weit gegriffen ist
    • Wir haben uns dann zusammen auf das Thema Combinator Pattern in Java 8 festgelegt
  • Wie hast du dich auf deinen Vortrag vorbereitet?
    • Johannes und ich haben uns ein paar mal getroffen. Oft im Cafe, aber auch bei mir zu Hause.
    • Thema schärfen
    • Abstract: Leute ansprechen und die Erwartungen genau beschreibt
      • Welches Publikum will ich ansprechen? Was für Voraussetzungen erwarte ich vom Publikum?
    • Danach ging es dann los.
      • Folien erstellt und mit Johannes ausgetauscht
      • Weiterhin hatte ich einen Probevortrag und Kommentare eingearbeitet
      • Ich möchte Mark Paluch nochmals für den Tipp mit dem Comparator-Typ danken
      • Dieser nutzt Combinator
      • Am Ende war der Foliensatz da und ich war glücklich 🙂
      • Inzwischen finde ich Google Docs da ganz angenehm
  • Was hast du selbst durch den Vortrag gelernt?
    • Nicht so viel Aufregug 🙂 Alles halb so schlimm
    • Haltung, Haltung, Haltung
    • In einem Foto sitze ich mit dem Schultern nach vorne und mache einen recht beklemmten Eindruck
    • Das nächste mal schnappe ich mir was zu trinken 🙂
    • Dass es klappt
    • Dass die Leute von der majug echt klasse sind (das wusste ich eigentlich schon vorher :-D)
    • Dass Nicolai und Marc super Tipps geben
    • Dass Johannes ein richtig guter Mentor ist
    • Dass Leute mir zuhören
    • Dass es nicht schlimm ist, wenn Leute den Raum verlassen
    • Dass ich langsamer sprechen muss
    • Dass ich die Leute evtl. mehr einbinde
  • Was hat dir der Vortrag rückblickend gebracht?
    • Votrag auf der Karlsruhe Java User Group, Artikel in der Java Aktuell
    • Erfahrung
    • Kontakte

Fachartikel

  • Wie kam es zu deinem ersten Fachartikel?
    • August 2016 habe ich meinen Blog umgekrempelt und einen ersten ernsthaften Eintrag geschrieben.
    • Nicolai Parlog war zu der Zeit bei uns an der majug und hat einen Vortrag gehalten.
    • Da habe ich gesehen, dass er auf Sitepoint den Java-Channel aufgemacht hat.
    • Ich habe mir gedacht: Fragen kostet nichts und und meinen Artikel angeboten.
    • Nicolai fand den Artikel gut und hat mich gefragt ob ich denn nicht weiter schreiben möchte.
    • Nach der JavaLand hat mich Wolfgang Taschner angeschrieben
    • Artikel erscheint im August
  • Wie aufwendig ist das Schreiben eines Artikels?
    • Kommt auf den Artikel an und wie viel Vorwissen vorhanden ist
    • Ein Kreis aus drei Schritten
      1. Recherche
      2. Schreiben
      3. Nacharbeitung
    • Kommentare des Editors einarbeiten
  • Beherrschst du die Technik schon vor dem Schreiben oder lernst du durch/für den Artikel?
    • Meist interessiere ich mich für das Thema und probiere es dann in meinen Artikeln anzuwenden.
    • Aber durch das Schreiben und das Feedback wird der Stoff noch einmal verinnerlicht
  • Welches Feedback hast du bislang zu deinen Artikeln (z.B. Functional FizzBuzz) bekommen?
    • Gemischt: Von den Leuten, die es gelesen haben, habe ich relativ viel Gutes gehört
    • Ich hatte aber auch recht harte Kritik.
    • Ich hätte bspw. nicht das richtige Verständnis von referrentieller Transparenz etc.
    • Man lernt nie aus. Wenn die Kritik wertneutral vorgetragen wird, dann nehme ich sie gerne an
    • Wichtig zwischen persönlicher und fachlicher Ebene zu unterscheiden
    • Manchmal fühle ich mich dennoch angegriffen
    • Da hilft Kaffee, 20 Minuten Pause oder Feierabend 🙂

Aus- und Weiterbildung

  • Bildest du selbst Entwickler-Nachwuchs aus und wenn ja, wie ist das Vorgehen?
    • Nein, ich bilde keinen Entwickler-Nachwus aus.
    • Ich war Mentor in einem Coder-Dojo für Kinder
    • Ich hatte mal Studenten, die bei mir im Projekt mitgearbeitet haben
    • Ich glaube Eigeninitiative ist wichtig
  • Was ist das letzte Fachbuch mit Bezug zur Programmierung, das du selbst gelesen hast?
    • Immer wieder: Functional Programming in Scala
    • Gerade dabei: Reactive Design Patterns von Roland Kuhn, Implementing Domain Driven Design von Vaughn Vernon
  • Was ist dein absolutes Lieblingsbuch mit Bezug zur IT/Programmierung und warum?
    • Functional Programming in Scala
    • Sehr ausführlich und umfangreich
    • Companion Booklet
    • Sehr gut geschrieben
  • Hast du Tipps zur Aus-/Weiterbildung für angehende Softwareentwickler/-innen?
    • Ich kann nur außerhalb der Ausbildung sprechen
    • Richtung finden, die einen interessiert
    • Evtl. Lernpfad aufbauen mit Lernziel und Stundenplan
    • Ausgleich ist sehr wichtig
    • Wenn der Kopf den ganzen Tag brennt, dann darf man auch gerne mal nichts in der Freizeit machen
    • Ich denke Lernen ist ein Teil des Berufs
    • Durch den Arbeitgeber gefördert werden und geordnet
  • Hast du Tipps für Ausbilder/-innen im IT-Bereich?
    • auf gleicher Augenhöhe zusammenarbeiten
    • Leading by Example ist sehr nett

Literaturempfehlungen

Gregor hat einen Haufen interessanter Bücher empfohlen, die ich bislang teilweise auch noch nicht kannte. Vielleicht ist ja auch etwas Spannendes für dich dabei!

Links

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

To create code blocks or other preformatted text, indent by four spaces:

    This will be displayed in a monospaced font. The first four 
    spaces will be stripped off, but all other whitespace
    will be preserved.
    
    Markdown is turned off in code blocks:
     [This is not a link](http://example.com)

To create not a block, but an inline code span, use backticks:

Here is some inline `code`.

For more help see http://daringfireball.net/projects/markdown/syntax