Programm Delphi Code Camp

Programm Delphi Code Camp
Das Trainingsevent für Delphi-Entwickler
22. - 24. April 2024 | Düsseldorf

Anforderungen:

Alle Workshops setzen einen sicheren Umgang mit Delphi und Kenntnisse objektorientierter Entwicklung voraus.
Es handelt sich um einen Praxisworkshop! Um die Beispiele und Übungen nachzuvollziehen und durchzuführen benötigen Sie ein Laptop mit aktuellem Windows 10 oder 11 und optimalerweise Delphi mit installierter Linux Personality. Für einige Beispiele ist eine höhere Delphi-Version erforderlich (APL ab Delphi XE8).

Die Workshops des Camps

Tag 1: Multithreading und Parallel Programming mit Delphi

 

Aktuelle Rechner bieten Hyperthreading und Multicore-CPUs oder gleich mehrere Prozessoren. Programme mit mehreren Threads können diese Hardware besser ausnutzen. Daneben erwarten User ebenso wie die Richtlinien aktueller Betriebssysteme ein „Responsive UI“, unabhängig davon, was die Anwendung tut. Lange Datenbankabfragen oder die Nutzung von Cloud-Diensten im Hintergrund dürfen eine Anwendung nicht mehr blockieren. Mit Threads und dem zusätzlichen Parallel-Programming-Library-(PPL-)Framework bietet Delphi einiges an Bordmitteln, um das zu realisieren.

Allerdings erhöhen Threads und Tasks auch die Komplexität von Programmen und bieten bei falscher Verwendung genügend Fallstricke, die für Deadlocks oder Abstürze sorgen können.

Der Workshop gibt eine Einführung in die Verwendung der Thread-Klassen von Delphi und das Design von Threads. Sie lernen die verschiedenen Synchronisationselemente wie Critical Sections, Mutexes, Events und Semaphoren ebenso kennen wie Delphis Hilfsklassen von TMonitor bis TThreadedQueue.  Sie lernen die Tasks, Futures und den Threadpool der PPL kennen. Wir stellen Tasks und Threads gegenüber und schauen uns an, wie beide effektiv verwendet werden, um ein reaktives UI mit Threads und/oder Tasks realisieren zu können. Ein Blick auf das das Exception Handling bei Threads und Tasks und ein Blick auf asynchrone Aufrufe in TComponent runden die Themen ab.

Agenda

  • Einführung in Multithreading
  • Thread-Klasse in Delphi
  • Synchronisationsobjekte und Hilfsklassen
  • Delphi Parallel Programming Library (PPL)
  • Tasks und Futures versus Threads
  • Responsive UI realisieren
  • Exception Handling bei Threads und Tasks
  • Asynchrone Calls in Komponenten

Tag 2: Delphi Language Update

Im Laufe der letzten Jahre ist die Delphi Programmiersprache und Laufzeitbibliothek unter dem Einfluss von .net und Cross-Platform-Support auch für native Entwicklung signifikant weiterentwickelt worden. Unzählige neue Compiler-Features wie Enumeratoren, Klassendaten, verschachtelte Typen, Class und Typehelper, generische Typen, anonyme Methoden stehen in Delphi zu Verfügung. Die auf LLVM basierende Compilergeneration für mobile Geräte und nicht-Windows Plattformen führt neue Konzepte wie Attribute ein und brachten teilweise neue Datentypen mit sich.

Records können Methoden enthalten und unterstützen überladbare Operatoren und mit Managed Records kann auch das Memory Management für Records geändert werden. Der String-Typ ist zu Unicode gewechselt, das Exceptionhandling und die RTTI-Funktionen wurden erweitert und die Laufzeitbibliothek um diverse neue Klassen ergänzt.

Anonyme Methoden, generische Typen oder auch die vor kurzem hinzu gekommenen inline-Variablen haben das Sprachbild erweitert und verändert.

Mit den neuen Sprachfeatures schließt Delphi zu den Möglichkeiten auf, die andere verbreitete Sprachen und Frameworks bieten. Der Workshop gibt einen Überblick über diese neuen Sprachfeatures seit Delphi 2007, zeigt wie diese eingesetzt werden und an welchen Stellen man das, was man in alten Delphi Versionen schon immer so gemacht hat, jetzt vielleicht effektiver und eleganter lösen kann und sollte.

Die Themen im Überblick

  • Enumeratoren, Class Helper, Nested Types und Klassendaten
  • Generische Typen und anonyme Methoden
  • Inline Variablen und Array-Methoden
  • Records und überladbare Operatoren, Managed Records
  • Memory Management bei Interfaces, Compilerattribute
  • Unicode Strings
  • Erweiterte RTTI-Funktionen seit Delphi 2010
  • Neue Typen , 64bit Support
  • Wichtige RTL-Features von TObject und Exception bis zu TThread und System.JSON

 

Tag 3: Softwaresanierung und Refactoring

 

Software, die längere Zeit weiterentwickelt wird, kann leicht zum Sanierungsfall werden, wenn bei Erweiterungen und Anpassungen Refactorings unterbleiben. Irgendwann wird es dann schwierig und zeitaufwendig Änderungen in kurzer Zeit umzusetzen oder überhaupt ohne Seiteneffekte vorzunehmen ? RAD-Systeme wie Delphi verleiten zudem dazu, Konzepte wie die Schichtentrennung außen vor zu lassen und Business-Code bunt gemischt mit GUI-Code in verschiedenste Ereignishandler zu verstreuen. Das Ergebnis ist ein System, dessen Abhängigkeiten Tests extrem erschweren oder gar unmöglich machen und dessen Reaktion auf Änderungen nur schlecht abgeschätzt werden können.

Es gibt nicht das „eine“ Rezept, um im Handumdrehen aus jedem System, das durch Änderungen aus dem Ruder gelaufen ist oder noch nie testbar war, eine testbare und damit wartbare Anwendung zu machen. Aber es gibt sehr wohl hilfreiche Prinzipien, die bei Refactorings beachtet werden sollten und es gibt Rezepte und Vorgehensmuster, wie Sie Code Schritt für Schritt testbar machen, die unterschiedlichsten Abhängigkeiten auflösen und Klassen entkoppeln können.

Der Workshop beginnt mit einem Überblick über die Grundlagen testbaren und wartbaren Codes, den SOLID-Prinzipien und Unittests sowie Patterns und Anti-Patterns, insbesondere für die Entkopplung von Code. An einer kleinen RAD-Beispielanwendung wird dann im Laufe des Workshops gezeigt, wie Refactorings eingesetzt werden, um den Code sukzessive testbar zu machen. In Demos werden Wege und Methoden erarbeitet, um Code durch Anwendung von OOP-Konzepten und Design Patterns zu strukturieren. Es werden verschiedene Wege gezeigt Abhängigkeiten zwischen Klassen oder von globalen Variablen aufzuheben oder temporär zu kapseln und testbar zu machen. So können mit den Praxistipps und Rezepten aus dem Workshop letztendlich auch Änderungen an Legacy Systemen so vorgenommen werden, dass diese Erweiterungen testbar sind.

Themen

  • SOLID-Prinzipien
  • Patterns und Anti-Patterns
  • Unittests, Mocks und Dummies
  • Probleme finden – von Code Smells zu Metriken
  • Einfache Refactorings
  • Refactorings in Delphi und MMX
  • Refactorings planen und durchführen
  • Design for Testability
  • Refactoring von nicht-testbaren Klassen
  • RAD/Legacy Code testbar erweitern
  • Design Patterns für testbaren Code

ZEITLICHER ABLAUF

 
Montag bis Mittwoch:
  • 8:00 Uhr – Check-in
  • 9:00 Uhr – Beginn der Veranstaltung
  • 10:30 Uhr – Kaffeepause
  • 12:30 Uhr – Mittagspause
  • 15:00 Uhr – Kaffeepause
  • 17:00 Uhr – Ende der Veranstaltung