Modulbeschreibung

• Sie kennen die grundlegenden Konzepte des funktionalen Programmier-Paradigmas.

Vermittelte Kompetenz

• Sie lernen eine andere Sichtweise auf die Programmierung (funktional anstelle von OO)
• Sie können einfache Probleme mithilfe der Datentypanalyse-Funktionsanalyse Methode lösen.

• Programmier-Paradigmen
• Kennzeichen der funktionalen Programmierung und funktionaler Programmiersprachen
• Funktionen und Daten als gleichberechtigte Konstrukte; Immutability
• Funktionen höherer Ordnung (Funktionen als Parameter, Funktionen als Rückgabewerte, partielle Funktionen)
• Unendliche Datenstrukturen und Lazy Evaluation
• Kontrollstrukturen in funktionalen Programmiersprachen (Rekursion, Pattern Matching, u. ä.)
• Methodische Unterschiede zur OO und imperativem Projektabwicklung: EVA und Datentyp-basierte Spezifikation.

Schriftliche Prüfung am Kursblockende

• Interaktives Arbeiten in kleinen Gruppen (2-er Team) und Besprechungen im Plenum
• Gemischter Unterricht: aktives Arbeiten am eigenen Laptop (Übungen und Vorlesung werden gemischt).

• Folien, Skripts und Beispiellösungen, Kurzanleitungen, Arbeitsblätter und Lösungshinweise

Internetlinks:

• Haskell: https://www.haskell.org/
• Haskell Platform: https://www.haskell.org/platform/
• Einführung: https://wiki.haskell.org/Haskell_in_5_Schritte

Tools

• Java Interpreter (Java 8 und höher)
• Haskell Interpreter (GHC Haskell Platform; MacHaskell)
• Text-Editor: EMACS, VIM, Notepad++ oder Sublime Text mit Syntax highlighting

Die Studierenden erhalten einen groben Einblick in die wichtigsten Konzepte von C# und dem .NET Framework sowie die wesentlichsten Unterschiede zu Java.

Lernziele:

• Sie kennen die Grundkonzepte und die wichtigsten Funktionalitäten der .NET Plattform
• Sie verstehen Sprachkonzepte, Syntax und Vererbung in C# und können diese anwenden
• Sie verstehen die Unterschiede in der Syntax zu Java und können diese nachvollziehen
• Sie können einfache User Interfaces mit WPF erstellen

Grundlagen

• .NET Grunlagen
  Framework Architektur, CLR, MSIL, Assemblies, Typensystem CTS
• C# Grundlagen
  Namespaces, zentrale Klassen (Object, Array, String), Enums

Klassen, Structs und Vererbung

• Klassen und Structs
  Einführung, Methoden, Properties, Indexer, Konstruktoren, Operatoren
• Vererbung
  Einführung, Methoden und Vererbung, Abstrakte Klassen, Interfaces

Weiterführende Sprachkonzepte

• Delegates & Events
  Einführung, Multicast-Delegates, Hands-on Beispiele, Events, Anonyme Methoden 
• Generics
  Einführung, Type Constraints, Vererbung, Nullable Types, Generische Delegates
• Language Integrated Queries LINQ
  Lambda Expressions, Extension Methods, Initializers, Anonymous Types, Query Expressions

Vertiefung: GUI Programmierung

• WPF
• Einführung, XAML, Controls, Grund-Konzepte, Data Binding
   

Schriftliche Prüfung am Kursblockende

Vorlesung mit Übungsteil

Zur Verfügung gestelltes Folienskript inklusive ausführbarer Codebeispiele plus Übungen mit Musterlösung.

Literaturhinweise:

• C# in a Nutshell von Joseph & Ben Albahari / English
• C# kurz & gut von Joseph & Ben Albahari / Deutsche Übersetzung  = aktuellste C# Version

Links:

• Microsoft Developer Network / .NET Development (Offizielle Dokumentation) https://msdn.microsoft.com/library/ff361664(v=vs.110).aspx
• Microsoft Developer Network / C# programming guide (Offizielle Dokumentation) https://docs.microsoft.com/dotnet/csharp/programming-guide

Aktuellste Versionen dieser Tools:

• Visual Studio Community Edition
• Visual Studio Code
• SQL Server Express LocalDB

Es wird ein VMWare-Image mit diesen Tools zur Verfügung gestellt. Die Zip-Datei ist ca. 15GB gross, entpackt und ausgeführt muss mit 40GB – 45GB gerechnet werden.

• Die Konzepte der Nebenläufigkeit verstehen und in Java Programmen für Parallelisierung anwenden können.
• Die Korrektheitskriterien der Nebenläufigkeit kennen und typische Gefahren bei Multi-Threading vermeiden können.
• Verschiedene Implementierungstechniken für Nebenläufigkeit in Java kennen und anwenden können.

Vermittelte Kompetenzen:

• Multi-Thread Programmierung
• Monitor-Synchronisation und anderen Synchronisationsprimitiven
• Race Conditions, Data Races, Deadlocks und andere Nebenläufigkeitsfehler erkennen und vermeiden
• Effiziente Parallelisierung mit Thread Pools
• Asynchrone Programmierung im Allgemeinen und im GUI
• Java Memory Model und atomaren Instruktionen

• Grundlagen des Multi-Threading
• Monitor-Synchronisation
• Semaphore, Lock & Condition, Reader-Writer Locks und andere Synchronisationsprimitiven
• Korrektheitsbedingungen: Problematik von Race Conditions, Data Races, Deadlocks, Livelocks und Starvation
• Thread Pools, flache und rekursive Parallelisierung
• Asynchronität u.a. mit CompletableFutures
• Paralleles Stream API in Java
• GUI und Threading
• Java Memory Model: Atomare Instruktionen, volatile, lock-freie Datenstrukturen

Schriftliche Prüfung am Kursblockende

• Vorlesung begleitet mit praktischen Übungen
• Unterrichtsunterlagen
• Praktische Programmierübungen zur Anwendung und Vertiefung

• Erweiterte Kenntnisse der Programmiertechnologie Java.
• Grundkenntnisse der aspektorientierten Programmierung mit AspectJ.

Vermittelte Kompetenzen

• Die Teilnehmer sind in der Lage eigene Enumerationen, generische Klassen mit Bounds und Annotationen zu erstellen.
• Sie können Reflection, Schwache Referenzen, Streams und Lambdas anwenden.
• Sie verstehen das Konzept der aspektorientierten Programmierung.
• Sie können AspectJ für einfache Problemstellungen anwenden.
• Sie verstehen das Konzept von Design by Contract.
• Sie kennen das Java-Native-Interface JNI.

• Enumerationen
• Generics (Vererbung, Wildcards, Upper- und Lower-Bounds, Raw-Type, Erasure, Bridge-Methoden, Class-Sharing)
• Annotation (Default-Werte, Marker-Annotation, Arrays, Meta-Annotation, Targets, Self-Annotation, Retention, Package-Annotation, Annotation Processing Tool (apt) )
• Reflection (Class-Object, Type-Tokens, Instanzierung mittels Reflection, Class Inspection, Class Member Inspection, Attribute, Methoden)
• Erweiterungen Java8
• Soft-, Weak und Phantom-Referenzen (Resurrection, Schwache Referenzen, SoftReference, WeakReference, ReferenceQueue, PhantomReference, java.lang.Runtime)
• Single-Abstract-Method, Functional Interface, Method-Reference, Lambdas, Streams
• Aspekt-Orientierte Programmierung mit AspectJ (Cross-Cutting-Concerns, Seperation-Of-Concerns, AspectJ, Pointcut, Subtype Pattern, Advice, thisJoinPoint)
• Design by Contract
• Assertions
• Contracts for Java (C4J)
• Java Plattform Module System JPMS
• Java Native Interface JNI (Aufruf von Native-Code aus Java, Aufruf von Java aus Native-Code)
• Internationalization
• Logging (u. a. Log4J, Commons Logging)

Schriftliche Prüfung (open book), Dauer: 45 Minuten

An den Unterrichtsabenden jeweils zuerst ein Block Frontalunterricht und daraufhin ein begleiteter Übungsblock im Vorlesungsraum.

• Eigenes Script

Weitere Literaturhinweise:

• Joshua Bloch, Effective Java, Verlag:  Addison-Wesley
• Ken Arnold, James Gosling, David Holmes, The Java Programming Language, Verlag: Addison-Wesley
• Johannes Nowak, Fortgeschrittene Programmierung mit Java 5, Verlag: Dpunkt
• Raoul-GabrielUrma, Mario Fusco, Alan Mycroft, Java 8 in Action, Verlag: Manning
• Richard Jones, Rafael Lins, Garbage Collection. Algorithms for Automatic Dynamic Memory Management, Verlag: Wiley & Sons
• Russ Miles, AspectJ Cookbook , Verlag: O'Reilly
• Adrian Colyer, Andy Clement, George Harley, Matthew Webster, eclipse AspectJ, Aspect-Oriented Programming with AspectJ and the Eclipse AspectJ Development Tools, Verlag: Addison Wesley
• Bertrand Meyer, Design by Contract: The Component Revolution, Object & component technology series, Verlag: Prentice Hall
• Richard Mitchell, Jim McKim, Design by Contract, by Example, Verlag: Addison-Wesley

Internetlinks:

• http://www.java.com
• http://www.eclipse.org/aspectj

Tools:

• Eclipse und Java-JDK
• Eclipse-PlugIn für AspectJ:
• http://www.eclipse.org/aspectj