Oculus Rift, Cardboard, PlayStation VR, HTC Vive – VR-Brillen sind in aller Munde und werden als Revolution im Spielebereich gehypt.

Natürlich geht diese Entwicklung nicht an den Webbrowsern dieser Welt vorbei. Mit WebVR entsteht ein Standard, der es erlaubt, mit JavaScript auf die neuen Möglichkeiten zuzugreifen. Mit diesem Vortrag möchte ich zeigen, wie eine VR-Brille benutzt werden kann – von Beschleunigungssensoren für Cardboard-Apps, bis zum Headtracking einer Oculus Rift. Dank WebGL können performante VR-taugliche Anwendungen für den Browser entstehen und Benutzern auf Webseiten eine zusätzliche Erfahrung bieten.

Im Frühjahr 2016 wurden in der Presse die ersten Berichte zu den "Panama Papers" veröffentlicht. Mit knapp 3 TB an Rohdaten war dies das bisher mit Abstand größte Leak an Daten weltweit.

Der Vortrag gibt technische Einblicke, wie das ICIJ (International Consortium Of Investigate Journalists) diese riesige Datenmenge verarbeitet und den Journalisten zur Recherche einfach benutzbar bereitgestellt hat.

Neben anderen Technologien kamen dabei auch Graphdatenbanken als Schlüsselkomponente zum Einsatz. Eine Livedemo wird Lesbarkeit und Mächtigkeit der Abfragesprache "Cypher" auf dem Panama Paper Dataset deutlich machen.

Für viele ist die Selenium IDE der Einstieg in die Testautomatisierung mit dem Browser. Auf Dauer wartbare Regressionstests lassen sich damit aber kaum erstellen, da eine Änderung in der zu testenden Anwendung, Änderungen an viele Tests zu Folge haben kann.

Dieser Vortrag geht auf die Schwächen ein und stellt grundlegende Konzepte zum Aufbau von Browser-Tests mit Selenium-Java vor. Danach wird anhand von den auf Selenium aufbauenden Frameworks geb und arquillian graphene vorgestellt, wie wiederkehrende Elemente sinnvoll angesteuert werden können und das Testschreiben mittels Java-IDE per Code-Vervollständigung möglich ist.

Java EE 8 bringt mit dem JSR-371 ein neues Action-basiertes Webframework mit. Getauft wurde es schlicht „MVC“. Grundlage für MVC sind bekannte und erprobte Technologien wie JAX-RS, CDI und Bean Validation.

Die Java EE Community zeigt großes Interesse: Während die Spezifikation JSP und Facelets als View Technologie unterstützt, wurde aus der Community bereits Support für ​modernere Alternativen wie Mustache oder Thymeleaf beigesteuert. Erste Beispiele zeigen, wie sich MVC auch zusammen mit React verwenden oder als Fat-JAR ohne Application Server deployen lässt.

Im Vortrag werden wir einen Blick auf den aktuellen Stand der Spezifikation werfen und live eine einfache MVC-Applikation erstellen.

Swift wurde überraschend während Apples WWDC Keynote im Juni 2014 vorgestellt. Ein Jahr später folgte die Open Source Veröffentlichung und der Sprung auf Version 2.

Ursprünglich als Ablösung für Objective-C angepriesen, findet Swift immer mehr den Weg in den Enterprise-Sektor und wird sogar als First Class Language für Android in Betracht gezogen.

So stellt sich die Frage, in welchen Bereichen Swift in Zukunft seinen Einsatz finden wird?

Mit den Open Source Bemühungen Apples und der Möglichkeit Swift neben Mac OS X, auch auf Linux und FreeBSD ausführen zu können, wurden eine Reihe von Web-Frameworks vorgestellt.

Die Präsentation gibt eine Einführung zu Swift und einen Überblick zu den derzeit populärsten Web-Frameworks (Vapor, Perfect and Kitura) und deren einzelnen Features. Anschließend wird die exemplarische Implementierung und das Deployment eines Mobile Backends in Kitura für eine TODO-App vorgestellt. Hier soll verdeutlicht werden, welche Vor- und Nachteile die Nutzung von Swift auf dem Server hat und welche Möglichkeiten der Einsatz bietet.

Als relativ junges Ökosystem ist gerade die Betrachtung des Wandels und die Integration von Swift spannend. Mit IBM als Partner von Apple ist es nur noch eine Frage der Zeit bis Swift in der Cloud ankommt.

Microservices sind mittlerweile ein etabilierter Architekturstil. Dieser stellt neue Anforderungen an Automatisierung, Infrastruktur und Wissensmanagement. Das Wissen über Funktionalität, Abhängigkeiten, Verantwortlichkeiten und Build-Systeme ist stark verteilt, was Entwickler und Architekten vor neue Herausfoderungen stellt.

Wie weiß ein Entwickler, welche Services es bereits gibt? Wo ist der Sourcecode und die Buildchain dazu? Wer sind die Ansprechpartner dafür? Es ergeben sich eine ganze Reihe an Fragen bezüglich Dokumentation, Inter-Teamkommunikation und Technik.

In diesem Vortrag stellen wir unseren Lösungsansatz vor und vergleichen ihn mit bestehenden Implementierungen von E-Post und Zalando.

To make the complex, distributed and highly interconnected system landscapes of today robust, responsive and highly available, we need to implement resilience into them on the application level.

Many patterns exist how to implement resilience into an application. The daunting question is which patterns to pick and how to combine them in order to match your specific needs best.

In this session we will get an overview about the resilience pattern landscape, organize them in a little taxonomy and explore a few patterns in more detail. Then we will learn a small guideline how to create a resilience pattern language and some examples of known choices and combinations.

After this session, you will be better capable to pick the resilience patterns you need to satisfy your specific robustness needs and combine to your pattern language.

Reactive Programming wird in einschlägigen Quellen oft als das nächste große Programmierparadigma beschrieben.

Eine der häufigsten Beschreibungen von Reactive Programming ist, dass Reactive Programming aus der Kombination von Immutable Streams und propagation of change besteht. Bei dem Begriff propagation of change, der Verbreitung von Änderungen, denkt man direkt an das Observer-Pattern, welches in diesem Vortrag klar von Reactive Programming abgegrenzt wird.

Mithilfe von kleinen Beispielen wird das Prinzip von Observables, eine der Grundsteine des Reactive Programming betrachtet. Dabei tauchen alte Bekannte, wie Lambda-Expressions und Map/Reduce auf.

Natürlich existiert bereits ein Manifest, welches beschreibt, was ein Reaktives System ist: Responsiv, Widerstandsfähig, Elastisch und Nachrichtengetrieben.

Nach diesem Überblick stellen wir uns folgende Fragen:

Ist Reactive Programming überhaupt ein neues Paradigma?

Wie testen wir Reaktive Systeme?

Wer hat die Kontrolle über Reaktive Systeme, wenn alles auf ständiger Veränderung basiert?

Mit JBoss Keycloak gibt es eine Open-Source Benutzerverwaltung, die sich über OAuth 2.0 auf einfache Art in die eigene Anwendung integrieren lässt.

Beispielanwendungen im Vortrag zeigen die verschiedenen Integrationsmöglichkeiten: Angefangen von JavaEE- und Spring-Anwendungen über JavaScript-Client-Anwendungen bis hin zu Java-REST-Services.

Alle Funktionen angefangen von der Benutzerregistrierung über die Integration von Google, Facebook, Twitter und LDAP stehen so ohne Programmierung zur Verfügung und können individuell konfiguriert werden. Teilen sich mehrere Anwendungen eine Benutzerverwaltung, so steht ein anwendungsübergreifendes Single-Sign-On und Single-Sign-Out zur Verfügung.

„Schreibe aus Sicht des Lesers! Erkläre Deine Notation! Verwende eine Standardgliederung! ..." Die klassischen sieben Regeln für gute (Architektur-)dokumentation sind so alt, dass Ihr sie vielleicht gar nicht kennt.

Doch die Frage, wie Ihr Eure Lösungskonzepte festhaltet, kommuniziert und wirkungsvoll in der Umsetzung verankert, bleibt – und ihre Relevanz nimmt in Zeiten selbstorganisierter Teams eher noch zu.

Dieser Vortrag ruft Euch die Regeln nicht nur (falls nötig) in Erinnerung, sondern diskutiert und hinterfragt sie im heutigen Kontext. In dem leichtgewichtige Formen Schwergewichte wie die UML mehr und mehr verdrängen und in dem Entwickler die Architekturarbeit verantworten.

Lernt anhand praktischer Beispiele zeitgemäße Formen eines Architekturüberblicks und ein schlankes Vorgehen für dessen Erstellung kennen. Sowie Möglichkeiten, wie Ihr die Dokumentation näher an die Entwicklung bringt, und die Umsetzung Eurer Architektur dort angemessen überprüft. Von Richtlinien zu Prinzipien und Tests. Der Quelltext erzählt nicht die ganze Geschichte ...

Der Vortrag befasst sich mit den Herausforderungen der technischen System-, Anwendungs- und Service-Integration im Zeitalter des Digital Business und der digitalen Transformation von Unternehmen.

Er begründet warum Konzepte der klassischen Enterprise Application Integration (EAI) oder denen der serviceorientierten Architekturen (SOA) unter häufigem Einsatz eines Enterprise Service Bus (ESB) nicht mehr genügen, um mit der agilen Softwareentwicklung Schritt zu halten. Deshalb überführen wir bei Immobilien Scout eine klassische Integrationslösung mit dem Produkt TIBCO BusinessWorks über mehrere Ausbaustufen in eine hybride Integrationsplattform (HIP), in der die Amazon Webservices (AWS) und insbesondere die AWS Simple Workflows (SWF) verstärkt Anwendung finden. Die finale Integrationslösung folgt den Prinzipien der agilen Softwareentwicklung und fügt sich nahtlos in eine Microservice-Architektur ein. Die als asynchrone Workflow-Engine wahrnehmbare Lösung besitzt das Potential zur Integration neuartiger Technologien aus den Bereichen Internet of Things (IoT), Mobile und Cloud in die Geschäftsprozesse des Unternehmens. Mehr noch bereitet sie den Weg für Self-Service-Integrations-Portale, welche Teams die Möglichkeit der selbstständigen Service-Integration geben.

Here we are: Microservices, Container, Cloud ... and lots of data to deal with. Usually that's where the real trouble starts.

Many developers still base their designs on the concept of perfectly consistent ACID transactions, everything being always consistent and in order, no anomalies around.

But reality is different: Perfect consistency does not exist and many real-world use cases require much weaker consistency models in order to satisfy the scalability or robustness requirements.

So, what are our options and what is the price we need to pay? Do we need to accept potentially losing data in order to get higher availability? How much can I scale without compromising consistency?

In this session we will answer this and many more questions. We will also have a look at some popular data stores and examine what kind of consistency models you can achieve with them and how. Finally, we will have a peek into latest research and see new ideas that might push the borders of the current state-of-art.

Das Spring Data Projekt organisiert seine Releases in ungefähr halbjährlichen Release-Trains, die ein gutes Duzend Module enthalten um Datenzugriffschichten für verschiedene Datenbanken zu implementieren.

Der Vortrag widmet sich den wichtigsten Features der letzten Releases: Erweiterung der Unterstützung von Java 8, ein Programmiermodell für Projektionen in Repositories und Store-spezifische Änderungen in JPA, MongoDB, Redis und den Spring Data Community-Modulen.

Bei Microservices denken die meisten an Frameworks wie Spring Boot und Docker Container. Es geht aber viel kleiner, wenn man technologische Kompromisse eingeht.

Dieser Vortrag gibt einen Überblick über Microservice-Technologien wie Spring Cloud oder Spring Boot - und Ansätze wie Java EE, OSGi und Amazon Lambda, mit denen noch viel kleinere Systeme möglich ist. Dabei zeigt der Vortrag die Vorteile aber auch die Nachteile dieser Ansätze.

Erwarten Sie plumpes Marketing für unsere BPM Platform! Ähm - wie bitte? Nein - natürlich das genaue Gegenteil!

Im Vortrag möchte ich live demonstrieren (und codieren!) wie bestimmte Sachverhalte in den Standards BPMN 2.0 (Workflows für "starre" Abläufe), CMMN (Case Management für mehr Flexibilität) oder auch DMN (Business Rules mit z.B. Entscheidungstabellen) grafiscg modelliert und dann direkt auf einer Java Engine ausgeführt werden. Dazu verwende ich die quelloffene camunda BPM Platform - so dass alles direkt zu Hause nachgebaut werden kann! In der Session diskutiere ich mögliche Architekturen von klassischer SOA bis zu Spring Boot basierenden Microservices. Natürlich dürfen Best Practices sowie ein bisschen Meinung nicht fehlen, z.B. dass "Zero-Code-Lügen“ in die Märchenbücher gehören - und nicht in Marketingmaterialien der Hersteller!

Microservices sollen keine gemeinsame Datenbank haben. Warum eigentlich?

Und was ist mit der dabei entstehenden Redundanz? Viele Architekturen kranken an zu großen und inflexiblen Datentöpfen. Dieser Vortrag zeigt die Gründe für die Probleme: Die Missachtung von Bounded Context und eine viel zu enge Kopplung der Datenmodelle. Ansätze wie CQRS (Command Query Responsibility Segregation) und Event Sourcing zeigen, wie solche Probleme gelöst werden können - ohne dass dabei zu große Redundanzen bei den Daten entstehen.

Als Fundament der virtuellen Währung Bitcoin ist das Blockchain-Verfahren mittlerweile die Basis für zahlreiche neue Geschäftsideen.

Die üblichen Verdächtigen übertrumpfen sich gegenseitig mit Superlativen dazu, wie „disruptiv“ die darauf basierenden Startups sein werden. In diesem Vortrag betrachten wir zunächst die technischen Grundlagen und beleuchten Vor- und Nachteile. Danach identifizieren wir praktische Szenarien und diskutieren, wie man diese konkret umsetzt.

Mit Docker Swarm und Compose stehen nun endlich Werkzeuge zur Verfügung mit der stabile Docker Cluster aufgebaut werden können.

Compose kümmert sich dabei um die Bereitstellung der Container in diesem Cluster, Swarm bietet die Grundlage in dem es verschiedene Voraussetzungen hierfür schafft. Mit einer Beispielapplikation werden wir in die Untiefen und Abgründe der Nutzung von Swarm und Compose in einem produktiven Umfeld abtauchen.

Für mich und viele andere ist JUnit die vielleicht wichtigste Bibliothek im Java Universum. (Fast) jedes Projekt nutzt sie, alle IDEs integrieren sie, ebenso wie Buildtools.

Aber JUnit hat eine lange Geschichte und mit Java 8 sieht JUnit 4 ein wenig altbacken aus.

Im August 2015 starteten die Entwickler von JUnit eine Crowdfounding Kampagne um die Entwicklung von JUnit Lambda zu unterstützen. Einer neuen JUnit Version, die basierend auf den Sprachfeatures von Java 8, flexiblerer Möglichkeiten bieten wird, Tests zu definieren und gleichzeitig die APIs, die von Toolherstellern genutzt werden, aktualisieren wird.

In diesem Vortrag wollen wir einen Blick auf JUnit Lambda werfen: Wo kommt es her, wo steht es aktuell und wohin geht die Reise.

Betriebliche Abläufe gehören zum Geschäftsalltag wie LEGO zur Kindheit. Dennoch mangelt es in vielen Unternehmen an der Transparenz und Wiederverwendbarkeit dieser Abläufe.

Mit der „Business Process Modeling Notation“ (BPMN) lässt sich dieses Manko beseitigen und Fachabteilungen und Technik wachsen zusammen. Zusätzlich wird die Geschäftswelt ortsübergreifend visualisiert. Als Ergebnis entstehen Diagramme, die als Dokumentation für das Business dienen und Automationsgrundlage der IT sind.

Im Gegensatz hierzu steht das praktische Lernen mit LEGO-Mindstorms. Ein kleiner Roboter wird in mannigfaltigen Ausprägungen zusammengebaut, mit einer Java-API gefüttert und über externe Software gesteuert. Seriell und parallel geschaltete Einzelschritte erwecken unseren beweglichen Freund zum Leben.

In diesem Vortrag wird der Bogen zwischen Prozessen und Robotern gespannt. Bewegungsabläufe werden mit BPMN2 definiert und mittels einer „Business Process Engine“ automatisiert. Es wird die Herangehensweise der Modellierung inklusive BPMN-Basics, Strukturierung von Prozessen sowie Motorik und Sensorik behandelt und während einer Live-Demo veranschaulicht.

Alles in allem ein Thema, welches Programmierer und Tüftler, Profis und Unerfahrene sowie Erwachsene und Kinder gleichermaßen zu begeistern vermag.

Es gibt Momente, in denen will man einfach nur Code schreiben und diesen in der Cloud ausführen. Ohne sich lange mit der Infrastruktur aufhalten zu müssen, ohne Infrastruktur dauerhaft betreiben/laufen lassen zu müssen. Weil man es nicht braucht, weil man es nicht will, weil es teuer ist.

Ereignisgesteuerte Funktionen in der Cloud ausführen - darauf ist AWS Lambda spezialisiert. Wir Entwickler schreiben einfach nur noch den Code. In JavaScript (Node.js), Java oder Python. Um den Rest kümmert sich Lambda. Und abgerechnet wird in 100ms Blöcken. Wer effizienten Code schreibt, zahlt also entsprechend wenig.

Auf AWS eigene Ressourcen kann direkt zugegriffen werden, denn die komplette AWS-API steht in Lambda zur Laufzeit zur Verfügung. Zusammen mit dem AWS API-Gateway erhalten Lambda-Services eine HTTP-/REST-Schnittstelle und können auch mit dem Rest der Welt kommunizieren.

Wer also davon überzeugt ist, dass Microservices wirklich klein sein müssen, der muss sich mit AWS Lambda beschäftigen. Viel kleiner geht schon nicht mehr. Und App-Server? Die waren gestern...

Haben sich Unit-, Integrations- und Oberflächentests in der Vergangenheit doch mehr oder weniger gut durchgesetzt, fristen die Lasttests eher ein Nischen-Dasein oder fallen meist Zeit-Budgets zum Opfer. In vielen Unternehmen klicken die Mitarbeiter meist nur schnell aber unkontrolliert hin und her. Diese Art von Smoke-Tests haben keine Aussagekraft, sind nicht reproduzier- und damit nicht vergleich- oder bewertbar. Wenn ein Performance-Engpass auftritt, ist die eigentliche Ursache nicht ersichtlich.

Gatling schickt sich seit einiger Zeit an, dieses Feld neu aufzurollen. Mit einer zeitgemäßen Architektur basierend auf Scala, Akka und Netty, arbeitet Gatling asynchron und nicht-blockierend und damit mit einem hohen möglichen Durchsatz. Mit der Scala-DSL sind die Test-Szenarien schnell erstellt, anhand von Assertions können globale Erfolgskriterien definiert werden und in übersichtlichen Reports sind alle Ergebnisse detailliert nachlesbar. Umfangreiche Tests können einfach mit dem Recorder aufgenommen und realitätsgetreu wiedergegeben werden. Mit Gatling gibt es keinen Grund mehr, Lasttests nicht von Anfang an auszuführen!

Seit Ende 2011 steht WebSocket als offizieller Standard (RFC 6455) bereit. Doch wie sieht es mit dem Einsatz von WebSocket in der Praxis wirklich aus?

Funktioniert WebSocket auch im mobilen Umfeld? Was hat sich seit dem Fertigstellen der Spezifikation getan? Wie sehen die Neuerungen aus? Was bedeutet HTTP/2 für WebSocket? Der Vortrag gibt einen Überblick zum aktuellen Stand des Protokolls, sowie dessen Erweiterungen und stellt verschiedene Java Client- und Serverbibliotheken anhand von praktischen Beispielen vor.

Der Elastic Stack ist weit verbreitet, um Logdaten mit Logstash zu sammeln, mit Elasticsearch zu analysieren und sie mit Kibana zu durchsuchen sowie zu visualisieren.

Mittlerweile gibt es aber ein weiteres Werkzeug, um diverse Betriebsdaten zu sammeln: Beats. Es kann viele verschiedene Quellen nutzen, um Daten zu sammeln, zu analysieren und weiterzuleiten.

Dieser Vortrag gibt einen Überblick über die Plattform Beats und wie man mit ihr Systemmetriken, Netzwerkdaten und Dateien in Echtzeit analysieren kann.

Docker hat sich inzwischen aus dem Hype-Bereich heraus entwickelt und bietet einige ausgereifte Werkzeuge, die im gesamten DevOps-Bereich benutzt werden können. Häufig wird Docker mit Microservices assoziiert. Wir finden aber, dass es sich auch wunderbar bei klassischen Anwendungsarchitekturen benutzen lässt.

Entwickler benötigen sowohl für die eigene Entwicklung als auch für Integrationstests unterschiedliche Systeme, die meistens aus mehreren Komponenten aufgebaut sind. Der Klassiker ist die Datenbank und ein Web-Server. Docker ermöglicht diese leichtgewichtig und isoliert aufzusetzen. Richtig hilfreich wird dies aber nur, wenn ein übergreifendes Konfigurationsmanagement auch gleich die Überführung in die CI-, Staging- und Produktivsysteme ermöglicht.

Des Weiteren ermöglicht Docker es dem Entwickler, dass er nicht eine Vielzahl kleiner Hilfsprogramme lokal installieren muss, die sich potenziell projektübergreifend in die Quere kommen, wie z.B. Java, Maven, Gulp, Grunt und Node.js.

In diesem Vortrag wollen wir unsere Erfahrungen beim Einsatz von Docker in all diesen Bereichen an einem praktischen Beispiel vorstellen.

Eine Tabelle mit drei Spalten: Das ist alles was man mit EventSourcing braucht, um einen eCommerce Shop zu entwickeln - oder ein ERM-System - oder eigentlich jede Art von Software.

Statt wie üblich den Ist-Zustand zu speichern, erfasst man Domain Events: Alles was in der Anwendung passiert ist. Aus diesen Events wird zur Laufzeit der Zustand der Anwendung abgeleitet. In meinem Vortrag zeige ich, wie eine EventSourcing Architektur mit Command-Query-Responsibility-Segregation aussieht und wie man damit skalierbare, sich entwickelnde Software, maßgescheidert auf die Business Anforderungen, schreiben kann und obendrein ein exzellentes Domänenmodell erhält.

Clojure ist eine JVM-Sprache, die das Unmögliche möglich macht: Ein tatsächlich in der Praxis von normalsterblichen Entwicklern einsetzbares Lisp.

Neben den Grundlagen von Clojure werden Sie in dieser Session auch lernen wie man hiermit Web-Anwendungen umsetzten kann. Wenn Sie sich hierbei nicht von den Lisp-typischen Klammern abschrecken lassen werden Sie schnell sehen, dass der Einsatz einer rein funktionalen Programmiersprache sehr gut zum statuslosen Ansatz von HTTP passt.

Why craft and deliberate practice matter and how to raise the bar in today's software industry. What is software craftsmanship all about and how could you be part of it?

Fast jedes Softwaresystem wird mit guten Vorsätzen aber unter schwierigen Bedingungen entwickelt. Deadlines, unterschiedliche Qualifikationen und Missverständnisse im Entwicklungsteam führen dazu, dass die Architektur des Systems erodiert und Schritt für Schritt technische Schulden aufgebaut werden.

In diesem Vortrag zeige ich Ihnen, wie Sie Ihren Sourcecode organisieren und weiterentwickeln können, um technische Schulden zu verhindern. Dabei werden Sie sehen, welche Tools sich besonders eignen, technische Schulden durch geeignete Refactoring aus der Welt zu schaffen. Basis der Empfehlungen sind Beispiele aus über 100 Analysen in Java, C#, C++, PHP und ABAP sein.

Deep learning, big data, data science: Der coole Entwickler von heute bietet seinen Kunden mehr als eine Produktliste und einen Warenkorb. Aber braucht es wirklich den großen Cluster in der Cloud bevor man anfangen kann, den eigenen Webshop mit kontextsensitiven Empfehlungen aufzuwerten?

Am Beispiel von Elasticsearch gibt der Vortrag einen Überblick wie weit man allein mit einer Suchmaschine von trivial zu implementierenden Features bis hin zu komplexen personalisierten Recommendations kommen kann. Darüber hinaus wird aufgezeigt wie mit Elasticsearch's aktuell noch als experimentell markierten "Significant Terms Aggregation" Recommender Features schnell out of the box umgesetzt werden können, für die bisher zusätzliche Recommendationsframeworks benötigt wurden.

The buzz around containers has not yet reached it climax. Rolling out big scale heterogeneous applications has just started.

This talk is about real customer projects, which use docker to deploy applications in a rapidly environment changing by kubernetes and CoreOS. We followed a very strict approach, separating persistent and stateless applications and run everything in small units orchestrated by Kubernetes. With our own tools we could create descriptions of environments very rapidly, creating full complex environments with a single command. Examples in Java, Python and Ruby are shown. Security has been addressed to pass an extensive security audit. Using the latest feature of systemd on Linux on CoreOS, we could move the configuration management into the kubernetes domain.

Was bedeuten Continuous Delivery, Micro Services und Feature Toggles für die Benutzbarkeit von Software?

User Experience wird für die Software Entwicklung immer bedeutender. Heute wird nicht mehr nur darauf Wert gelegt, dass eine Anwendung korrekt funktioniert - sie muss perfekt funktionieren. Sie muss leicht bedienbar sein, intuitiv zu verwenden und die Anwender bei ihren kognitiven Prozessen unterstützen. Ein Teil davon ist, Software ein Gesicht zu geben, das Benutzer begeistert. Der andere Teil besteht darin, Architekturen zu bauen, mit denen das technisch möglich wird.

Dieser Vortrag möchte einen Einblick geben, was Software-Architektur leisten muss, um eine optimale User Experience zu garantieren. Als Beispiele dazu dienen diverse Migrationsprojekte vom Host zu Java-Web-Anwendungen, anhand derer gute und schlechte Ideen der Software-Architektur und ihre mittelbaren und unmittelbaren Auswirkungen auf die User Experience aufgezeigt werden. Diese Ideen erstrecken sich von technischen Lösungen über Entwicklungsprozesse bis hin zu allgemeinen Irrtümern, denen Software Architekten wie auch Usability Engineers gerne unterliegen, wenn es um die andere Disziplin geht.

Software-Architekturen werden mit Begriffen beschrieben, für die keine überprüfbaren Repräsentationen in Programmiersprachen existieren. Die Folge: Architekturdefinitionen mit ihren Konzepten und Constraints sind nur als Dokumentation vorhanden, über deren Inhalt alle Entwickler auf dem Laufenden gehalten werden müssen.

Dieses Vorgehen scheitert meist in der Praxis, ein Auseinanderdriften von Architektur und Code-Basis ist kaum zu verhindern. Der Vortrag präsentiert den Ansatz hinter dem Code-Analyse-Werkzeug jQAssistant, welches Informationen aus strukturrelevanten Artefakten – vom Buildsystem über Packages und Klassen, bis hin zu Framework-Deskriptoren – extrahiert und als Graph in einer Datenbank ablegt. Die gewonnenen Daten werden automatisiert über Regeln in Beziehung gesetzt, und um projektspezifische Konzepte bzw. Begriffe angereichert und validiert. Die Regeln sind in Form ausführbarer Dokumentation hinterlegt und Entwickler erhalten stets aussagekräftiges Feedback über vorliegende Verletzungen.

Ein Vortrag über die Best-of-Breed-Plattform bestehend aus Spark, Mesos, Akka, Cassandra und Kafka.

SMACK ist ein Baukasten von Technologien, um eine zuverlässige und flotte Ingestion zu erstellen und hohe Freiheitsgrade in der Auswahl der Speicher- und Abfragemethoden zu bieten. Eingebaut in allen Technologien ist zudem ein dedizierter Flow-Control-Mechanismus, um mit der Last umgehen zu können.

JavaScript ist seit ein paar Jahren die neue Hypesprache. Sie hat eine aktive Community und zahlreiche Frameworks, mit jedem Einsatzgebiet das man sich vorstellen kann. Spätestens seit dem Sprung ins Backend mit Node.js ist sie eine der populärsten Sprachen geworden.

Leider wurde JavaScript nicht für diesen umfassenden Einsatz entworfen. Das macht sich in fehlenden Sprachfeatures bemerkbar, wie zum Beispiel lokalem Scoping oder einem standardisierten Modulkonzept. Mit ECMAScript 6 wurden viele dieser lang erwarteten Erweiterungen in die Sprache aufgenommen.

Was JavaScript aus der Sicht von vielen Backendentwicklern noch fehlt ist ein ausgereiftes Typsystem. Genau dort setzt TypeScript an, indem es optionale statische Typisierung mit all seinen Vorteilen bereitstellt. Als echte Obermenge von JavaScript kompiliert es zurück zu ECMAScript 5 oder 6 und garantiert damit volle Abwärtskompatibilität. Außerdem strebt es eine volle Angleichung an die JavaScript-Spezifikation an, womit es das JavaScript der Zukunft werden soll. Der Vortrag stellt die wichtigsten Eigenschaften von TypeScript vor. Diese beruhen hautpsächlich auf der Erfahrung in komplexen Projekten, die mit TypeScript gebändigt werden konnten.

Anhänger der funktionalen Programmierung sprechen gern von "Immutability", "polymorphen Typen" und "Monaden", meist begleitet von grandiosen, aber luftigen Metaphern. Aber wie sollen sich Java-Programmierer vorstellen, wofür diese Dinge in einer realistischen Anwendung konkret gut sind oder wie sie eingesetzt werden?

Der Vortrag präsentiert ein kleines, aber realistisches Java-Projekt - einen ereignisorientierten Simulator ("discrete event simulator") aus dem Kontext der Produktionssteuerung. Dann zeigt er, wie der Java-Code zunächst nach Haskell übersetzt und dann noch weiter verbessert werden kann. (Das Original wurde von Simulations-Experten geschrieben, die keine Haskell-Programmierer sind.) Aus dem Vorgang ergeben sich dann konkrete Einsichten darüber, was die "Immutability" ausmacht, was man mit dem Haskell-Typsystem so ausrichten kann und wofür Monaden gut sind.

Im Rahmen eines Hackathons entstand VeRST (Versioned Represental State Transfer, https://github.com/openknowledge/jaxrs-versioning ), ein kleines aber nützliches Framework, um JAX-RS-Schnittstellen einfach und automatisiert zu versionieren.

Im Rahmen dieses Kurzvortrags wird das Framework mit seinen Features vorgestellt.

Gehöre ich dem Internet oder gehört es mir? Weiß ich noch, was ich wohin übertrage und habe ich Kontrolle darüber?

Ein Offline-Proxy ermöglicht mir, alles was ich im Internet angesehen habe, jederzeit so oft ich will zu nutzen, ohne mit dem Internet verbunden zu sein. Auch verschlüsselte Inhalte kann ich durchsuchen, Adressen sperren und erlauben. Auch in der Arbeit macht es Sinn. In einer SOA oder REST-Architektur wäre das ein selbst lernender Mock - immer aktuell, ohne Programmierung. Genial? Meine Tochter könnte es nicht gebrauchen.

Apache Tamaya ist ein interessantes Projekt, welches ein einfaches aber komfortables API zum Konfigurieren von Applikationen anbietet.

Dieser Vortrag zeigt, wie Apache Tamaya benützt werden kann, um ihre Microservices und Java EE Applikcationen zu konfigurieren. Die Mächtigkeit von Tamaya zeigt sich dabei nicht nur an den verfügbaren Erweiterungen, sondern ganz konkret dann, wenn wir neue Backend-Services (z.B. etcd) vollkommen transparent einziehen, ohne dass auch nur eine Zeile Code geändert werden muss. Höchste Zeit sich also das Projekt mal näher anzusehen!

Mit steigender Komplexität von Software-Systemen steigt auch die Komplexität die für den Aufbau einer Entwicklungsumgebung nötig ist. Wo früher für eine Webapplikation nur eine Datenbank für eine lokale Entwicklung nötig war, sind heute eine Vielzahl von Komponenten wie Messaging-Systeme, Suchserver oder andere Services für die Entwicklung nötig. Spätestens bei der Umsetzung von Mikroservice Architekturen ergeben sich hier noch deutlich größere Probleme bei der lokalen Bereitstellung der Umgebung.

Im Betrieb haben sich in den letzten Jahren deutliche Fortschritte in diesem Bereich ergeben. Tools wie Puppet und Ansible machen es heute relativ einfach, schnell große Software-Infrastrukturen bereitzustellen. Allerdings sind diese Projekte oft auf Produktionsumgebungen optimiert und bieten dem Entwickler für das Setup seiner Umgebung nicht immer die richtige Unterstützung.

In dieser Lücke entstehen derzeit zwei noch relativ junge Projekte, die es Software-Entwicklern ermöglichen schnell Infrastrukturen für ihre Entwickungen aufzubauen. Zum einen ist da docker-compose, welches eine Orchestrierung von Docker-Containern ermöglicht und über den reichhaltigen Fundes des Docker Hubs Zugriff auf eine Vielzahl von Projekten gibt. Ein anderer Vertreter ist otto. Dieses basiert auf dem populären Vagrant und ermöglicht mittels Convention over Configuration die schnelle Erstellung von applikationsspezifischen Umgebungen. Dabei wird gesamte Lebenszkylus der Software bis zum Deployment mit abgedeckt.

Im Rahmen des Vortrags werden die Vor- und Nachteile dieser Komponenten erläutert und dargestellt. Abschließend werden wir an einem realen Beispiel wie sich auf diese Weise Umgebungen erstellen und weitergeben lassen.

Der JPA-Standard ist in diesem Jahr 10 Jahre alt geworden. Längst hat er sich in Enterprise-Java-Architekturen etabliert.

Die Session zeigt, welche Probleme es gab und noch immer gibt und welche architektonischen Konzepte und Best Practices die vergangenen Jahre hervorgebracht haben. Als Fazit wird dabei gezeigt, wie man heutzutage mit JPA leichtgewichtige Anwendungen bauen kann und sich dabei Features wie Lazy-Loading, den Extended Persistence-Context und Transaction-Synchronization zunutze macht.

Webschnittstellen, zur Integration externer Partner und Anwendungen werden immer wichtiger. Das gilt nicht nur für erfolgreiche Plattformen, wie eBay, Twitter, Salesforce oder Amazon, sondern auch für die Anbindung mobiler Anwendungen.

Gerade Microservices-Architekturen setzen ein ausgefeiltes API-Management mit eingebautem Monitoring, Security und Verwaltung der API-Schnittstellen voraus. JBoss APIman bietet zusammen mit KeyCloak eine gute Möglichkeit ein API-Gateway auf OpenSource-Basis sicher umzusetzen. Artikel dazu im JAVAspectrum geschrieben.

Viele Organisationen haben in den letzten Jahren eine Plattform für Continuous Integration oder gar Continuous Delivery aufgebaut. Man kann auch die Plattform selbst nach dem Prinzip "Infrastructure as Code" erstellen und kontinuierlich reproduzieren und testen, sie also zum Gegenstand einer Continuous Delivery Strategie machen.

Damit lässt sich nicht nur die Funktionsfähigkeit der Plattform permanent prüfen und garantieren, sondern es können auch sehr leicht weitergehende Use Cases abgebildet werden, z.B. Weiterentwicklung/Upgrade einer Komponente, Integration neuer Komponenten/Plugins, Austausch einer Komponente. Außerdem lassen sich beispielsweise Mitarbeiter oder Entwickler damit schulen oder komplexe CI-/CD-Prozesse testen, wie das Release von Komponenten.

Im Vortrag wird eine Referenz-Plattform aus typischen Open Source-Komponenten, wie sie sich im Java-/Enterprise-Umfeld finden, vorgestellt:

- SCM-Manager (Source Code Management mit SVN, Git oder Mercurial)

- Nexus (Artifact-Repository)

- SonarQube (Qualitätssicherung/Historisierung)

- Jenkins (Build-Server)

Es wird zunächst demonstriert und erklärt, wie die die Plattform als virtuelle Maschine mit Vagrant und Puppet aufgebaut wird, die Komponenten werden dabei weitgehend als Docker-Container installiert. Anschließend wird gezeigt, wie die Plattform sich selbst reproduziert und dabei kontinuierlich einen Test-Prozess durchläuft. Zum Testen wird ein Java-basiertes Software-Paket als Referenz-Projekt von der automatisch errichteten Plattform gebaut. Ein Reproduktions-Zyklus ist abgeschlossen, wenn die Plattform das Referenz-Projekt erfolgreich bauen kann. Typische Ereignisse, die einen erneuten Durchlauf erfordern und anstoßen, werden diskutiert, u.a.

- Änderungen an den bestehenden Komponenten, z.B.,

- Einfügen neuer Jenkins-Plugins

- Update auf neue Versionen der Komponenten

- Änderungen am Build-Prozess des Referenz-Projekts.

Viele IT Teams stehen derzeit vor der Aufgabe ihre Systeme für die digitale Transformation fit zu machen. Die direkte Integration von Altsystemen in digitale Workflows und deren Anbindung an Webseiten stellt neue und andere Herausforderungen bereit. Nicht immer ist es direkt möglich oder sinnvoll diese System in moderne, skalierbare Architekturen zu überführen. Meist ergibt sich hier eine Lücke in der Belastbarkeit dieser Systeme gegenüber neueren Entwicklungen, welche von Anfang an auf Skalierbarkeit ausgelegt sind.

Um diese Systeme vor Belastungen, wie sie zum Beispiel bei plötzlich auftretenden Lastspitzen vorkommen, zu schützen ist es notwendig entsprechende Strategien einplanen. In diesem Vortrag möchte ich anhand mehrerer Beispiele aus der Praxis zeigen wie man mit diesem Problem umgehen kann. Neben Strategien zur schrittweisen Reduktion des Funktionsumfangs, werden Architekturen gezeigt die dem Legacy-System einen Puffer vorschalten und dieses im Zweifelsfall aus dem Betrieb nehmen. Dabei kommt unter anderem der Netflix Stack zum Einsatz, welcher zusammen mit Spring Cloud ein schnelle Entwicklung dieser Systeme ermöglicht. Nach Abschluss einer Sicherung dieser Systeme wird noch diskutiert, wie mittels des eingesetzten Technologiestacks eine Integration neuer Funktionalität möglich ist, ohne deren Code und Infrastruktur anpassen zu müssen.

Über Stock und Stein durch unbekanntes Terrain. Das Ziel: Schnelle Entwicklungsgeschwindigkeit.

Wir haben viele Umwege gemacht und hatten manche Panne. Ausrüstung, die wir für unentbehrlich hielten, erwies sich als Ballast. Aber es hat sich gelohnt! Für alle, die statt Lyrik lieber harte Fakten lieben: Architektur, Build, Testen, Deployment, Entwicklungsprinzipien.

Bugs are inevitable. In todays world with reactive and asynchronous programming they are harder to hunt down than ever.

Personal experience showed that not firing up the debugger all the time speeds up the bug hunt. The talk adresses the reasons behind this phenomenom and encourages to use your brain.

Software wird von AnwenderInnen besonders dann akzeptiert und eingesetzt, wenn sie deren Gewohnheiten und existierenden Tätigkeitsablauf unterstützen. Trotzdem ist das Einbinden von Human-Centered Design (HCD) in die Entwicklung noch keine Selbstverständlichkeit. Viele Projekte lassen die Betrachtung von Interessen, Fähigkeiten und Aktivitäten ihrer Zielgruppen außer acht.

Diese Projekte riskieren den Misserfolg ihrer Lösung, begründet durch knappe Ressourcen, den Fokus auf technische Herausforderungen oder fehlendes Wissen über HCD. In diesem Vortrag wird ein leichtgewichtiges Vorgehen präsentiert, um HCD erfolgreich in agile Softwareentwicklung zu integrieren. Der Trick gelingt durch eine passende Auswahl konkreter Schritte und einen gelegentlichen Fokuswechsel.

Kreative Berufe - wie Software-Entwicklung - lassen viele Spielräume, aber im Alltag wird das oft vergessen. Angst vor falschen Entscheidungen schränkt den Blickwinkel immens ein. Vorgaben des Managements werden viel zu häufig unreflektiert umgesetzt - aus Angst vor falschen Entscheidungen.

Wie viel Einfluss hat das Entwicklungs-Team? Wie weit reichen die Entscheidungen Einzelner? Wem gegenüber sind Entwickelnde verantwortlich? Wann haben wir eine Wahl und wann müssen wir tun, was “da oben” beschlossen wurde? Welche Dinge sollten wir anfangen, die wir “noch nie so gemacht” haben? Und warum werden wir eigentlich nicht gefeuert, wenn unsere Software floppt?

Verantwortung kann man nur übernehmen, wenn man eine Wahl hat. Und wer entscheidet muss sich zwangsläufig mit Moral auseinander setzen. Der Vortrag regt an, die Rollen im Unternehmen zu überdenken. Und er ermahnt dazu, Entscheidungen bewusst zu treffen. Denn letztlich müssen wir uns vor uns selbst verantworten. Und da schaden wir uns nur selbst, wenn wir zu faulen Ausreden greifen.

Fullstack-Java-EE-Anwendungen schreibt man mit JSF. Zumindest im Standard. Nun sind Browser schon lange nicht mehr einfache Remote-Displays, sondern führen mit JavaScript eine leistungsfähige und allgegenwärtige Programmumgebung mit sich.

Also dann HTML+JS+CSS, vielleicht mit ein bisschen AngularJS? Wie integriert sich das mit dem Java-EE-Backend? Und was ist mit Vaadin als serverzentrierter Präsentation ohne Zwang zu einer weiteren Sprache neben Java? Dieser Talk stellt diese Varianten anhand von Beispiel-Code gegeneinander und liefert Argumente für die Beantwortung der Frage, welches GUI-Framework wann und für wen am besten geeignet ist.

Wenn man sie pflegen muss hat man zu viele Assertions, wenn ein Fehler durchschlüpft zu wenige. Observational Diff (auch Characterization Test, Golden Master oder Approval-Test) ist ein innovativer Testansatz um dieses Problem zu lösen.

Die Idee besteht darin das gesamte beobachtbare Verhalten der Anwendung bei Testablauf aufzuzeichnen. Bei einer Änderung werden alle Unterschiede im aufgezeichneten Verhalten der Anwendung erkannt und dargestellt. Sind diese Unterschiede gewünscht, so wird (ähnlich einem Commit bei einem VCS) das neue Verhalten zur neuen "Wahrheit" und zukünftig Unterschiede zu diesem Verhalten aufgezeigt. Statt bei Tests einzelne Prüfregeln erstellen und pflegen zu müssen, und dabei doch nie alle Details erfassen zu können, erhält man durch ein Observational Diff quasi 100% Assertions bei minimalem Pflegeaufwand. In den Beispielen wird eine GUI mit Hilfe des Open Source Projektes ReTest getestet. Der Clou dabei: mittels Monkey-Testing kann man dafür die Tests sogar generieren. Monkey-Testing findet vollautomatisch und kostengünstig Fehler bzw. zeichnet das Programmverhalten auf. Durch die Kombination mit "Observational Diff" und wenn man diesen Affen etwas trainiert, kann man seinen Testaufwand locker halbieren und dabei noch die Qualität verbessern!

Microservices are now a trend and every new piece of software must be written following the Microservices’ architecture. But what if you already have a big monolith and don't want to rewrite it from scratch?

This talk will guide you in applying some of the Reactive Techniques to your JEE monolith in order to make it more resilient and responsive. Some of the key aspects that will be discussed are:

• Asynchronous messaging
• Embrace failure
• How to organize your services

Für das Releasen von Java-basierten Artefakten (JARs/WARs/...), die mit Maven oder Gradle gebaut werden, hat sich die Verwendung von Semantik Versioning (SemVer) weitgehend durchgesetzt. Typischerweise wird ein Release gebaut, wenn die Software eine gewisse Reife erreicht hat.

Continuous Delivery setzt jedoch auf das regelmäßige Ausliefern von Software, im Idealfall führt jede Änderung (Commit) zu einem Artefakt, das bis in produktive Systeme ausgerollt wird. Das Multi-Module-Maven-Release-Plugin (auch Releaser-Plugin genannt) kombiniert die Verwendung der Major-/Minor-Versionen von SemVer mit einer Build-Nummer statt der Patch-Version. So kann einerseits immer noch eine Schnittstellen-/Kompatibilitäts-Semantik in der Versionsnummer verankert werden, die Artefakte können aber auch kontinuierlich und unterscheidbar ausgeliefert werden. Der Vortrag stellt das Konzept an Hand einer Open Source-Software vor, die damit gebaut und geliefert wird und diskutiert eine dabei entstandene Erweiterungen des Moduls, nämlich die mögliche Definition von Abhängigkeiten als Snapshots und Verwendung von deren jeweils aktueller Version beim automatischen Releasen.