• Konfiguration durch Helm-Skripte, um alle Umgebungen per DevOps zu versorgen
• Erstellung von Kubernetes ConfigMaps, Services, ServiceAccounts, Deployments, Secrets, Certificates, Routes und Sidecar Konfiguration als ConfigMap
• Build und Deployment der Docker Images über Azure DevOps Pipelines auf die einzelnen Umgebungen in Richtung Azure Cloud
• Überwachung der Kubernetes POD?s aller Umgebungen über OpenShift

• Folgende Funktionalitäten wurden umgesetzt:
  • Erstellung der Schnittstellen auf Basis von OpenAPI nach dem Contract First Ansatz
  • Generierung der REST-Schnittstellen nach außen über den OpenAPI Generator Maven Plugin
  • Implementierung dieser Schnittstellen
  • Umsetzung der REST-Controller und dazugehöriger Services
  • Implementierung einer Pagination
  • Einbindung einer vom Kunden selbstgeschriebenen Java-Library in die eigene Anwendung, um das DB-Secret zu verschleiern
  • Einrichten einer Oracle Datenbank Version 19c als Docker Container auf der eigenen Maschine zur lokalen Entwicklung
  • Einrichten von Kafka und Zookeeper als Docker Image auf der eigenen Maschine zur lokalen Entwicklung
  • Erstellung von Avro Schemas, um die Kafka Nachrichten zu modellieren
  • Vertestung aller Controller und Services
  • Implementierung von Flyway Skripten
  • Implementierung der Persistenzschicht mit Spring Data JPA und Criteria API
  • Implementierung der Versendung von Daten an Kafka zur Versorgung der Umsysteme
  • Implementierung von Kafka-Listenern, um Daten von Umsystemen zu empfangen und zu verarbeiten
  • Implementierung und Durchführung von Lasttests mittels K6
  • Einbau von Metriken
  • Einrichtung der Anzeige der Applikationslogs in ELK Stack Kibana
  • Implementierung von konfigurierbaren Hintergrundjobs durch Spring-Scheduler mit Cron Expressions

Zusätzlich zu den Entwickler-Tätigkeiten, wurden in allen Projekten folgende DevOps Tätigkeiten durchgeführt:

• Konfiguration durch Helm-Skripte, um alle Umgebungen per DevOps zu versorgen
• Encrypten/Decrypten von Secrets
• Erstellung von Kubernetes ConfigMaps, Services, Service-Accounts, Deployments
• Deployment über TeamCity Pipelines als Docker-Images in Richtung AWS Cloud
• Überwachung der Kubernetes POD?s und aller DEV -und Integrationsumgebungen

Weiterentwicklung einer bestehenden Identity Provider Software (IDP) unter Einsatz von einem Custom-Keycloak und Quarkus-Integration

Folgende Funktionalitäten wurden umgesetzt, um die Customization zu erreichen:

• Generierung der Schnittstellen nach außen über den OpenAPI Generator Maven Plugin
• Implementierung dieser Schnittstellen als eine Ressource und Keycloak-Erweiterung als Service Provider Interfaces (SPI)
• Umsetzung der REST-Controller und dazugehörigen Services
• Vertestung aller Controller und Services
• Implementierung der Persistenzschicht
• Implementierung eines Verschlüsselungsservices, um Datenbankspalten mit verschlüsselten Daten zu versorgen
• Implementierung von Authenticators und Required Actions als SPI, um customized-Handhabung mit dem Keycloak zu erreichen
• Implementierung von Required-Action-Frontends
• Konfiguration von Keycloak Benutzern, Clients, Scopes und Roles in der Keycloak-AdminUI
• Implementierung der Versendung von Daten an Kafka zur Versorgung der Umsysteme
• Implementierung von Kafka-Listenern, um Daten von Umsystemen zu empfangen und zu verarbeiten
• Einbau von Metriken
• Implementierung von konfigurierbaren Hintergrundjobs durch Quarkus-Scheduler

Implementierung von Kafka-Listenern, um Daten aus einem anderen System über Kafka zu importieren und in einer PostgrSQL Datenbank verschlüsselt zu speichern:

Folgende Funktionalitäten wurden umgesetzt:

• Implementierung von Kafka-Listenern, Konvertierung der Daten in eine Datenbankstruktur
• Speichern der Daten in der Datenbank. Dabei wurden sensible Daten verschlüsselt abgespeichert.
• Implementierung eines Verschlüsselungsservices, um die Daten verschlüsselt zu speichern
• Einbau von Metriken

Implementierung von Kafka-Listenern, um Daten aus einem anderen System über Kafka zu importieren, Mapping vorzunehmen und die gemappten Daten an andere Kafka Topics zu schicken:

• Es wurden Daten aus einem SAP-System über Kafka mittels über Kafka-Listener entgegengenommen. Anschließend wurden diese Daten in eine Struktur gebracht, die ein Zielsystem versteht und schließlich wurden diese über Kafka mittels Kafka-Template ans Zielsystem verschickt.

Implementierung von REST-Schnittstellen über den openAPI Generator:

Folgende Implementierungen wurden vorgenommen:

• Generierung der Schnittstellen nach außen über den OpenAPI Generator Maven Plugin
• Umsetzung der REST-Controller und dazugehörigen Services
• Vertestung aller Controller und Services
• Einbau von Metriken

Testsuite zur Automatisierung von Smoke-Tests:

Es wurde eine Testsuite implementiert, die dabei helfen sollte, die Smoketests nicht mehr manuell machen zu müssen. Folgende Funktionalitäten wurden umgesetzt:

• Erstellen von Cucumber Test Skripten (Feature-Dateien)
• Verwendung von Gherkin-Keywords auf deutsch
• Implementierung der Tests mittels WebDriver von Selenium
• Verwendung des openAPI Generators, um REST-Schnittstellen in den Tests zu konsumieren

Implementierung einer Applikation zur Verwendung von Support Mitarbeitern

Frontend:

• Die Support-Mitarbeiter haben am Frontend Prozesse anstoßen können, die Kunden helfen konnten, ihre Anfragen zu lösen. Das hat dazu geführt, dass viele Kundenanfragen sofort über den Support durchgeführt werden konnten, ohne stets mit dem 3rd Level Support in Kontakt zu treten. Das hatte eine schnellere Abarbeitung von Support-Tickets ermöglicht. Auch wurde im Frontend eine Möglichkeit geboten, Klärfälle bei Videoidentifikationsfehlern zu bearbeiten.

Die Daten wurden aus der IDP-Software bezogen und im Frontend zur Anzeige gebracht. Dabei wurden Schnittstellen mittels openAPI generiert und zwar über den OpenAPI Generator Maven Plugin. Folgende Funktionalitäten wurden im Backend umgesetzt:

• Generierung der Schnittstellen nach außen über den OpenAPI Generator Maven Plugin
• Umsetzung der REST-Controller und dazugehörigen Services
• Vertestung aller Controller und Services
• Einbau von Metriken

Applikation zum Exportieren von Prometheus-Metriken auf Basis von SQL-Abfragen zu konfigurierbaren Zeitintervallen:

Durch Abfrage der Datenbank und Exportieren der Ergebnisdaten in Prometheus, konnten zu statistischen Fragestellungen Metriken erstellt werden, die zu Monitoringzwecken dienten. Dazu wurde auf einer als Docker-Image vorliegende Lösung aufgesetzt, die in der eigenen Cloud verdrahtet wurde. Folgende Funktionalitäten wurden umgesetzt:

• Implementierung und Speicherung der SQL-Abfragen in einer Kubernetes ConfigMap

Applikation zur Identifizierung von Kundenidentitäten:

Neukunden, die sich registriert haben, mussten eine Videoidentifikation durchlaufen. Dabei mussten persönliche Daten geprüft werden, um ihre Identifikation zu verifizieren. Folgende Funktionalitäten wurden umgesetzt:

• Generierung der Schnittstellen nach außen über den OpenAPI Generator Maven Plugin
• Umsetzung der REST-Controller und dazugehörigen Services
• Vertestung aller Controller und Services
• Verschlüsselung von Daten mittels Java-Kryptografie
• Speicherung der verschlüsselten Daten in der Datenbank
• Einbau von Metriken

Applikation zum Anlegen von Mock-Daten zur Identifizierung von Kundenidentitäten:

Zum einfacheren Testen der Applikation zur Identifizierung von Kundenidentitäten wurde ein Tool gebaut, das Mockdaten in das jeweilige Kafka-Topic gepumpt hat. Auf diese Weise konnte die Consumer-Appikation diese Mockdaten konsumieren und Test-Szenarien schneller durchgeführt werden. Folgende Funktionalitäten wurden umgesetzt:

• Umsetzung der REST-Controller und dazugehörigen Services
• Verschlüsselung von Daten mittels Java-Kryptografie

Applikation zur Versendung von SMS und E-Mails aus Kafka Events:

Kunden wurden per Email/Sms benachrichtigt wenn bestimmte Ereignisse an ihren Konten passiert sind. Diese Ereignisse konnten die Kunden selbst über ihr App-Verhalten, aber auch das System selbst ausgelöst haben. Um gleiche Nachrichten nicht mehrfach zu verschicken, wurden Kafka-spezifische Informationen in einer Datenbank gespeichert. Folgende Funktionalitäten wurden umgesetzt:

• Kafka-Consumer inklusive Retry- und Deadletter-Funktionalität zum Erhalt der Message
• Speichern von Kafka-Topic Informationen in der Datenbank
• Verschicken von SMS über einen externen Dienst
• Verschicken der Emails durch AWS SES
• Vertestung dieser Funktionalitäten

Weiterentwicklung einer Webapplikation zur Verwaltung von Kundenprofilen:

Frontend:

Kunden hatten die Möglichkeit in ihrem eigenen Profil Daten aktuell zu halten. Z.Bsp Änderung ihrer Telefonnummer etc. Dafür wurde in ReactJS ein Frontend implementiert, um dies zu bewerkstelligen. Folgende Funktionalitäten wurden im Frontend umgesetzt:

• Implementierung der Kommunikation zwischen Frontend und Backend
• Implementierung der Anfrage an den IDP, um ein Access-Token zum Austausch mit dem IDP zur Abfrage von Benutzerkonten zu erhalten
• Implementierung aller GU?s per ReactJS

Backend:

Die Daten wurden aus der IDP-Software bezogen und im Frontend zur Anzeige gebracht. Dabei wurden Schnittstellen mittels openAPI generiert und zwar über den OpenAPI Generator Maven Plugin. Folgende Funktionalitäten wurden im Backend umgesetzt:

• Generierung der Schnittstellen nach außen über den OpenAPI Generator Maven Plugin
• Umsetzung der REST-Controller und dazugehörigen Services
• Vertestung aller Controller und Services

Implementierung eines Import-Systems zur Versorgung von aktualisierten Benutzerkonten:

Da das führende System ein anderes System war, musste ein Import-Tool her, um Benutzerkonten in den IDP zu bekommen. Dabei ging es um Benutzerkonten, die aus verschiedenen Gründen aktualisiert wurden. Die Aktualisierung und Versorgung des IDP-Systems sollte durch dieses Tool umgesetzt werden. Folgende Funktionalitäten wurden umgesetzt:

• Importieren der Daten über einen Kafka-Consumer
• Aggregation der Daten in konfigurierbaren Paketgrößen
• Konvertierung der Daten in die Ziel-Struktur
• Verschicken der Daten der neuen Struktur an den IDP
• Vertestung dieser Funktionalitäten

Entwicklung eines Standalone-Tools zum Erzeugen von einem Certificate Signing Request (CSR) für AWS KMS

Das Cloud-Team hat dieses Tool angefragt. Folgende Funktionalitäten wurden umgesetzt:

• Entwicklung des CSR?s

Entwicklung eines Tools zur Umwandlung von Daten aus einem JSON-Format in ein Java-Format

Folgende Funktionalitäten wurden umgesetzt:

• Konvertierung der Daten aus dem JSON-Format nach Java

Einmaljobs zur Versorgung von Umsystemen:

Umsysteme mussten zum Hauptsystem synchron gehalten werden. Dabei wurden Einmaljobs in Java Spring Batch implementiert, um größere Datenmengen abzusetzen. Folgende Funktionalitäten wurden umgesetzt:

• Einlesen der Daten
• Konvertierung der Daten in eine andere Struktur
• Verschicken der neuen Struktur an Kafka Topics

Implementierung eines Web-Frontends mit Java JSF PrimeFaces:

Implementierung und Wartung eines eventbasierten Messaging-Systems in Java zur Verwendung für die Kommunikation zwischen Hardware-Gerät (Device für Airlines) und bestehender Software für den Einsatz von Checkin bzw. Boarding Zwecken von Passagieren

• Der Checkin-Mitarbeiter am Schalter (auch Agent genannt) sollte die Möglichkeit geboten bekommen, die Kreditkarte/Miles and More - Karte des Kunden per Software bequem und schnell einzulesen.  Weiterhin sollte er per Software einen Aufkleber mittels eines Devices (Bag Tag Printer) per Knopfdruck für den Kunden ausdrucken. Zusätzlich kann man einen Boarding Pass für den Kunden ausdrucken, was wiederum über ein dediziertes Device namens Boarding Pass Printer bewerkstelligt wird. Es gibt auch noch weitere Devices (Reader Devices, Printer Devices, AEA Devices), die im Rahmen dieses Projekts behandelt wurden.
• Technisch gesehen sollte das System mit dem Device über eine vom Hersteller zur Verfügung gestellte Java-API kommunizieren und gleichzeitig mit einer Desktop-Applikation, die als Frontend dient über einen Event-Bus Nachrichten austauschen, um die ev. per Scanner gelesenen Daten im Frontend anzuzeigen. Auch der umgekehrte Weg kommt in der Praxis vor, nämlich dass der Agent den Druck eines Kofferaufklebers triggert. Im Rahmen dessen, schickt das Frontend die durch diesen Prozess generierten Nachrichten an den Event-Bus, über den sich die Consumer bedienen. In diesem Fall sind die Consumer diejenigen Instanzen im System, die mit dem Device mittels der bereitgestellten Java-Library kommunizieren. 
• Das System ist somit ein Event-Handler, der verschiedene Zustände der Device-Kommunikation abbilden muss. Dazu gehören open, read, write init, write, lock, unlock und getStatus Operationen. Je nach vorliegendem Zustand, muss dafür gesorgt werden, dass die richtigen Events entgegen -bzw. weitergereicht -oder gar erweitert werden. Diese Zustandsübergänge wurden mit einer eventbasierten Technik mit Hilfe der Java-Library Apache SCXML als Final State Machine realisiert. Es wurden stets bei der Verarbeitung von Events ein gewisses Stück Logik durchgeführt, die in sogenannten Custom Actions gekapselt wurden. Diese wurden in Java geschrieben.
• Weitere Tätigkeiten, die im Rahmen dieses Projekts angefallen sind:
  • Implementierung eines gemeinsam genutzten Moduls zur Maskierung von sensiblen Kreditkartendaten in Logdateien
  • Implementierung eines Reader-Device Interpreters zur Identifizierung von Barcode-Daten, Kreditkartendaten oder Personalausweisdaten
  • Implementierung von Standalone-Logik zur direkten Kommunikation mit den Devices mit Hilfe der vorliegenden Java-API
  • Erweiterung der Implementierung um spezifische Reader-Devices, die aufgrund ihrer speziellen Natur keine direkte Integration in die bestehende Architektur ermöglicht haben.
  • Implementierung eines Parsers, der Outputs eines bestimmten Tools interpretiert und die Daten weiterverarbeitet, um Device-Konfigurationen dem System mitzuteilen

Schnüren einer Java-Library zur einfacheren Handhabung der Versendung von Emails mit Java in Spring

• Es wurde um die bestehende Email-Funktionalität von Spring eine Abstraktion implementiert und als Java-Bibliothek zur Verfügung gestellt. Diese sollte bestehenden Microservices ein schnelles und redundanzfreies Werkzeug bieten, Funktionalität zum Email Versenden leicht einzubinden. Dadurch mussten die einzelnen Microservices diese Funktionalität nicht mehr in ihrer eigenen Logik selbst implementieren. Die Bibliothek umfasste folgende Features, die der Entwickler nach Belieben entweder als Fluent-Interface-Style oder klassischen Java-Objektaufruf verwenden konnte:
  • Optionale Konfiguration eines SMTP-Servers
  • Optionalen Email-Anhang als binäre- oder Textdatei mit zusätzlicher Konfiguration, ob der Anhang als ZIP-Archiv komprimiert werden soll
  • Optionale Konfiguration eines HTML-Layouts oder einfach plain bezüglich der Formatierung des Email-Inhalts
  • Optionale Konfiguration eines zusätzlichen Logos an Stelle der Email-Signatur

Implementierung eines asynchronen REST-Microservices zum Abfragen von Benutzerdaten

• Es sollte ein sogenannter User-Dump per Knopfdruck erstellt und per Email an den eingeloggten Benutzer versandt werden. Der REST-Microservice musste mit dem Spring-Framework implementiert werden. Dabei sollte ein eingeloggter Benutzer in einem bereits bestehenden Frontend per Knopfdruck einen Request anstoßen, der die Benutzer mit ihren sämtlichen Berechtigungen und Rollen aus einer MongoDB auslesen, in eine CSV-Datei schreiben und als gezippten Anhang per Email an den eingeloggten Benutzer senden sollte.
• Dabei wurde in einem Microservice-Umfeld ein Microservice implementiert, der einen bestehenden Microservice nach den Daten abgefragt hat und diese in eine CSV-Datei geschrieben hat. Technisch wurde dieser Service asynchron implementiert, um dem Client weitere Arbeiten verrichten zu lassen, sprich nicht blockiert zu werden.

Implementierung von Integrationstests mit Spring Boot

• Es sollte die Arbeitsweise eines bestehenden Ext-JS-Frontends so nachimplementiert werden, dass REST-Schnittstellen verschiedener Komponenten automatisiert aufgerufen werden.
• Dabei ging es fachlich darum, eine Reisebuchung mit all ihren umfangreichen Details automatisiert vorzunehmen. Die Buchung sollte angelegt, aufgerufen und am Ende der Tests wieder gelöscht werden.

Implementierung eines REST-Microservices als Report zur Aufdeckung möglicher Fehlerquellen in den einzelnen Microservices

Übernahme der technischen Verantwortlichkeit zum Thema Druck der über den Smart-Client erfassten Daten

• Aufgrund der hohen Datenvielfältigkeit wurde später über die automatisierte Auswertung der Änderung der Druckdaten nachgedacht. Dies wird weiter unten beschrieben.
• Refactoring eines ähnlich funktionierenden historisch gewachsenen Druck-Systems zur Wahrung der Codequalität und der Möglichkeit auf Änderungen schneller zu reagieren.

Entwicklung eines Integrationstest-Frameworks in Java zur Auswertung von versicherungsspezifischen Daten, die aus anderen Software-Komponenten stammten

• Die Daten wurden mittels RTF-Technologie als PDF mit Hilfe der kommerziellen Software von CIB zu einem PDF-Druck aufbereitet.
• Aufgrund der ständigen Änderung der Daten, sollte der technische und fachliche Test dieser Informationen per automatisierten Integrationstests ablaufen. Dies wurde durch ein selbstgeschriebenes Test-Framework umgesetzt.
• Nach Aufspüren der Änderungen der Daten wurde ein Excel zur strukturierten Anzeige generiert, welches dem Fachbereich vorgelegt wurde. Dieser hat die Daten soweit korrigiert, woraufhin die Werte den Tests als korrekte Ergebnisse bekanntgemacht werden mussten. Zum Anerkennen der Werte auf Korrektheit wurde mit einem weiteren Java-Tool realisiert, den Testbestand automatisiert auf die neuen  Werte per Knopfdruck zu aktualisieren.

• Implementierung des Algorithmus auf Basis eines Fachkonzepts
• Implementierung von JUnit-Tests und Testen des Algorithmus

Entwicklung von GUI-Masken auf der Grundlage eines Smart-Client-Ansatzes über die Eclipse Riena Platform, die eine kompatible Ergänzung der Eclipse RCP ist.

• Implementierung von GUI-Masken auf Basis von fachlichen Vorgaben
• Implementierung von JUnit-Tests
• Bugfixing von Issues und Wartung der Software

Entwicklung einer Software für den touristischen Bereich auf Basis von Eclipse RCP, EJB3 und Hibernate und Wartung einer älteren Version.

• Konzeption und Design der Client-Komponenten
• Implementierung von JUnit-Tests/SWTBot Tests für die Client-Komponenten
• Realisierung von Frontend-Komponenten
• Bugfixing und Wartung älterer Versionen der Software

Weiterentwicklung einer bestehenden Software zur Verwaltung, Reporting und Durchführung von Online-Befragungen.

• Konzeption und Design für die Backend-Komponenten
• Implementierung von JUnit-Tests für die Backend-Komponenten
• Realisierung von Frontend-Komponenten mit Apache Wicket

Implementieren einer Web-Anwendung zum Zwecke der Marktforschung für einen Kunden

• Zu Marktforschungszwecken benötigte der Kunde eine Web-Anwendung, die Reports, Kennzahlen-Erfassungen, Besuchsberichte etc. mit einem Benutzerberechtigungskonzept und Rollen innerhalb komplexer Organisationsstrukturen zugänglich macht. Dies wurde auf der Backend-Seite mit Spring und Hibernate als DAOs und Services zur Verfügung gestellt. Zu Testzwecken wurde HSQLDB als Datenbank für jeden einzelnen Entwickler eingerichtet.
  • Realisierung von Backend-Komponenten der Businesslogik
  • Realisierung von Backend-Komponenten der Integrationslogik
  • Realisierung der Junit-Tests für die Backend-Komponenten
  • Durchführen des Systemtest mit Fehleranalyse und Fehlerbehebung

• Analyse des bestehenden Datenmodells für die spätere Aufbereitung der Daten für den Web Service
• Implemetierung des Web Services mit Spring Web Services
• ?Implementierung der Test-Clients mit Apache Axis 2

• Die Verwaltung der Fragebögen erfolgte über einen Web Client auf Basis von Eclipse RAP. Die Durchführung der Online Befragungen erfolgte über einen Web Client auf Basis von JSP und Struts.
  • Erstellung des Fachmodells als UML2 Modell und Umsetzung in Java-Klassen & -Interfaces (ca. 140 Klassen)
  • Schwerpunkte des Fachmodells (Benutzerverwaltung, Fragebögen, Datawarehouse)
  • Mapping der Domainmodell Klassen mittels JPA als Annotation unter Verwendung von Hibernate (Die Umsetzung nutzte alle existierenden O/R Mapping Strategien der JPA)
  • Aufbau und Pflege der kompletten JUnit Suite zum Test des Domainmodels
  • Umsetzung eines I18N Supports auf Ebene von Enumerations des Domainmodells (Fachkonstanten z.B. Geschlecht, Fragetypen, Antworttypen usw)
  • Konfiguration und Deployment des Spring Frameworks für alle Klassen der Backend Komponenten
  • Installation und Konfiguration von Hibernate und Integration in Spring
  • Installation und Konfiguration eines Java Messaging Servers (JMS) auf Basis von Spring/ ActiveMQ
  • Umsetzung asynchroner Services zum Speichern der Online Survey Ergebnisse in einem Datawarehouse über ActiveMQ

Das Projekt ?Formel 1? dient der Konsolidierung mehrerer teils redundanter Datenbanken zu einem zentralen System. Das Projekt wurde unter Einsatz von Smarty als Referenzprojekt umgesetzt, mit dem Ziel die Entwicklungsdauer zu reduzieren.

• Modellierung eines konsolidierten Datenbankdesigns der betroffenen Datenbanken
• Erstellung der logischen Transformations-/Migrationsregeln und Umsetzung in Form von Import/Export-Routinen für MySQL
• Entwicklung eines webbasierten Administrationswerkzeug für die Redakteure
• Entwicklung einer http-basierten Schnittstelle für die Bereitstellung der Daten im Teletext von RTL

Das Projekt ?Programmdatenbank? dient der Bereitstellung von Programmdaten. Ziel des Projektes war die Bereitstellung der Programmdaten als unternehmensweite Services

• Entwicklung von REST-Services auf Basis des Zend-Framework für die Änderung und Bereitstellung von Programmdaten
• Entwurf und Entwicklung der REST-Services und der XML-basierten Nachrichten
• Entwicklung browserunabhängiger DOM-Elemente und Widgets mit JQuery und JQueryUI zur Erhöhung des Benutzerkomforts

Portierung einer Applikation zur risikoadäquaten Kreditbewertung von MS Access auf eine Swing basierte Lösung auf Basis einer JEE Architektur

• Die JEE Architektur basierte auf JBoss, Oracle im Backend und Rich Client auf Basis von Swing.
  • Kapselung und Anbindung des bestehenden (C++) Rechenkerns zur Risikobewertung in Java. Die Einbindung in den Application Server JBoss erfolgte mittels SWIG
  • Entwicklung von C++ Testprogrammen zur Validierung größer Datenmengen in MS Visual Studio 2005
  • Planung und Aufbau der JEE Umgebung auf Basis von JBoss
  • Technisches Design und Umsetzung mittels Enterprise Java Beans (Stateless, Stateful, Message Driven Beans)
  • O/R Mapping mit JPA Annotations
  • Deployment über ANT auf Linux
  • Test der Datenbestände mit SQL und JUnit