Training

3-day practical training course

Firebird SQL and Pascal programming for the next generation

From basic developer knowledge to productive involvement in real-world Delphi, Lazarus, Firebird and IBExpert projects.

- 16 -18 November 2026 – Munich – 3 days, 9.00 am–5.00 pm – German language -

This 3-day hands-on training course can also be booked as a remote or on-site in-house training course.

The focus of this course

Practical knowledge for getting started with established software projects

Basic programming skills are often not enough to start working productively on an existing enterprise application straight away. Project files, units, forms, components, packages, events, database access and SQL objects must be understood as an integrated system.

This training course provides precisely this orientation and practical knowledge. Participants will build a small application using Lazarus, create the associated Firebird database and programme the connection between the two using IBExpert.

“The best programming language at the moment is German.”
It is crucial to formulate requirements in full and to carry out a technical review of the results produced.

Target group

For the next generation of developers

Not a retrospective look at old development environments, but a practical introduction for people who will be working productively on existing systems in the future. No practical experience with Delphi, Lazarus, Firebird or IBExpert is required.

Suitable for

Apprentices, students and those starting their careers with basic programming skills
People changing careers who will be working on Delphi, Lazarus or Firebird projects in future
Junior developers with no practical experience of larger, established applications
Companies wishing to integrate junior staff into existing projects more quickly and in a more structured manner

Recommended Requirements

A basic understanding of variables, conditions, loops and simple programme flows
Bringing your own Windows laptop is recommended; detailed software requirements will be provided prior to the course
A willingness not only to generate source code and SQL, but also to read and check it systematically

Course objectives

What participants should be able to accomplish after three days

find their way around an existing Delphi or Lazarus project
read and write basic Object Pascal code
build a simple graphical or console-based application
understand the structure of a Firebird database
create and analyse SQL and PSQL code using IBExpert
connect a Lazarus application to a Firebird database
take on small, clearly defined tasks within an existing project
critically review AI-generated code and reuse it appropriately

Benefits for employers

faster induction of new staff into existing projects
a shared basic understanding of the application, database and development tools
less uncontrolled copy-and-paste code from AI systems
better modularity and more clearly defined tasks for junior developers
practical preparation for real-world maintenance, extension and analysis tasks

Key information

The event at a glance

Date: 16–18 November 2026

Location: Munich

Duration: 3 days, 9.00 am – 5.00 pm

Language: German

Day 1

Understanding the Pascal world
Project structure, language, components, events and launching your own Lazarus application.

Day 2

Firebird SQL, PSQL and IBExpert
Data model, SQL, database programming and connecting the application to Firebird.

Day 3

Interaction, modularity and AI
Clean application structure, practical AI support and verifying generated results.

Training programme

Three days focusing on a single, continuous practical project

Participants do not learn about the individual components in isolation, but instead combine Pascal code, the user interface, the Firebird database and IBExpert step by step to create a small, fully functional application.

The ongoing practical project: a time and attendance system

Over the course of the three training days, a practical time and attendance system will be developed step by step:

Day 1: Development of a basic Lazarus GUI for recording arrival and departure times. Initially, the data is deliberately stored in plain text files.
Day 2: Transferring the recorded data into a newly created Firebird database. This involves creating tables, SQL queries and triggers. The triggers also transfer the relevant information to existing tables within an existing software solution.
Day 3:
Conversion of the Lazarus application into a minimal PHP-based terminal application that writes directly to Firebird, with AI support. This can be used in kiosk mode on iPads and later operated via NFC cards.

In this way, participants learn, through a coherent example, the journey from a simple local prototype, through database integration, to a modular, cross-platform application.

Day 1

Understanding the Pascal World

Project structure, the language, components, events and launching your own Lazarus application.

Morning: How is a Delphi or Lazarus project constructed?

Project orientation

What are Pascal, Object Pascal, Delphi and Lazarus?
Similarities and differences between Delphi and Lazarus
Project structure
Meaning of typical file formats: .dpr, .lpr, .pas, .dfm and .lfm
Other project, resource and configuration files
What happens during compilation?
From source code to executable file
Understanding compiler errors, warnings and notes

Basic structure of a Pascal unit

unit, program and library
interface and implementation
uses and dependencies
Declaration and visibility
Local and global elements
Initialisation and finalisation
Namespaces and name conflicts

Afternoon: Language, Components and Events

Basic language elements

Constants and variables
Data types
Enumerations, sets and records
Arrays, lists and strings
Procedures and functions
Parameters and return values
Scopes
Classes, objects, methods and properties
Creating and releasing objects
Basic error handling with exceptions

Graphical applications

Forms and controls
Properties, methods and events
Visual and non-visual components
Event handling, for example OnClick, OnCreate and OnClose
Relationship between the form and its associated unit
Packages and reusable components
Difference between GUI and console applications

Practical project

Creating a new Lazarus project
Designing the main form
Adding input fields and buttons
Implementing events
Checking and processing data
Extracting the first functions into separate units

Today's outcome: Participants will be able to explain the structure of a Pascal project, read basic Object Pascal code and create a small application with their own events, procedures and functions.

Day 2

Firebird SQL, PSQL and IBExpert

Data model, SQL, database programming and connecting the application to Firebird.

Morning: Structure and language of a Firebird database

Fundamentals of relational databases

Tables, records, columns and data types
The difference between data and metadata
Primary keys and foreign keys
Relationships between tables
NULL and its special characteristics
Domains, sequences and generators
Constraints and indexes
Views as stored perspectives on data

SQL basics

DDL: CREATE, ALTER, DROP, RECREATE and CREATE OR ALTER
DML: SELECT, INSERT, UPDATE and DELETE
Conditions using WHERE
Sorting using ORDER BY
Grouping and aggregate functions
Joins using JOIN
Parameters instead of compound SQL strings
Transactions, COMMIT and ROLLBACK

Afternoon: Programming in the database

Firebird PSQL

Structure of a PSQL module
Variables and parameters
BEGIN and END
Conditions and loops
Stored procedures and stored functions
Triggers and exceptions
Executable and selectable procedures
Demarcation: What belongs in the database and what belongs in the application?

Working with IBExpert

Registering and opening a database
Navigating the Database Explorer
Editing tables and other metadata objects
Using the SQL Editor
Executing queries and checking results
Creating SQL scripts
Identifying dependencies between objects
Testing procedures and triggers
Locating errors and interpreting error messages correctly

Connection to the Lazarus application

Establishing a database connection
Connection, Transaction and Query components
Executing SQL queries from the application
Passing parameters
Reading, inserting and modifying data
Committing transactions correctly
Handling database errors in the application

Expanding the practical project

Creating a Firebird database for the example application
Defining tables and relationships
Storing, displaying, modifying and deleting records
Implementing simple business rules

Today's outcome: Participants will understand the basic structure of a Firebird database, be able to create simple SQL and PSQL objects, and connect a Lazarus application to the database.

Day 3

Interaction, modularity and AI

A clear application structure, practical AI support and the verification of generated results.

Morning: Creating an application from individual components

Structure of a database-driven application

User interface, programme logic, database access and database logic
Clearly separating responsibilities
Why the entire code should not be contained within a single form
Dedicated units for distinct tasks
Reusable functions and classes
Centralised error handling and logging
Configuration rather than hard-coded values

Modularity in practice

Small, clearly defined modules
Unambiguous inputs and outputs
As few hidden dependencies as possible
Descriptive names and traceable structures
Limit changes to a restricted area
Extend existing code without unintentionally altering other behaviour
The difference between ‘works for now’ and ‘is maintainable’

GUI and console applications

when a graphical user interface is appropriate
when a console programme is the better solution
Automation of routine tasks
Shared business logic for different types of programme
Separation of the user interface from the actual processing

Afternoon: AI as a Development Tool

The best programming language is German

Describe the goal, starting point, and framework
List the versions and technologies used
Clearly define inputs and outputs
Take special cases and error cases into account
Provide existing code in its entirety and without modification
Specify concrete rules for changes
Break down large tasks into verifiable sub-steps

Useful Applications of AI

Explain existing code and analyze unknown units
Prepare routine code and SQL queries
Generate test data and test cases
Analyze error messages
Document and modularize code
Compare variants

Limitations and Risks

Code that sounds plausible but is incorrect
Fictitious functions, classes, or components
Solutions that do not match the version in use
Missing error handling and insecure SQL constructs
Resource and memory issues
Unintended changes to existing behavior
Disclosure of confidential data or source code
Adoption of code that no one on the team can explain

Functional testing of AI results

Does the code actually fulfil the requirements?
Can it be compiled with the intended version?
Are all the functions used actually available?
Are error cases handled?
Do transactions and resources remain in a defined state?
Is the code understandable and modular?
Can components be tested independently?
Have existing functions been unintentionally altered?
Do SQL statements match the data model?

Final project

Display existing data
Create and modify new records
Validate inputs and handle database errors
Extract programme logic into separate modules
Prepare a small additional function using AI
Jointly analyse and correct the generated code

Today's outcome: Participants will understand the interplay between the user interface, Pascal code, database access and the Firebird database. They will be able to use AI tools as a support without relinquishing responsibility for functionality, security and maintainability to the AI.

AI in Development

Accelerating progress without relinquishing control

ChatGPT, Codex and similar tools can explain source code, prepare routines, generate SQL, develop test cases and assist with debugging. However, they are no substitute for technical understanding or systematic testing. This training course therefore not only demonstrates how AI is used, but above all how requirements are formulated, results are broken down, compiled, tested and examined for unintended side effects.

Why modularity is becoming increasingly important

Small, clearly defined, and independently testable modules can be developed more reliably with AI support than large, complex blocks of source code.

clear inputs and outputs
few hidden dependencies
limited scope of changes
individually testable functions
transparent responsibilities

After the Course

Participants will be able to contribute practically rather than just knowing the basics

Identify the most important project components
Understand the basic program flow
Make simple changes to forms and units
Read and create SQL queries
Examine database objects using IBExpert
Implement small functions on your own
Systematically narrow down errors
Work on clearly defined tasks with the support of AI
Critically test the generated results
Contribute effectively to an experienced development team

Interested in the course?

Training Course: Firebird SQL and Pascal Programming for the Next Generation
Date: November 16 -18, 2026, 9.00 am–5.00 pm
Price per participant: 1,490.00 EUR (plus VAT)
For the second and subsequent participants billed to the same invoice recipient: 1,290.00 EUR per participant (plus VAT)
Venue: TBK Patent Attorneys, Bavariaring 4–6, 80336 Munich, Germany
Contact and registration via email: register@ibexpert.biz

This 3-day hands-on training course can also be booked as a remote or on-site in-house training session, in which we will use your existing software and database as a basis.

(English-language version above)

3-tägige Praxisschulung

Firebird SQL und Pascalprogrammierung für die Next Generation

Vom grundlegenden Entwicklerwissen zur produktiven Mitarbeit in realen Delphi-, Lazarus-, Firebird- und IBExpert-Projekten.

- 16.-18. November 2026 - München - 3 Tage 9.00-17.00 Uhr - Deutsch -

Diese 3-tägige Praxisschulung kann auch als Remote- oder Onsite-Firmenschulung gebucht werden.

Worum es geht

Praxiswissen für den Einstieg in gewachsene Softwareprojekte

Grundlegende Programmierkenntnisse reichen oft nicht aus, um in einer bestehenden Unternehmensanwendung sofort produktiv mitzuarbeiten. Projektdateien, Units, Formulare, Komponenten, Packages, Ereignisse, Datenbankzugriffe und SQL-Objekte müssen als zusammenhängendes System verstanden werden.

Diese Schulung vermittelt genau dieses Orientierungs- und Praxiswissen. Die Teilnehmer bauen mit Lazarus eine kleine Anwendung auf, erstellen die zugehörige Firebird-Datenbank und programmieren die Verbindung zwischen beiden Welten mit Unterstützung von IBExpert.

„Die beste Programmiersprache ist aktuell Deutsch.“
Entscheidend ist, Anforderungen vollständig zu formulieren und die erzeugten Ergebnisse fachlich zu prüfen.

Zielgruppe

Für die nächste Entwicklergeneration

Nicht als Rückblick auf alte Entwicklungswelten, sondern als praxisnaher Einstieg für Menschen, die künftig produktiv an bestehenden Systemen mitarbeiten sollen. Keine praktische Erfahrung mit Delphi, Lazarus, Firebird oder IBExpert erforderlich.

Geeignet für

Auszubildende, Studierende und Berufseinsteiger mit grundlegenden Programmierkenntnissen
Quereinsteiger, die künftig an Delphi-, Lazarus- oder Firebird-Projekten mitarbeiten sollen
Junior-Entwickler ohne praktische Erfahrung in größeren, gewachsenen Anwendungen
Unternehmen, die Nachwuchskräfte schneller und strukturierter in bestehende Projekte einarbeiten möchten

Empfohlene Voraussetzungen

Grundverständnis für Variablen, Bedingungen, Schleifen und einfache Programmabläufe
eigener Windows-Notebook-PC empfohlen; genaue Software-Vorbereitung folgt vor der Schulung
Bereitschaft, Quellcode und SQL nicht nur zu erzeugen, sondern systematisch zu lesen und zu prüfen

Lernziele

Was die Teilnehmer nach drei Tagen können sollen

sich in einem bestehenden Delphi- oder Lazarus-Projekt orientieren
grundlegenden Object-Pascal-Code lesen und selbst erstellen
eine einfache grafische oder konsolenbasierte Anwendung aufbauen
die Struktur einer Firebird-Datenbank verstehen
SQL- und PSQL-Code mit IBExpert erstellen und analysieren
eine Lazarus-Anwendung mit einer Firebird-Datenbank verbinden
kleinere, klar abgegrenzte Aufgaben in einem bestehenden Projekt übernehmen
KI-generierten Code kritisch prüfen und sinnvoll weiterverwenden

Nutzen für Arbeitgeber

schnellere Orientierung neuer Mitarbeiter in bestehenden Projekten
ein gemeinsames Grundverständnis für Anwendung, Datenbank und Entwicklungswerkzeuge
weniger unkontrollierter Copy-and-paste-Code aus KI-Systemen
bessere Modularität und klarer abgegrenzte Aufgaben für Junior-Entwickler
praxisnahe Vorbereitung auf reale Wartungs-, Erweiterungs- und Analyseaufgaben

Rahmendaten

Die Veranstaltung auf einen Blick

Termin 16.-18. November 2026

Ort München

Dauer 3 Tage von 9.00 - 17.00 Uhr

Sprache Deutsch

Tag 1
Die Pascal-Welt verstehen
Projektaufbau, Sprache, Komponenten, Ereignisse und der Start einer eigenen Lazarus-Anwendung.

Tag 2
Firebird SQL, PSQL und IBExpert
Datenmodell, SQL, Datenbankprogrammierung und die Verbindung der Anwendung mit Firebird.

Tag 3
Zusammenspiel, Modularität und KI
Saubere Anwendungsstruktur, sinnvolle KI-Unterstützung und die Prüfung generierter Ergebnisse.

Schulungsprogramm

Drei Tage mit einem durchgehenden Praxisprojekt

Die Teilnehmer lernen die Einzelteile nicht isoliert kennen, sondern verbinden Pascal-Code, Benutzeroberfläche, Firebird-Datenbank und IBExpert Schritt für Schritt zu einer kleinen, funktionsfähigen Anwendung.

Das durchgehende Praxisprojekt: eine Arbeitszeiterfassung

Über alle drei Schulungstage entsteht schrittweise eine praxisnahe Arbeitszeiterfassung:

Tag 1: Entwicklung einer minimalen Lazarus-GUI zur Erfassung von Kommen- und Gehen-Zeiten. Die Daten werden zunächst bewusst einfach in Textdateien gespeichert.
Tag 2: Übernahme der erfassten Daten in eine neu aufgebaute Firebird-Datenbank. Dabei werden Tabellen, SQL-Abfragen und Trigger erstellt. Die Trigger übertragen die relevanten Informationen zusätzlich in bereits vorhandene Tabellen einer bestehenden Softwarelösung.
Tag 3: Übertragung der Lazarus-Anwendung in eine minimale PHP-basierte Terminalanwendung, de direkt in Firebird schreibt, mit Unterstützung von KI. Diese kann im Kioskmodus auf iPads eingesetzt und später über NFC-Karten bedient werden.

So lernen die Teilnehmer an einem zusammenhängenden Beispiel den Weg vom einfachen lokalen Prototyp über die Datenbankintegration bis zur modularen, plattformübergreifenden Anwendung kennen.

Tag 1

Die Pascal-Welt verstehen

Projektaufbau, Sprache, Komponenten, Ereignisse und der Start einer eigenen Lazarus-Anwendung.

Vormittag: Wie ist ein Delphi- oder Lazarus-Projekt aufgebaut?

Orientierung im Projekt

Was ist Pascal, Object Pascal, Delphi und Lazarus?
Gemeinsamkeiten und Unterschiede zwischen Delphi und Lazarus
Aufbau eines Projekts
Bedeutung typischer Dateiformate: .dpr, .lpr, .pas, .dfm und .lfm
weitere Projekt-, Ressourcen- und Konfigurationsdateien
Was passiert beim Kompilieren?
Vom Quellcode zur ausführbaren Datei
Compilerfehler, Warnungen und Hinweise verstehen

Grundstruktur einer Pascal-Unit

unit, program und library
interface und implementation
uses und Abhängigkeiten
Deklaration und Sichtbarkeit
lokale und globale Elemente
Initialisierung und Finalisierung
Namensräume und Namenskonflikte

Nachmittag: Sprache, Komponenten und Ereignisse

Grundlegende Sprachelemente

Konstanten und Variablen
Datentypen
Aufzählungen, Mengen und Records
Arrays, Listen und Strings
Prozeduren und Funktionen
Parameter und Rückgabewerte
Gültigkeitsbereiche
Klassen, Objekte, Methoden und Eigenschaften
Erzeugen und Freigeben von Objekten
grundlegende Fehlerbehandlung mit Exceptions

Grafische Anwendungen

Formulare und Steuerelemente
Eigenschaften, Methoden und Ereignisse
visuelle und nicht visuelle Komponenten
Ereignisbehandlung, zum Beispiel OnClick, OnCreate und OnClose
Zusammenhang zwischen Formular und zugehöriger Unit
Packages und wiederverwendbare Komponenten
Unterschied zwischen GUI- und Konsolenanwendung

Praxisprojekt

neues Lazarus-Projekt anlegen
Hauptformular gestalten
Eingabefelder und Schaltflächen hinzufügen
Ereignisse implementieren
Daten prüfen und verarbeiten
erste Funktionen in eigene Units auslagern

Ergebnis des Tages: Die Teilnehmer können den Aufbau eines Pascal-Projekts erklären, grundlegenden Object-Pascal-Code lesen und eine kleine Anwendung mit eigenen Ereignissen, Prozeduren und Funktionen erstellen.

Tag 2

Firebird SQL, PSQL und IBExpert

Datenmodell, SQL, Datenbankprogrammierung und die Verbindung der Anwendung mit Firebird.

Vormittag: Aufbau und Sprache einer Firebird-Datenbank

Grundlagen relationaler Datenbanken

Tabellen, Datensätze, Spalten und Datentypen
Unterschied zwischen Daten und Metadaten
Primärschlüssel und Fremdschlüssel
Beziehungen zwischen Tabellen
NULL und seine Besonderheiten
Domains, Sequences beziehungsweise Generatoren
Constraints und Indizes
Views als gespeicherte Sicht auf Daten

SQL-Grundlagen

DDL: CREATE, ALTER, DROP, RECREATE und CREATE OR ALTER
DML: SELECT, INSERT, UPDATE und DELETE
Bedingungen mit WHERE
Sortierung mit ORDER BY
Gruppierung und Aggregatfunktionen
Verknüpfungen mit JOIN
Parameter statt zusammengesetzter SQL-Strings
Transaktionen, COMMIT und ROLLBACK

Nachmittag: Programmierung in der Datenbank

Firebird PSQL

Aufbau eines PSQL-Moduls
Variablen und Parameter
BEGIN und END
Bedingungen und Schleifen
Stored Procedures und Stored Functions
Trigger und Exceptions
ausführbare und auswählbare Prozeduren
Abgrenzung: Was gehört in die Datenbank und was in die Anwendung?

Arbeiten mit IBExpert

Datenbank registrieren und öffnen
Orientierung im Database Explorer
Tabellen und andere Metadatenobjekte bearbeiten
SQL Editor verwenden
Abfragen ausführen und Ergebnisse kontrollieren
SQL-Skripte erstellen
Abhängigkeiten zwischen Objekten erkennen
Prozeduren und Trigger testen
Fehler lokalisieren und Meldungen richtig lesen

Verbindung zur Lazarus-Anwendung

Datenbankverbindung aufbauen
Connection-, Transaction- und Query-Komponenten
SQL-Abfragen aus der Anwendung ausführen
Parameter übergeben
Daten lesen, einfügen und verändern
Transaktionen korrekt abschließen
Datenbankfehler in der Anwendung behandeln

Erweiterung des Praxisprojekts

Firebird-Datenbank für die Beispielanwendung erstellen
Tabellen und Beziehungen definieren
Datensätze speichern, anzeigen, verändern und löschen
einfache fachliche Regeln umsetzen

Ergebnis des Tages: Die Teilnehmer verstehen die Grundstruktur einer Firebird-Datenbank, können einfache SQL- und PSQL-Objekte erstellen und eine Lazarus-Anwendung mit der Datenbank verbinden.

Tag 3

Zusammenspiel, Modularität und KI

Saubere Anwendungsstruktur, sinnvolle KI-Unterstützung und die Prüfung generierter Ergebnisse.

Vormittag: Aus Einzelteilen wird eine Anwendung

Struktur einer datenbankgestützten Anwendung

Benutzeroberfläche, Programmlogik, Datenbankzugriff und Datenbanklogik
Verantwortlichkeiten klar voneinander trennen
warum nicht der gesamte Code in ein Formular gehört
eigene Units für abgegrenzte Aufgaben
wiederverwendbare Funktionen und Klassen
zentrale Fehlerbehandlung und Logging
Konfiguration statt fest eingebauter Werte

Modularität in der Praxis

kleine, klar definierte Module
eindeutige Ein- und Ausgaben
möglichst wenige versteckte Abhängigkeiten
sprechende Namen und nachvollziehbare Strukturen
Änderungen auf einen begrenzten Bereich beschränken
bestehenden Code erweitern, ohne anderes Verhalten unbeabsichtigt zu verändern
Unterschied zwischen „funktioniert gerade“ und „ist wartbar“

GUI- und Konsolenanwendungen

wann eine grafische Oberfläche sinnvoll ist
wann ein Konsolenprogramm die bessere Lösung ist
Automatisierung von Routineaufgaben
gemeinsame Fachlogik für unterschiedliche Programmarten
Trennung von Bedienoberfläche und eigentlicher Verarbeitung

Nachmittag: KI als Entwicklungswerkzeug

Die beste Programmiersprache ist Deutsch

Ziel, Ausgangslage und Rahmenbedingungen beschreiben
verwendete Versionen und Technologien nennen
Ein- und Ausgaben eindeutig festlegen
Sonderfälle und Fehlerfälle berücksichtigen
vorhandenen Code vollständig und unverändert bereitstellen
konkrete Regeln für Änderungen vorgeben
große Aufgaben in überprüfbare Teilschritte zerlegen

Sinnvolle Einsatzbereiche von KI

bestehenden Code erklären und unbekannte Units erschließen
Routinecode und SQL-Abfragen vorbereiten
Testdaten und Testfälle erzeugen
Fehlermeldungen analysieren
Code dokumentieren und modularisieren
Varianten vergleichen

Grenzen und Gefahren

plausibel klingender, aber falscher Code
erfundene Funktionen, Klassen oder Komponenten
nicht zur eingesetzten Version passende Lösungen
fehlende Fehlerbehandlung und unsichere SQL-Konstruktionen
Ressourcen- und Speicherprobleme
unbeabsichtigte Änderungen an bestehendem Verhalten
Preisgabe vertraulicher Daten oder Quelltexte
Übernahme von Code, den niemand im Team erklären kann

KI-Ergebnisse funktional prüfen

Erfüllt der Code wirklich die Aufgabenstellung?
Lässt er sich mit der vorgesehenen Version kompilieren?
Sind alle verwendeten Funktionen tatsächlich verfügbar?
Werden Fehlerfälle behandelt?
Bleiben Transaktionen und Ressourcen in einem definierten Zustand?
Ist der Code verständlich und modular?
Können Bestandteile unabhängig getestet werden?
Wurden bestehende Funktionen unbeabsichtigt verändert?
Stimmen SQL-Anweisungen mit dem Datenmodell überein?

Abschlussprojekt

bestehende Daten anzeigen
neue Datensätze erfassen und verändern
Eingaben validieren und Datenbankfehler behandeln
Programmlogik in eigene Module auslagern
eine kleine Zusatzfunktion mithilfe einer KI vorbereiten
den generierten Code gemeinsam analysieren und korrigieren

Ergebnis des Tages: Die Teilnehmer verstehen das Zusammenspiel von Benutzeroberfläche, Pascal-Code, Datenbankzugriff und Firebird-Datenbank. Sie können KI-Werkzeuge als Unterstützung einsetzen, ohne die Verantwortung für Funktion, Sicherheit und Wartbarkeit an die KI abzugeben.

KI in der Entwicklung

Beschleunigen, ohne die Kontrolle abzugeben

ChatGPT, Codex und ähnliche Werkzeuge können Quellcode erklären, Routinen vorbereiten, SQL erzeugen, Testfälle entwickeln und bei der Fehlersuche helfen. Sie ersetzen jedoch weder fachliches Verständnis noch systematische Prüfung.Die Schulung zeigt deshalb nicht nur, wie KI eingesetzt wird, sondern vor allem, wie Anforderungen formuliert, Ergebnisse zerlegt, kompiliert, getestet und auf unbeabsichtigte Nebenwirkungen untersucht werden.

Warum Modularität wichtiger wird

Kleine, klar definierte und unabhängig prüfbare Module lassen sich zuverlässiger mit KI-Unterstützung entwickeln als große, unübersichtliche Quellcodeblöcke.

klare Ein- und Ausgaben
wenige versteckte Abhängigkeiten
begrenzte Änderungsbereiche
einzeln testbare Funktionen
nachvollziehbare Verantwortlichkeiten

Nach der Schulung

Praxisfähig mitarbeiten statt nur Grundlagen kennen

die wichtigsten Projektbestandteile identifizieren
den grundsätzlichen Programmablauf nachvollziehen
einfache Änderungen an Formularen und Units durchführen
SQL-Abfragen lesen und erstellen
Datenbankobjekte mit IBExpert untersuchen
kleine Funktionen selbst implementieren
Fehler systematisch eingrenzen
klar definierte Aufgaben mit Unterstützung einer KI bearbeiten
die erzeugten Ergebnisse kritisch testen
sinnvoll in einem erfahrenen Entwicklungsteam mitarbeiten

Interesse an der Schulung?

Schulung: Firebird SQL und Pascalprogrammierung für die Next Generation
Zeitraum: 16.-18. November 2026, 9.00 - 17.00 Uhr
Preis pro Teilnehmer: Preis pro Teilnehmer: 1.490,00 EUR (zzgl. MwSt.)
Ab dem 2. Teilnehmer bei demselben Rechnungsempfänger: 1.290,00 EUR pro Teilnehmer (zzgl. MwSt.)

Veranstaltungsort: TBK Patentanwälte, Bavariaring 4-6, 80336 München
Kontakt und Anmeldung per E-Mail: register@ibexpert.biz

Diese 3-tägige Praxisschulung kann auch als Remote- oder Onsite-Firmenschulung, in der wir dann Ihre schon existierende Software und Datenbank als Basis nehmen, gebucht werden.