Asynchrone Nachrichten statt Methodenaufrufe, fachliche Actor-Hierarchien statt Schichtenarchitektur, Supervisor und "let it crash" statt langer Stack Traces, Zustand in Anwendungskomponenten statt zustandsloser Server, Sharding statt identischer Serverinstanzen - Akka erlaubt völlig andere Architekturen als z.B. Spring oder Java EE. Es bringt andere Trade-offs als klassische Komponentenframeworks mit und eröffnet eine weitere Sicht auf Architektur jenseits etablierter Patterns. Dieser Workshop gibt eine praxisorientierte, quelltextzentrierte Einführung in Akka. Wir bauen ein lauffähiges System, an dem wir reaktive Patterns kennen lernen und neue architektonische Wege ausprobieren. Die Beispiele sind vollständig in Java, aber wenn jemand die Übungen lieber in Scala implementieren will, unterstütze ich ihn dabei gern.
In diesem Workshop geht es zur Sache. Wir werden eine einfache Applikation mit Event Storming entwerfen und unseren Entwurf dann mit Java umsetzen. Wir wollen uns in diesem Workshop mit Event Storming als Modellierungswerkzeug und der Übertragung des so gewonnenen Modells in lauffähigen Code vertraut machen. Unseren gemeinsamen Entwurf werden wir als eventgetriebene Microservices-Applikation umsetzen. Hierbei werden die Techniken des Event Sourcings und der Command Query Responsibility Segregation (CQRS) zum Einsatz kommen. Das Lagom-Framework wird uns helfen, die Domain-driven-Design-Konzepte aus dem Event Storming (Command, Events, Aggregates, Policies) eins zu eins in eine funktionierende Anwendung zu überführen. Am Ende des Workshops werden die Teilnehmer/-innen nicht nur ein Grundverständnis von Event Storming, Event Sourcing und CQRS haben, sondern auch von wichtigen Konzepten und Herausforderungen der Microservices-Architektur. Teilnehmer/-innen bringen bitte ihren eigenen Rechner mit einer funktionierenden Java-8-Entwicklungsumgebung mit.
API-first-Design und API as a Service sind die neuen Trendthemen in den IT-Abteilungen. Als primärer Kommunikationspartner für Fat-, Mobile- und Webclients sind APIs das Rückgrat moderner verteilter Anwendungen. „From zero to hero“ ist unser Motto auf der Reise in die Welt des API-Designs, und nach dem Motto „API first“ starten wir in dem Workshop mit dem Design eines simplen API. Kaum haben wir die erste Version geschafft, widmen wir uns gleich größeren Herausforderungen wie einer immer aktuellen Dokumentation, Abwärtskompatibilität bei der Weiterentwicklung, Einsatz von Caching-Features und dem Aufbau erster Sicherheitsmaßnahmen. Lebensnahe Beispiele, jede Menge Best Practices und viel Code, der nahtlos in eigene Projekte übernommen werden kann, bilden die Grundlage für einen erfolgreichen Tag, an dem neue API-Designer geschaffen werden.
To make the complex, distributed and highly interconnected system landscapes of today robust, responsive and highly available, we need to implement resilience into them at application level. Many patterns for implementing resilience into an application exist. The daunting questions are how to slice (design) an application and which patterns to pick and combine in order to match your specific needs best.This workshop will address those questions in three parts:
* In the first part you will learn about the challenges how to design applications in a resilient way, get an overview about the resilience pattern landscape, learn some of the most important patterns and when to apply them.
* In the second part you will have the opportunity to apply the just learned contents to a real-life case study and design and discuss your own resilient solution.
* In the last part we will complete the workshop with a peek in some complementing topics, like some advanced patterns, a resilient design cycle and how to introduce the topic into the software development process.
After this workshop, you will have a much deeper understanding how to design solutions that satisfy your specific robustness needs.
Node.js ist erwachsen geworden und hat Einzug in die Server der Welt gehalten. Ein Grund für den Erfolg ist das Ökosystem, das sich um Node.js gebildet hat. Für nahezu alle Belange in der Applikationsentwicklung existiert ein Paket. In diesem Workshop bauen wir Schritt für Schritt eine Applikation auf, die von der Authentifizierung über Logging und Datenbankverbindungen bis hin zu Webschnittstellen viele der gängigen Anforderungen erfüllt. Neben der Implementierung der verschiedenen Features lernen Sie außerdem zahlreiche Best Practices der Node.js-Welt kennen und haben natürlich genügend Zeit, auch selbst Experimente mit der Plattform durchzuführen.
In diesem Java-9-Hands-on-Workshop werden die neuen Funktionalitäten jeweils mithilfe von PowerPoint zunächst eingeführt und im Anschluss durch praktische Übungen vertieft. Dabei werfen wir einen Blick auf Sprach- und Syntaxerweiterungen, einige nette Funktionalitäten in Streams und Optionals, aber auch auf Erweiterungen im Process API und bei der Unterstützung von HTTP/2. Zudem machen wir uns mit der JShell vertraut. Selbstverständlich dürfen die Modularisierung und Project Jigsaw als Themen nicht fehlen. Neben einem fundierten Einstieg werden die Beispiele schrittweise komplizierter. Schließlich wird auf das Management von Abhängigkeiten, die Realisierung von Services sowie die Möglichkeiten zur schrittweisen Migration eingegangen. Die Teilnehmer erhalten einen ersten Überblick über die mit Java 9 eingeführten Neuerungen und können so besser einschätzen, was sie später bei einem Umstieg auf Java 9 erwarten wird. Abgerundet wird der Workshop durch viele Übungen, einige Livedemos, einpaar Tipps und Tricks sowie verschiedene nützliche Hand-outs. Zudem erhält jeder Teilnehmer mein Buch "Java 9 – Die Neuerungen".
Angular ist eines der populärsten Frameworks für moderne webbasierte Geschäftsanwendungen. In diesem Workshop erfahren Sie von Manfred Steyer, Google Developer Expert (GDE), wie Sie damit große Projekte umsetzen können. Dazu wird eine vollständige Anwendung unter Berücksichtigung von Best Practices live entwickelt. Verschiedene Architekturansätze werden diskutiert und die einzelnen Building-Blocks im Detail betrachtet. Sie lernen die Ideen hinter den vorherrschenden Konzepten kennen und sehen, wie Sie aus der Welt von Java bekannte Strategien wie Dependency Injection, Datenbindung oder Komponentenorientierung mit Angular und TypeScript realisieren.
Vielen ist gar nicht klar, was ein Scrum Master den ganzen Tag so macht und was seine Hauptaufgaben sind. Wir versuchen anhand von verschiedenen Modellen eine Erklärung zu liefern und beantworten außerdem die Frage, wie viele Teams aus unserer Sicht ein Scrum Master überhaupt sinnvoll betreuen kann. Wir versuchen dabei die Rolle des Scrum Masters anhand diverser Quellen zu definieren und überlegen uns, welche Handlungen für Scrum Master geeignet sind und wann.
Jeder Jeck ist anders, jedes Unternehmen auch. Je nach Branche, Unternehmenskultur oder -größe haben Organisationen ihre ganz eigenen spezifischen Strukturen, Herangehensweisen und Prozesse. Die Kluft zwischen einer klassischen und einer agilen Unternehmensorganisation ist oft immens und erscheint auf den ersten Blick unüberwindbar. In seinem Vortrag erklärt Volker Schmidt, warum das Gelingen einer agilen Transformation bereits mit der Auswahl der passenden agilen Methoden anfängt. Er zeigt, warum sich manche Methoden für unterschiedliche Branchen und Unternehmen leichter umsetzen lassen als andere, und welche Kriterien Unternehmen bei der Auswahl beachten sollten. Was das konkret bedeutet, stellt er anhand eines Praxisbeispiels aus der Automobilbranche vor.
Scrum bietet einen effektiven Rahmen zur Selbstorganisation, der es agilen Teams erlaubt, optimale Wege zur Erstellung hochwertiger Software zu finden. So ergeben sich regelmäßig Fragen zu Anforderungsmanagement und Qualitätssicherung. Wie lassen sich grobe Anforderungen in passgenaue Lösungen überführen? Wie lässt sich maximale Qualität in kurzer Zeit erreichen? Der Vortrag zeigt, wie agile Teams kurze Concept-to-Market-Zyklen erreichen und wie sich das mit klassischem Anforderungsmanagement verträgt.
Agil ist klasse. Agile Praktiken, agile Prozesse, agile Organisationen, agile Menschen. Aber was bedeutet Agilität wirklich? Was soll denn eine agile Organisation sein, wenn sich das Manifest doch nur auf Softwareentwicklung bezieht? Kann man Agil uminterpretieren/erweitern oder gibt es da etwas, was zur lernenden Organisation führt? Diese Session klärt auf, was Agilität auf welcher Ebene bedeutet. Sie gibt Rat, wie sich ein Team oder eine Organisation entwickeln kann. Hierzu wird auf Organisation à la Heterarchie, Führung zur Selbstführung, Macht und Verantwortung eingegangen und am Beispiel der HEC gezeigt, mit welchen Schmerzen und Freuden dieses Unternehmen zur lernenden Organisation geworden ist.
Die DB Systel GmbH hat sich 2015 auf eine Reise in eine agile und selbstorganisierte Arbeitswelt gemacht. Was passiert aber, wenn agile Prinzipien, Strukturen und Arbeitsweisen auf eine klassische Führungskraft treffen? In seinem Beitrag gibt uns Thorsten Ziegler einen authentischen Reisebericht aus drei Jahren agiler Transformation der DB Systel. Wie hat sich das Verständnis von Führung verändert? Welche Anforderungen werden zukünftig an die Führungsrolle gestellt? Und braucht es überhaupt noch Führungskräfte in einem Netzwerk dezentral agierender, selbstorganisierter Teams?
Wer legt die Regeln in einem agilen Team fest? Das Team! Wer organisiert die Arbeitsabläufe im agilen Team? Auch das Team! Wer ist verantwortlich für die Qualität des Produkts? Sie ahnen es, wieder das Team! Agile Entwicklung ist nur sinnvoll umsetzbar, wenn sich die Teams selbst organisieren können. Nur wie sieht Selbstorganisation in der QS-Praxis aus? Wie findet man eine Entscheidung, wenn es unterschiedliche Ansichten gibt? Wie findet die Abstimmung teamübergreifend statt? Selbstorganisation bedeutet zwar mehr Freiheiten, aber auch mehr Verantwortung. Besonders bei der Qualitätsfrage ist eine einheitliche Abstimmung über agile Teamgrenzen hinweg notwendig. Brauchen wir einen End-2-End-Test? Gibt es Businessprozesse durch die Applikationen? Wer kümmert sich um die Fortbildung? Wo werden wie die Schnittstellen definiert? Benötigen wir ein einheitliches Testtool? Dieses alles und viel mehr war früher die Aufgabe der QM-Abteilung. Wer kümmert sich in der agilen Welt um diese Themen? Richtig, das Team. Aus der Erfahrung eines selbstorganisierten Unternehmens heraus beantworten wir die Fragen rund um die Selbstorganisation. Wie es funktioniert, wie gemeinsam Entscheidungen getroffen werden und wie Sie Ihre Qualität durch eine selbstorganisierte Qualitätssicherung verbessern, zeigen wir Ihnen. Damit am Ende Sie, das Team, entscheiden können: Wie wollen wir zusammenarbeiten? Welche Prinzipien sind uns wichtig und welche Werkzeuge benötigen wir dazu?
Man möchte agil werden, hat das Scrum- oder Kanban-Board aufgesetzt, aber irgendwie läuft es nicht richtig rund. Die Entwickler arbeiten nicht wirklich als Team zusammen. Bühne frei für Pair Programming, den alten Geheimtipp aus dem Extreme Programming (XP), und das darauf aufbauende Mob Programming! Seit einigen Jahren machen wir in zahlreichen Teams aus den unterschiedlichsten Bereichen gute Erfahrungen damit, Pair Programming aktiv zu fördern, indem wir den Teams zusätzlich zum üblichen Scrum- oder Kanban-Coaching ein Pair-Programming-Coaching anbieten. Denn wenn Entwickler einfach nur zu zweit vor einen Rechner gesetzt werden, kann das nach hinten losgehen. Wenn man aber ein paar grundlegende Verhaltensweisen übt, wird diese intensive Form der Zusammenarbeit als angenehm empfunden und unterstützt das agile Vorgehen nachhaltig. So sehr, dass wir immer wieder positive Auswirkungen auf die agile Planung und das kontinuierliche Testen sehen. Mittlerweile probieren die Teams vermehrt Mob Programming aus, um auch in größeren Gruppen effizient zusammenzuarbeiten. In diesem Vortrag stelle ich kurz die Grundlagen von Pair und Mob Programming vor: worauf man achten sollte und welche typischen Fallstricke es gibt. Zudem erkläre ich den Ablauf des Coachings - als Anregung und Hilfestellung, wie ein solches Coaching im eigenen Team durchgeführt werden kann.
We live in a competitive world. That competition forces change. It has always forced change. Change is normal. The question is not whether our organisations will change, that’s a given, but can we see this change before it hits us, do we know where we’re heading or are we simply floating aimlessly being carried by a river? It certainly feels that way sometimes. To answer the question we need to understand our landscape, the economic forces at play, the context we operate within and our situational awareness of this. Can we navigate the waters, can we see a storm coming or are we being battered by rocks because we refuse to look?
During this talk we will examine the level of situational awareness within business, why it matters and whether we can anticipate and exploit change before it hits us. We look into the changes that are occurring with the development of serverless, why now, what’s important to it and how it will change the way we do business. There’s a lot of fuss about serverless and in this session will try to paint a clearer picture or at the very least a map of where it is going.
Vielfach gleicht die Situation von Unternehmen im Wandel einem Mexican Standoff. Die Beteiligten verstehen, dass es an diesem Punkt nicht wie bisher weitergehen kann. Dennoch wagt niemand den ersten Schritt aus der Deckung. Funktionale Silos und hierarchische Strukturen haben über Jahrzehnte Unternehmenskulturen des Wettbewerbs geschaffen, in denen die meiste Energie in „Cover your ass“-Aktivitäten statt in kollaborative Zusammenarbeit zu fließen scheint. Die Folge: Stillstand und Verschwendung statt wertschöpfendes Arbeiten im Sinne des gemeinsamen Unternehmensziels. Dabei hat der Vorstand doch schon längst den kulturellen Wandel ausgerufen. Und in der Entwicklung werden bereits erste Services mit Docker in der Cloud betrieben. Wo bleibt das erhoffte Hochgefühl, das DevOps und Continuous Delivery versprechen? Dieser Vortrag setzt sich anhand von Beispielen mit verschiedenen Situationen von im Wandel befindlichen Unternehmen auseinander und gibt Handlungsempfehlungen für ein Umdenken von Entwicklern, Administratoren, Fachabteilungen und Managern. Das Ziel: gemeinsame Wertschöpfung mit harmonisierten Zielen statt absurder Kleingärtnerfehden.
Das Ziel eines jeden Sprints ist es, ein potenziell lieferbares Produktinkrement zu bauen. Und doch sind viele Teams nicht in der Lage, unmittelbar nach einem Sprint ihr Inkrement zu releasen. Sei es aufgrund von Reviews durch einen Fachbereich, einer externen QA oder anderer äußerer Einflüsse, die dafür sorgen, dass das Entwicklerteam innerhalb eines Sprints niemals ein echtes "Done" erreichen kann. Wir sprechen darüber, welche Hürden sich daraus ergeben, was man dagegen machen kann und wie man sich auch in komplexen Umfeldern einem echten “Done” annähern kann.
Beim Bauen von Softwaresystemen werden tolle Technologien, Programmiersprachen und Tools eingesetzt. Das ist gut und richtig und außerdem macht es viel Spaß. Dabei verlieren wir immer mal wieder aus den Augen, dass das Entscheidende für den Erfolg unserer Software nicht die Technik ist, sondern der Business Value, den wir für unsere Anwender erzeugen. Haben wir die Anforderungen der Anwender fachlich sinnvoll umgesetzt? Haben wir unsere Software so strukturiert, dass sie ohne viele Umbauarbeiten um neue Funktionalität erweitert werden kann? Skaliert unsere Software, wenn mehr und mehr Anwender anfangen, sie zu benutzen? In diesem Vortrag widmen wir uns den verschiedenen Ursachen und Missverständnissen, die unseren Fokus immer wieder vom Business Value weg zur Technik lenken, obwohl wir eigentlich wissen sollten, dass das kontraproduktiv ist.
Beim Bauen monolithischer Systeme nutzen Entwicklerteams eine Reihe typischer Muster, um die Interaktion verschiedener Systemteile zu implementieren. Behält man diese Interaktionsmuster bei, während man ein System aufteilt, ergeben sich oft große Komplexität und architektonische Nachteile, die oft die ursprüngliche Idee konterkarieren, die hinter der Aufteilung stand. Der Vortrag betrachtet ein konkretes Beispiel von Modulinteraktion in einem monolithischen System und identifiziert die Problemstellungen, die sich ergeben, wenn man dieses System in exakt dem gleichen Interaktionsstil aufteilt. Danach wird eine alternative Implementierungsstrategie für das monolithische System diskutiert, die die Modularität des Ursprungssystems stark verbessert und im Falle einer Aufteilung in unabhängige Teilsysteme zu einer besseren Architektur führt.
Continuous Delivery makes it possible to exploit findings of cognitive psychology and neuroscience to increase the productivity and happiness of our teams. This session will highlight fascinating academic research that answers:
• How can we improve willpower and decrease technical debt?
• Is the present bias real? How can we turn it to our advantage?
• Can you increase a team’s effective IQ?
• How do DevOps and Product Teams increase empathy, and what impact does empathy have on productivity?
The OECD and Bank Of England are both puzzled over missing productivity. Are we failing to exploit the benefits of modern technology by running our software businesses and teams as if they're post-war factories, rather than continuously delivering?
Deep Learning is one of the "hot" topics in the AI area - a lot of hype, a lot of inflated expectation, but also quite some impressive success stories. As some AI experts already predict that Deep Learning will become "Software 2.0", it might be a good time to have a closer look at the topic. In this session I will try to give a comprehensive overview of Deep Learning. We will start with a bit of history and some theoretical foundations that we will use to create a little Deep Learning taxonomy. Then we will have a look at current and upcoming application areas: Where can we apply Deep Learning successfully and what does it differentiate from other approaches? Afterwards we will examine the ecosystem: Which tools and libraries are available? What are their strengths and weaknesses? And to complete the session, we will look into some practical code examples and the typical pitfalls of Deep Learning. After this session you will have a much better idea of the why, what and how of Deep Learning, including if and how you might want to apply it to your own work.
Wer im Webbereich auf Kundenbedürfnisse eingehen möchte, hat im Versicherungs- und Bankensektor ein Problem: Es fehlt vielfach das hierfür nötige Tooling. Rasch und effizient neue digitale Produkte für das Web zu entwickeln, ist im Enterprise-Bereich eine gewaltige Herausforderung. Verteilte Teams, unterschiedliche Requirements, Maintenance, Security, regulatorische Anforderungen, unterschiedliche Designs – man kann hier sehr schnell den Überblick und damit auch Geld verlieren, das dann für die wichtigen Dinge fehlt: den Fokus auf die Wertschöpfung für Kunden zu legen.
Wir haben diese Herausforderung technisch gelöst, indem wir ein Framework entwickelt haben, das es uns erlaubt, den Kunden und das Feedback in den Fokus der Entwicklung zu stellen. Das auf Angular setzende Framework dbCORE gestattet es uns, neue Produkte rasch und effizient im Web abzubilden. Wie wir damit entwickeln, zeigen wir im Talk, der zu großen Teilen aus Live-Coding besteht.
Kubernetes ist der Industriestandard für Containerorchestrierung. Doch es ist mehr als ein weiteres Tool. Es ist die eierlegende Wollmilchsau der Containerinfrastrukturen. Dieser Vortrag/hands-on will zeigen, warum Kubernetes als zukünftige und alleinige Infrastruktur zum Container-Deployment gedacht werden sollte. Der Zugriff auf ein Kubernetes-Sluster ist vollkommen ausreichend, um die Container - mit allem drum und dran - zu betreiben. Der Entwickler bekommt nicht nur eine Umgebung, um seine Container hoch verfügbar auszurollen, sondern auch ein Life-Cycle-Management frei Haus. Richtig eingerichtet bringt Kubernetes viel mehr:
* Scaling aufgrund eigener Metriken
* Automatisches Verfügbarkeitsmonitoring
* Zentrales Logging
* Aufzeichnen aller Metriken
* Service Discovery
* Einfaches Einrichten des Load Balancers
* Dynamisches Volume-Management
Vereinfacht wird kein anderes Tool mehr gebraucht, um seine Container produktiv zu betreiben.
All die erwähnten Features lernen wir kennen, indem eine Beispielapplikation ausgerollt wird. Wir werden die grundlegenden Kubernetes-Objekte kennenlernen: Pods, Deployments, Services, Ingres-Ressourcen. Der Zuhöhrer soll am Ende des Vortrags mit den ersten Schritten zur Verwendung von Kubernetes vertraut sein. Auch soll klar werden, warum in Zukunft nicht mehr viel mehr als Kubernetes gebraucht werden muss.
Die SoftwarlLandschaft wird verteilter und komplexer. Um sie zu betreiben, entstehen mit der Zeit isolierte Monitoringlösungen - teils aus der Entwicklung, teils aus dem Betrieb, teilweise auch aus den Geschäftsbereichen getrieben. Mit der Zeit wird klar, dass diese Einzellösungen kein befriedigendes Gesamtbild ergeben, und es entsteht der Wunsch nach einer einheitlichen Lösung. Wir beschreiben, wie wir vorgegangen sind, um eine solche Monitoringlösung zu erhalten. Hierbei geht es neben der eigentlichen Entscheidungsfindung auch um die Integration in das Unternehmen und die zeitliche Dimension dieses Vorhabens.
Einsatzgebiete für leichtgewichtige Workflow-Engines oder Zustandsautomaten werden immer vielfältiger, entsprechend steigen die Anforderungen an deren Skalierbarkeit. Eine stetig steigende Anzahl an Nutzern, Systemen oder "Things" sorgt dafür, dass traditionelle Engine-Architekturen an ihre Grenzen stoßen, da sie auf Transaktionalität und relationale Datenbanken vertrauen. Über die letzten Jahre haben wir viele Aspekte verprobt und inzwischen eine Engine der nächsten Generation als Open-Source-Projekt bereitgestellt, die im Herz vollständig anders tickt. Im Vortrag möchte ich zeigen, wie eine solche Engine dank Event-Sourcing Zustand aus einem Event-Stream ableitet und horizontale Skalierbarkeit erreicht. Anhand konkreter Beispiele diskutiere ich Architekturoptionen und untermauere sie mit konkreten Codebeispielen. Ich zeige verschiedene Use Cases für Workflows und wie sie sich entwicklerfreundlich auch ohne grafische Oberflächen definieren lassen. Ich grenze diese Lösung zu Netflix Orchestrator oder AWS Step Functions ab und zeige, wie sich eine solche Technologie mit aktuellen Paradigmen wie z. B. Microservices verheiraten lässt.
Most nontrivial software systems suffer from significant levels of technical and architectural debt. This leads to exponentially increasing cost of change, which is not sustainable for a longer period of time. The single best thing you can do to counter this problem is to carefully manage and control the dependencies among the different elements and components of a software system. This session will first look at the major reasons why so many systems end up in an unmaintainable state and then look at different strategies for better code-organization. We will first consider module systems like Java 9 or OSGi. Then we will look a new innovative domain specific language to describe software architecture that allows to define an enforceable architectural blueprint for any software system. As a takeaway you will understand the limitations of module systems used for architectural purposes.
Wer durch die DTO-Hölle früherer J2EE-Versionen gegangen ist, als technikbedingt für jede Schicht eigene Datenklassen geschrieben und die Daten zwischen all diesen Klassen umkopieren musste, weiß, welche Vereinfachung uns Spring und Java EE vor über einem Jahrzehnt gebracht haben. Aber wenn wir uns unsere aktuellen Architekturen und Entwurfsstile wie hexagonale Architektur und Domain-driven Design anschauen, merken wir, dass wir doch wieder Adapter und Transferobjekte benötigen – beispielsweise im Anticorruption Layer eines Bounded Context. Wir müssen also weiterhin Daten zwischen ähnlichen Strukturen kopieren. Für solche Bean Mappings zwischen Entities, DTOs und vergleichbaren Strukturen wurden bisher oft die BeanUtils oder Dover eingesetzt, oder der Mapping-Code wurde mühsam von Hand geschrieben. Als Alternative bietet sich seit einiger Zeit MapStruct an, was den Mapping-Sourcecode als Annotationsprozessor zur Compile-Zeit generiert. Zur Laufzeit gibt es dann keine Reflection mehr, sondern typsicheres und schnelles Mapping. Dieser Vortrag stellt Version 1.2 von MapStruct vor, von den Grundlagen bis hin zu den flexiblen Mapping-Möglichkeiten. Wir werfen einen kurzen Blick auf die Integration mit Lombok. Und dazu gibt es diverse Tipps und Tricks aus der Praxis. Neben ein paar Folien wird es Live-Coding geben.
„Traditionelle Geschäftsmodelle stehen stark unter Druck und ein Wandel ist unausweichlich!“ Wer hat diesen Satz so oder so ähnlich nicht schon gehört? Doch was heißt das genau, und was kann ich tun, um den Wandel erfolgreich zu meistern? Natürlich kennen wir alle die immer wieder zitierten Beispiele von Uber, Airbnb oder Amazon. Doch diese sind meist junge Unternehmen, die digital gestartet sind. Was müssen nun Unternehmen mit traditionellen Geschäftsmodellen tun, um erfolgreiche digitale Unternehmen zu werden? Um dies zu verstehen, haben wir eine internationale Studie mit Fokus auf praktische Relevanz durchgeführt, deren Ergebnisse die Grundlage für diese Session bilden. Wir betrachten zunächst die Anforderungen, die die zukünftigen digitalen Geschäftsmodelle an Unternehmen stellen, sowie die wesentlichen Treiber für die Digitalisierung. Vor diesem Hintergrund werden dann die fünf Erfolgsfaktoren – D°5 – vorgestellt, die die Essenz für den Erfolg der digitalen Transformation bilden. Praktische Beispiele aus dem reichhaltigen Projektalltag des Vortragenden im Kontext verschiedener Transformationsprojekte zeigen, welche Handlungsmöglichkeiten sich aus den Erfolgsfaktoren für die eigene Firma oder das eigene Projekt ergeben.
In jedem Unternehmen gibt es eine IT-Landschaft, die aus vielen über Schnittstellen verbundenen Systemen besteht. All das soll nun modern, skalierbar und flexibel werden. Das heißt für viele Unternehmen, dass die IT-Landschaft auf Microservices umgestellt werden muss. In diesem Vortrag kläre ich auf, was den Unterschied zwischen einer serviceorientierten Architektur (SOA) und einer IT-Landschaft aus Microservices ausmacht, wie man seine Architektur auf Microservices vorbereitet und welche Vorteile und Herausforderungen bei dieser Umstellung bewältigt werden müssen.
Künstliche Intelligenz in der Bild- und Tonerkennung kann mittlerweile von allen großen Playern im Cloud-Business über kognitive Services bezogen werden. Geht es jedoch um die Analyse von Filmmaterial, so stehen diese Services noch am Anfang: Im Ideal soll der kognitive Service das Drehbuch hinter einem Film erkennen können. Hierzu muss er eine Reihe von Disziplinen kombinieren, um die entscheidenden Fragen zu beantworten: Wer ist gerade zu sehen und zu hören? Welche Eigenschaften haben diese Personen von ihren Emotionen bis hin zu ihrem Alter? Kann unterschieden werden, ob eine Person gerade einen Ball wirft oder fängt? Worüber wird gerade im Dialog geredet? Was ist im Umfeld der Personen zu erkennen? Das durch den kognitiven Service entstehende Drehbuch kann in weiterführenden (semantischen) Services weiter analysiert werden, um schließlich in Such- oder Empfehlungssystemen einzugehen.Der Vortrag gibt einen Überblick über die aktuell verfügbaren Services und analysiert auf Basis konkreter Beispiele deren Leistungsfähigkeit.
Aus dem ehemaligen „Drogen- und Waffengeld“ Bitcoin ist mittlerweile eine große Szene rund um die zugrunde liegende Blockchain-Technologie entstanden. Mit Ethereum ist eine neue Generation der Blockchain hinzugekommen, auf deren Basis sich mittels Smart Contracts nun auch automatisierte und programmierte Payments oder auch ganze Handelsplattformen abbilden lassen, für deren Erfüllung es keine Mittler wie Banken oder Händler mehr benötigt. Automobilkonzerne, Logistikunternehmen, jede größere Bank und jedes DAX-30-Unternehmen experimentiert mittlerweile mit der Technologie.
Wir wollen in unserer Session einen Rundumblick zur Technologie geben: von den Ursprüngen hin zu interessanten Anwendungsfällen, wie man sie mittels Smart Contracts umsetzen kann und auf welche Herausforderungen man dabei heute noch trifft.
Heutzutage ist es Best Practice, kontinuierlich zu bauen und auszuliefern sowie featurebasiert auf verschiedenen Branches zu entwickeln. Ein aktueller Entwicklungsprozess besteht aus Unmengen an Diensten, Werkzeugen, Plug-ins und Workflows, die alle ineinander greifen: IDE, Build-System, Binär-Repository, Versionsverwaltung, Issue Tracker, CI-System, Testwerkzeuge, etc. Als Entwickler möchte man jedoch möglichst wenig Aufwand damit haben, das Build-System zu konfigurieren, Branches anzulegen, Versionsnummern zu entkoppeln, Build-Jobs zu erstellen und Tickets zu pflegen. In größeren Teams mit paralleler Entwicklung von Features soll das CI-System möglichst schnell Feedback über die letzten Änderungen aller Branches liefern. Damit die Build Lanes parallel laufen können, müssen sie vollständig entkoppelt sein, um Konflikte mit zusätzlichen Ressourcen wie z.B. Datenbanken zu verhindern. Um dies zu erreichen, ist der Aufbau einer passenden Werkzeugkette unabdingbar, die an allen Stellen Erweiterungsmöglichkeiten und offene Schnittstellen bietet. Im Vortrag wird gezeigt, wie Eclipse, Oomph, Jenkins, Docker, Git, Nexus und Issue Tracker zusammenspielen und Maven nicht nur als Build-System, sondern auch als integrierende Komponente eingesetzt werden kann.
The past year or so has seen a flurry of activity around Java. Most notable was the announcement in September 2017 that Java EE platform was going to be migrating from the Oracle-led development and the Java Community Process (JCP) to the Eclipse Foundation. But other important announcements in 2017 included the creation of Eclipse MicroProfile (Java microservices), Eclipse OpenJ9 (Java VM), and Eclipse Deeplearning4j (machine learning). This is addition to the Eclipse Jetty, Eclipse Vert.x, Eclipse Collections, Eclipse IoT, and other foundational Java technology projects hosted at the Eclipse Foundation. This talk will walk through the Java technologies being worked on at the Eclipse Foundation, and discuss our community's vision for open innovation for the Java ecosystem in the future. Together we can ensure that Java remains at the forefront of the software industry for many years to come.
Derzeit wird viel debattiert, wann Serverless und wann Kubernetes verwendet werden sollte, um Cloud-native Applikationen zu entwickeln. Beide Optionen haben Vor- und Nachteile, die Entwickler berücksichtigen sollten, wenn sie neue Applikationen designen. In dieser Session werde ich die beiden Technologien bezüglich der folgenden Themen vergleichen: Szenarien, Programmiersprachen und Werkzeuge, Produktivität von Entwicklern, Skalierbarkeit, Performance, Deployment Möglichkeiten, Verlässlichkeit der Technologien und anfallende Kosten. Des Weiteren werde ich demonstrieren, wie serverlose Funktionen mit Docker implementiert werden können und wie Aufrufe zwischen Microservices in Kubernetes-basierten Applikationen mit Istio gemanagt werden können.
Software engineering and technology is about constant evolution, which mainly involves continuous improvement.
And in order to achieve it, there is long path ahead of us, which many times is not easy to follow up.
Jump onboard in this journey about common (or not) software enginnering disasters, failures and mistakes and how we can get the most out of those lessons in order to learn and write/develop better software.
Spring Framework 5 is here, along with Spring Security 5, Spring Data Kay and Spring Boot 2! One of the most exciting introductions in this generation of Spring is reactive programming, building on Project Reactor to support message-driven, elastic, resilient and responsive services. The new Spring WebFlux framework integrates an MVC-like component model for reactive processing as well as functional reactive endpoints. We'll look at the new Netty-based WebFlux runtime and also discuss the use of reactive programming patterns with existing technologies such as Spring MVC.
Agile Softwareentwicklung bringt hohe Dynamik in die Prozesse der Softwareentwicklung. Innerhalb von Sprints werden potenziell releasefähige Softwareinkremente erstellt. Voraussetzung für die Releasefähigkeit ist eine sehr hohe Qualität der erstellten Software. Dieser Vortrag zeigt praxiserprobte Ansätze zur Erreichung maximaler Qualität in agilen Projekten.
Rufen wir uns nicht alle gerne die traumatischen Erinnerungen von manuellen Builds, Tests und Deployments ins Gedächtnis? Wünschen wir uns die Zeiten des Monitoring via SSH und tail zurück? Nein, tun wir natürlich nicht. In Zeiten von GitLab gehören diese neurotischen Zusammenbrüche auch der Vergangenheit an. Wer Software noch manuell baut, ist arm dran und ein schlechter Mensch. Machen wir die Welt zu einem besseren Ort und schauen uns den aktuellen Stand des GitLab-Masterplans II mit seiner verfügbaren Bandbreite an Möglichkeiten näher an. Wir präsentieren eine vollständige DevOps-Pipeline und gehen auf automatische Builds und Tests ein. Es folgt ein Blick auf Code Quality und verschiedene Aspekte automatischer Deployments, wie Review-Apps, inkrementelle Rollouts und Rollbacks. Außerdem beleuchten wir, welche Businessaspekte einer solchen Pipeline vorausgehen und nachfolgen, angefangen mit der Erstellung von Tickets, bis hin zu Businessmetriken, Monitoring und Canary-Release. Bekanntlich ist Freude nur ein Mangel an Information, sodass auch die momentanen Grenzen, Stolpersteine und Alternativen des Ansatzes von GitLab in dieser Session nicht vorenthalten werden.
In a world where most companies claim to be data-driven the ingestion pipeline has become a critical part of everydays infrastructure. This talk will explore the mechanics of past, current and future of data processing pipelines with special emphasis in common challenges such as how to scale data consumption across teams, assuring reprocessing, optimal performance, scalability and reliability, etc. During this presentation we will analyse architecture patterns, and antipatterns, stream or batch organizations and the complexity of different data transformation graphs. By the end of it you will take home a collection of do’s and don’ts ready to be applied to your day job.
Als Designtechnik ist Event Storming momentan der letzte Schrei. Nur mit haufenweise Klebezetteln ausgerüstet, treffen Entwickler und Anwender aufeinander. Innerhalb von sehr kurzer Zeit bauen alle Teilnehmer ein gemeinsames Verständnis der Domäne und der Prozesse auf. Der Schwerpunkt wird dabei zunächst auf die Domain Events gelegt, also das, was in der Fachlichkeit geschieht. Weil die Methode so leichtgewichtig ist, fokussiert sie uns das, was wirklich wichtig ist: weg von Technologie und Werkzeugen hin zur Domäne. Besonders spannend: Die Ergebnisse der Event-Storming-Sessions geben uns schon konkrete Implementationshinweise. Und das Ganze auch noch mit einer Menge Spaß. In dieser Session zeige ich kurz, wie Event Storming funktioniert und wo man es einsetzt. Dann setzen wir es mit den Teilnehmern direkt in der Praxis an verschiedenen Beispielen um.
Mal ehrlich, "Management" ist aktuell nicht leicht: Selbstverwirklichung in der Generation Y, intrinsische Motivation stärken, attraktive Mitbewerber und wenig Auswahl am Personalmarkt.
Mit Management 3.0 werden bereits viele wichtige Bereiche unseres Managementalltags adressiert. Wir sollen Mitarbeiter nicht wie Maschinen behandeln, sondern führen. Wir sollen Verantwortung in die Teams delegieren und am Ende für komplexe Fragestellungen gemeinsam eine Lösung auf Augenhöhe finden.
Und dann kommt da auch noch das lästige Thema Gehaltsfindung auf den Tisch. Der fast schon dogmatische Ansatz von M30 - die Gehälter aller Mitarbeiter offen zu legen und eine Gehaltsformel zu erstellen - ist nur in den wenigsten Fällen realisierbar. Wir haben uns daher für einen einfachen, pragmatischen Weg entschieden, der ebenfalls den Grundprinzipien von Fairness, Delegation und Selbstorganisation von M30 entspricht.
Erfahrt in diesem Vortrag eine von uns iterativ entwickelte, neue und zugleich spannend-praxiserprobte Möglichkeit der Gehaltsrunde und welche grundlegenden Fehler wir bereits für euch gemacht haben.
Nur wenige Themen werden aktuell so heiß gehandelt wie Continuous Delivery, Cloud und Container. Viele assoziieren Ersteres typischerweise mit der Entwicklung einer Applikation und Letzteres mit dem Betrieb eben dieser. Dabei entsteht die wahre Stärke dieser Technologien erst durch deren Kombination.
In dieser Hands-on Session stellen wir mit Red Hat OpenShift eine beliebte Plattform zum Einstieg in die Welt von Cloud und Containern vor. An praktischen Beispielen zeigen wir die Kombination mit GitLab CI zur Realisierung einer nahtlosen und dynamischen Continuous-Delivery-Umgebung.
Dieser Vortrag richtet sich an jene, die eigene Dockerimages bauen wollen, damit quasi eigene Pakete im Docker Ecosystem ausgerollt werden sollen und können. Auch wenn dieser Talk hands-on gedacht ist, gibt es anfangs noch etwas Theorie. Wir werden etwas über Layerkonzept, Registries und Deployments erfahren. Der Haupteil wird mit dem Bau von konkreten Images verbracht. Neben den Grundlagen des Image-Baus werden selbstredend Best Practices vermittelt. Auch werden wir uns anschauen, wie Images in Proxyumgebungen gebaut werden. Unter der Verwendung von Multistage Builds sind wir in der Lage, einfache Images zu bauen, ohne die Entwicklungsumgebung mit in Produktion ausrollen zu müssen. Spätestens am Ende des Vortrags sollten die Teilnehmer schon am eigenen Laptop eigene Images bauen wollen.
When working as a software developer — as well as in any other job — it’s important to be productive and to get things done. You want to increase your development speed, focus on what adds value and cut out all the cumbersome, boring and repetitive tasks. This session shows twenty ways of how to accomplish the goal of being more effective and efficient as a software developer using certain tools, approaches and mindsets.
Softwareentwicklung bedeutet schon immer auch den Umgang mit Daten - praktisch jede Software ist ein Datenverarbeitungssystem. Der Fokus liegt traditionell auf dem handgeschriebenen Code, die Daten werden von diesem bearbeitet, verändert und gegebenenfalls auch gewonnen. Durch immer größere verfügbare Datenmengen und neue Durchbrüche in der künstlichen Intelligenz erreicht Machine Learning (ML) auch zunehmend die Geschäftswelt. Nun stehen die Daten am Anfang des Entwicklungsprozesses, und aus Daten werden Softwarekomponenten erlernt, die das Verhalten des Gesamtsystems genauso beeinflussen können wie bisher nur der geschriebene Quelltext. Statt Code, der manuell erstellt und Schritt für Schritt nachvollziehbar ist (bzw. sein sollte...), steht eine Datenbasis, die ein System trainiert, das dann wiederum Daten verarbeitet.
Das Training wird also zu einem neuen Entwicklungsschritt, Daten werden genauso wichtig für das Funktionieren des Systems wie der Sourcecode. In diesem Vortrag geht es darum, welchen Einfluss dies auf die Softwarearchitektur, das Projektmanagement, Arbeitsabläufe im Team und die Projektinfrastruktur vom CI-System bis zum Deployment haben kann.
Mobil war gestern, heute braucht jeder einen Alexa-Skill. So ungefähr könnte die Flut von Skills im Store von Amazon erklärt werden. Denn Alexa erfreut sich steigender Beliebtheit, und das nicht nur im privaten Umfeld, sondern auch in Unternehmen. Die starke Verbreitung hat nicht nur mit der Einfachheit des Systems zu tun, sondern sicherlich auch mit dem breiten Angebot an Skills, den Apps für Alexa. Doch was steckt dahinter? Wie wird so ein Skill entwickelt? Wie kommt ein Skill zum Kunden? In diesem Talk beleuchten wir die Anatomie eines Skills und zeigen am Beispiel eines der größten Logistikunternehmens die Entwicklung von Skills in Java auf Basis der Serverless Computing Platform AWS Lambda.
Scala unterstützt verschiedene Programmierparadigmen, darunter vor allem Objektorientierung und funktionale Programmierung. Für viele Projekte bietet sich ein pragmatischer Mix mit hohem OO-Anteil an, aber es lohnt sich durchaus, sich auch mit der reinen funktionalen Programmierung zu beschäftigen. Genau das werden wir in diesem Vortrag tun, wobei wir die Cats-Bibliothek verwenden und zahlreiche Codebeispiele anschauen werden.
Kleinere Zyklen, kleinere Teams, kleinere Komponenten – Hauptsache kleiner und schneller und bloß keine Projekte mehr! Denn der neue Most Valuable Player in der IT ist das MVP: Minimum Viable Product. Start-ups und das Silicon Valley nutzen das MVP bereits erfolgreich für Produktentwicklungen und Innovationen. Nun versuchen vermehrt etablierte Unternehmen, den MVP zu adaptieren, und stehen doch häufig vor der Fragestellung, was eigentlich ein MVP ist und wie man ihn findet. Dieser Vortrag setzt sich anhand von Beispielen mit den größten Irrtümern rund um das Minimum Viable Product auseinander und gibt Handlungsempfehlungen für die erfolgreiche Ablösung von Projekten in der Softwareentwicklung durch das MVP und die miteinhergehenden Vorgehensweisen.
"Schneller Software deployen ist ein wichtiger Wettbewerbsvorteil", so heißt es oft. Also gilt es: Entweder die Firmen setzen Continuous Delivery um oder sie verschwinden vom Markt. Aber in der Realität haben viele Organisationen den Sprung zu schnellen Deployments noch nicht geschafft. Warum nicht? Wenn es so viele nicht tun, ist es dann überhaupt relevant? Dieser Vortrag beschäftigt sich mit der Frage, warum Continuous Delivery in der Praxis nicht funktioniert und was wir dagegen tun können. Die möglichen Maßnahmen sind technologische Tricks, aber vor allem auch organisatorische Maßnahmen und Vereinfachungen.
Dieser Vortrag basiert auf einem Fallbeispiel: Wir nehmen uns eine bestehende, aber fiktive, Baufinanzierungsapplikation vor, die monolithisch entwickelt wurde und historisch gewachsen ist. In dieser Java-Anwendung befinden sich allerlei Fallstricke, die üblicherweise in einem solchen Monolith vorkommen und die eine Migration erschweren.Die Session zeigt ihnen wie Sie mithilfe zahlreicher Werkzeuge aus dem "Domain-driven Designkoffer" eine solche Migration angehen können. Wir starten mit der Context Map, die uns einen detaillierten Blick auf die Liefer- und Leistungsbeziehungen in dem Monolithen gibt. Auf Basis dieser Context Map werden wir schon früh erkennen, welche Teile sich gut auslösen lassen und wo wir auf Probleme laufen werden. Dann leiten wir auf dieser Basis einen Schritt für Schritt Transformationsplan ab. Dieser wird dann Schritt für Schritt im Code mithilfe von Aggregaten und Bounded Contexts durchgezogen sodass wir am Ende der Session einen in Microservices zerlegten Monolith vorfinden werden. Der Vortrag wird aus wenigen Folien und viel Praxis bestehen.
In March 2017, hackers took three days to identify and exploit a new vulnerability in Equifax’s web applications. In the post-Equifax world, moving new business requirements (e.g., a non-vulnerable version of Struts2) into production in under three days might just be your new normal. Join this session to better understand how DevSecOps teams are applying lessons from W. Edwards Deming (circa 1982), Malcolm Goldrath (circa 1984) and Gene Kim (circa 2013) to improve their ability to respond to new business requirements and cyber risks. It starts with emphasizing the performance of the entire system and never passing known defects downstream. To that end, DevOps teams are consuming billions of open source components and containerized applications to improve productivity at a massive scale. The good news: they are accelerating time to market. The bad news: many of the components and containers they are using are fraught with defects including critical security vulnerabilities. In this session I will share lessons that Deming employed decades ago to help us accelerate adoption of the right DevSecOps culture, practices, and measures today.
Java EE, cloud-native and service meshes — this doesn’t really sound like a good fit. Or does it? Is it possible to develop modern, cloud-native Java Enterprise applications that fulfill concerns such as scalability, monitoring, tracing, or routing — without implementing everything ourselves? And if so, how to do this?
This session shows how to develop Java EE applications in a modern, cloud-native world using Java EE 8 and MicroProfile. I will live-code a mesh of applications, managed by Kubernetes and Istio. We will integrate concerns such as configuration, monitoring and tracing in a lean way, using Prometheus and Zipkin. We’ll see how the cloud-native technologies integrate with our stack and how the concepts behind container orchestration and service meshes actually fit the Java EE approach very well. All of the time will be spent live-coding while explaining the concepts and solutions.
Wer Microservices entwickelt, ist sicherlich schon einmal in Verzweiflung geraten, als er sein API verändern wollte, aber nicht mehr wusste, welche Teams seine Services benutzen. Einfach Brute Force ändern und auf die Schläge warten, ist nicht zeitgemäß. Consumer-driven Contracts ist ein Verfahren, bei dem die Consumer eines API dem Producer dieses API in Form von Kontrakten ihre Wünsche an das API mitteilen. Dieser muss dann dafür sorgen, dass diese Verträge eingehalten werden. Spring Contract stellt im Rahmen von Spring Boot und Cloud ein Framework zur Verfügung, das dieses Vorgehen für REST und Messaging genial umsetzt. Es versorgt den Producer mit Unit-Tests, die er gegen sein API laufen lassen muss. Außerdem werden aus diesen Tests ein Mock-Server in Form einer JAR-Datei erzeugt, die der Consumer wiederum nutzen kann. Spring Contract sorgt für die Konsistenz der einzelnen Artefakte und setzt zur Definition der Kontrakte Groovy DSL ein. Der Vortrag demonstriert und erklärt die Verwendung dieses Ansatzes mit Spring Cloud.
Maschinelle Lernverfahren (ML) versprechen einfache Lösungen für viele Entscheidungs- und Optimierungsprobleme. Auf dem Weg von der Idee zur operativen künstlichen Intelligenz (KI) müssen dabei aber zunächst einige Hürden überwunden werden. Gesunder Menschenverstand allein reicht hierbei leider nicht aus. Für eine praxistaugliche KI bedarf es vielmehr eines Perspektivenwechsels. Man muss sich zum Beispiel die Frage stellen: Welche Problematiken ergeben sich aus der Sicht des Computers? Im Vortrag identifizieren wir typische Problemstellungen anhand eines konkreten Beispiels und zeigen Lösungen dafür auf. Mit Themen wie Machbarkeitseinschätzungen, Verfügbarkeit von Daten und Modellierung von Problemstellungen behandeln wir Fragen, die sonst in den Codebeispielen der ML-Toolkits häufig zu kurz kommen.
Datenzugriffe ohne Joins und Queries? Konsistenz ohne Transaktionen? Cassandra erfreut sich zunehmender Beliebtheit, hat aber einen völlig anderen Fokus als relationale Datenbanken, und gewohnte Architekturmuster funktionieren damit nicht. Diese Session erklärt, wie Cassandra-Knoten miteinander kommunizieren und was das für die Verwendung bedeutet bzw. bedeuten sollte. Sie zeigt, wie man die Stärken von Cassandra in der Praxis nutzen kann und wie man Architekturen bauen kann, die das nutzen. Sie zeigt aber auch, wo es an Grenzen stößt und einfach die falsche Wahl ist.
Nicht erst seit dem Hype um Microservices ist Schnittstellendesign ein essenzieller Bestandteil von Softwareentwicklung. Doch jede noch so gut definierte Schnittstelle kann an einen Punkt kommen, an dem sie weiterentwickelt werden muss. Sei es nur, weil sich die Anforderungen geändert haben. Kommt man an diesen Punkt, stellt sich die Frage: Muss ich meine Schnittstelle versionieren? Wenn ja, wie gehe ich vor? Wie müssen sich die Clients der Schnittstelle verhalten, um nicht plötzlich (nach einem neuen Release des Servers) eine böse Überraschung zu erleben? Die Weiterentwicklung einer Schnittstelle wird leider initial häufig nicht mit bedacht. Hoher Wartungsaufwand für die Bedienung alter und neuer Schnittstellen sind die Folge. Wie kann ich das verhindern? Wie muss ich bei der Weiterentwicklung vorgehen, um alte Clients nicht inkompatibel werden zu lassen und dennoch nicht in der Versionierungshölle zu landen? Diese und weitere Fragen werden in dieser Session beantwortet. Dabei werden die Konzepte nicht nur in der Theorie beleuchtet. Am Beispiel von JAX-RS zeige ich, wie Versionierung in der Praxis realisiert werden kann, ohne sich im Support alter Versionen zu verlieren.
Have you ever tried to visualize a system you are working on? There are lots of tools that can help, they create nice diagrams (UML) or charts. They work, but after a while are boring. Because they are flat! Thanks to the new toys such as Oculus Rift or HTC Vive you can see the things from a new perspective. You can actually immerse yourself in code. Imagine: you can walk around the classes and touch methods with your hands. That is a crazy experience... a toy - but maybe a revolution and new way of looking at dashboards, diagrams ..and maybe your future IDE. I will show you my experiments and how to quickly build similar ones with webvr and aframe framework.
Du bist in der IT-Branche tätig und fragst dich, wie du deine Kinder (ab 4 Jahre) für die Informationstechnologie begeistern kannst? Dann bist du in dieser Session genau richtig, denn hier erfährst du von verschiedenen Ansätzen und Technologien, die von Brettspielen bis hin zu Robotern reichen und sich an unterschiedliche Altersgruppen richten. Gerne kannst du sie auch nach der Session selbst ausprobieren. Mit dem klassischen "Hello World!" braucht heute niemand mehr seine IT-Karriere zu beginnen. Die ersten Schritte dürfen ruhig viel Spaß machen!
Asynchrone Programmierung kann leicht zu unüberschaubaren Callback-Kaskaden oder zu langen Promise-Ketten führen. Einige Programmiersprachen, wie Go und Clojure, haben mit Koroutinen ein einfaches Modell integriert, um asynchrone Abläufe synchron erscheinen zu lassen. Kotlin unterstützt Koroutinen durch eine einfache syntaktische Erweiterung der Sprache im Zusammenspiel mit Bibliotheken. Viele asynchrone Kommunikationsmuster (Aktoren, Async/Await, reaktive Queues etc.) werden auf der Basis von Koroutinen unterstützt. Der Vortrag zeigt anhand von Beispielen, wie man die neuen Möglichkeiten benutzt, und wirft einen Blick hinter die Kulissen.
Viele Softwareprojekte verwenden Build-Pipelines, einschließlich Tools wie Jenkins, SonarQube, Artifactory etc. Häufig werden diese Pipelinetools jedoch manuell installiert und verwaltet. Bei diesem Ansatz gibt es bestimmte Risiken, und im Fall eines Ausfalls dauert es oft lange, bis eine laufende Pipeline wieder hergestellt werden kann. Diese Session zeigt, wie man die Erstellung einer Build-Pipeline automatisieren kann. Mit Terraform wird eine Docker-Infrastruktur lokal und in AWS erstellt, in der Jenkins, SonarQube und Artifactory vorkonfiguriert und deployt werden. Die Pipeline ist in wenigen Minuten betriebsbereit, wie ich in einer Livedemo demonstrieren werde.
Daten werden schon lange nicht mehr ausschließlich in relationalen Datenbanken gespeichert. Denn es haben sich einige NoSQL-Datenbanken am Markt etabliert, die für bestimmte Anwendungsfälle einfach besser geeignet sind. Entsprechend vielfältig sind die Persistenzlösungen, aus denen wir als Entwickler oder Architekten bei der Erstellung moderner Anwendungen wählen können. Dabei stellt sich natürlich immer häufiger die Frage, welches System für den jeweiligen Anwendungsfall geeignet ist und wie die Daten darin persistiert werden können. Wir möchten in diesem Vortrag daher einen Überblick über traditionelle RDBMS, CouchDB, MongoDB und Cassandra geben, deren Besonderheiten und Einschränkung betrachten und zeigen, wie Java POJOs darin persistiert werden können.
Als Designtechnik ist Event Storming momentan der letzte Schrei. Nur mit haufenweise Klebezetteln ausgerüstet, treffen Entwickler und Anwender aufeinander. Innerhalb von sehr kurzer Zeit bauen alle Teilnehmer ein gemeinsames Verständnis der Domäne und der Prozesse auf. Der Schwerpunkt wird dabei zunächst auf die Domain Events gelegt, also das, was in der Fachlichkeit geschieht. Weil die Methode so leichtgewichtig ist, fokussiert sie uns das, was wirklich wichtig ist: weg von Technologie und Werkzeugen hin zur Domäne. Besonders spannend: Die Ergebnisse der Event-Storming-Sessions geben uns schon konkrete Implementationshinweise - und das Ganze auch noch mit einer Menge Spaß. In dieser Session zeige ich kurz, wie Event Storming funktioniert und wo man es einsetzt. Dann setzen wir es mit den Teilnehmern direkt in der Praxis an verschiedenen Beispielen um.
Die neuen serverlosen Plattformen ermöglichen es Entwicklern, sich auf das Erstellen neuer Applikationen anstatt auf das Management von Infrastrukturen zu konzentrieren. Apache OpenWhisk ist eine solche serverlose Plattform und Open Source verfügbar. In dieser Session werde ich demonstrieren, wie man serverlose Funktionen mit Java und JavaScript entwickelt. Des Weiteren werde ich zeigen, wie Funktionen auch mit Docker implementiert werden können, sodass weitere Sprachen wie Kotlin und TypeScript verwendet werden können. Während Funktionen keinen State haben, können serverlose Applikationen State und den Datenfluss zwischen mehreren Funktionen managen. Diese Cloud-nativen Applikationen können entweder deklarativ oder programmatisch erstellt werden. Die potenziell polyglotten Applikationen können zum Beispiel in der IBM-Cloud deployt werden.
Cloud-native Entwicklung ist praktisch. Viele Konferenzen haben eigene Tracks zu Cloud-native und berichten über interessante Dinge, auf vielen Blogs wird über Vorteile und Patterns zur Cloud-nativen Entwicklung geschrieben. Diese Vorteile möchten viele Entwickler in ihren Projekten und Produkten sehen. Bei der Einführung der neuen Konzepte werden oft Kompromisse eingegangen, die das Ergebnis deutlich von den Vorstellungen abweichen lassen.
In diesem Vortrag beleuchten wir viele Ansätze, die in Projekten und Produkten eingesetzt werden, um Cloud-native Entwicklung umzusetzen. Wir geben konkrete Einblicke in unsere Projektpraxis bei vielen verschiedenen Kunden, Branchen und uns selbst. Dabei zeigen wir, welche Kompromisse, Abkürzungen und Überlegungen häufig getroffen werden und welche Auswirkungen sie haben. Wir wollen euch Learnings aus den Negativ- und Positivbeispielen vermitteln und dafür sorgen, dass ihr euch einige Frustration sparen könnt, durch die andere bereits gegangen sind.
The Spring Framework originated from a book in 2002, becoming the most widely used application framework in the entire Java ecosystem within a few years... and holding that position to this day. This talk illustrates Spring's evolution over fifteen years, adapting not only to five new JDK generations but also to ever-changing requirements in modern enterprise architectures.
While programmers tend to divide themselves into communities along language or paradigm lines, the reality is that the OO and FP communities have a great deal to learn from each other. As developers, we should learn classic OO, learn classical FP, and then strive to rise above them both.
Spring Framework 5.0 brings a lot of new features all across the framework: functional and reactive as major programming model themes but also some less prominent and less commonly presented features. This session summarizes the major feature themes and particularly highlights personal favorites and useful refinements in the details. Last but not least, it will indicate next steps in the upcoming 5.1 release.
Ihr Kunde fordert mal wieder “nur eine kleine Änderung” in der Aufbereitung der Daten. Und nach ein paar Stunden oder Tagen stellen Sie fest, dass sich das nicht so leicht im Code umsetzen lässt. Hätten Sie doch besser den Datenbankzugriff angepasst! Die gute Nachricht ist, dass es in vielen Fällen schon ein Hibernate-Feature gibt, das Ihnen den Großteil der Arbeit abnimmt. Eine Annotation oder wenige Zeilen Code reichen aus, um Multi-Tenancy zu implementieren, datenbankspezifische Datentypen zu unterstützen, SQL-Schnipsel auf Entitäten abzubilden, die Elemente einer Assoziation in einer vorgegebenen Reihenfolge zu lesen, UUIDs zu generieren und als Primärschlüssel zu verwenden sowie Änderungen in einem Auditlog zu dokumentieren und vieles mehr.
Unabhängig davon, ob die Quelle von Sensoren, Social Media oder Internet of Things (IoT) stammt, werden Ereignisströme und ihre schnelle und effiziente Handhabung immer wichtiger. Ereignisse müssen rasch und sicher entgegengenommen, verteilt und analysiert werden. Wenn man aber schnell auf eine Situation reagieren will oder muss, ist es nicht zielführend, die Daten erst zu speichern und danach zu analysieren. Die analytischen Operationen müssen direkt auf dem Ereignisstrom durchgeführt werden, wenn sich die Daten noch in Bewegung befinden (als Data in Motion bezeichnet). In dieser Session werden zwei bekannte und populäre Stream-Processing-Frameworks miteinander verglichen: Spark Structured Streaming und Kafka Streams. Wie unterscheiden sich die Frameworks voneinander, wo sind sie ähnlich? Was sind die Alleinstellungsmerkmale der Lösungen? Wie lassen sie sich in eine Big-Data-Umgebung integrieren? Diese und weitere Fragen werden in dieser Präsentation beantwortet.
Node.js is a lightweight but yet capable platform for creating powerful web applications. The core of Node.js is kept small and restricted to a limited functionality that is extended by a vast ecosystem. With the right combination of packages you are able to build full-featured web applications. There is nearly no limit in features starting with simple problems such as authentication or logging over web interfaces with REST or GraphQL to a whole application based on a microservice architecture. In this talk I will introduce you to some commonly used packages and show you how to use them by example.
Alle schwärmen von der Cloud, aber wie bekomme ich meine alten Applikationen in diese schöne neue Welt? Dieser Vortrag beschreibt die Migration anhand einer fünf Jahre alten Webanwendung. Diese ist mit Wicket realisiert und läuft auf einem Jetty 6. Wir werden Schritt für Schritt die Anwendung containerisieren und auf einen Kubernetes-Cluster in der Cloud migrieren. Wir werden dabei sehen, wie diese Migration mit wenig Aufwand vonstatten geht und welche Vorteile sich für Entwicklung und Betrieb daraus ergeben. Livedemos zeigen die dazu notwendigen Schritte. Am Ende werden wir gelernt haben, dass eine Containerisierung nicht nur für Anwendungen auf der grünen Wiese Sinn ergibt, sondern auch Altlasten geschickt verpackt werden können.
Using SSL/TLS the right way is often a big hurdle for developers. We prefer to have that one colleague perform "something with certificates", because he/she knows how that works. But what if "that one colleague" is enjoying vacation and something goes wrong with the certificates? In this session we'll take a close look at secure communication at the transport level. Starting with what exactly SSL and TLS is, we'll dive into public/private keys, and signing. We'll also learn what all this has to do with an unfortunate Dutch notary. Of course, there'll be plenty of practical tips and tricks as well as demos. Attend this session to become "that one colleague"!
Nach der Übergabe von Java EE an die Eclipse Foundation wird die Plattform dort unter dem neuen Namen Jakarta EE weiterentwickelt. Dieser Schritt sorgt für spürbaren Aufwind und bedeutet signifikante Veränderungen für die Plattform, die viele Chancen, aber auch einige Risiken mit sich bringen. Dieser Vortrag beleuchtet den aktuellen Stand in Sachen Jakarta EE. Welche neuen Features werden diskutiert? Wann ist mit einem ersten Release zu rechnen? Gleichzeitig werfen wir einen Blick auf die MicroProfile-Initiative, die sich zu einem Innovationsmotor der Plattform zu etablieren scheint. Hier werden in raschem Tempo neue APIs und Implementierungen für lange geforderte Features wie Fault Tolerance, Health Checks, Metriken oder Support für JSON Web Tokens vorgestellt.
Nach der Freigabe vom JDK 10 steht die Praxistauglichkeit vom Java-Plattformmodulsystem beim kommenden Long-Term-Support-Release JDK 11 auf dem Prüfstand. Die mit dem JDK 9 eingeführten modularen Veränderungen lassen es zu, die gewünschte technische Paketierung von ausgewählter Java-Funktionalität selbst zu bestimmen. Dabei wird die durchgängige, dynamische und einfache Anpassbarkeit der Java-SE-Plattform und des JDKs, auch für kleine Java-SE-Plattformimplementierungen, verwirklicht. Im Vortrag werden Demobeispiele gezeigt, die eine Erstellung von individueller Java Runtime mit Anwendung anhand der JDK-10-Werkzeuge verdeutlichen und auch Migrationsaspekte älterer Java-Anwendungen berücksichtigen.
Aktuell sind die fünf wertvollsten Unternehmen aus den USA, und ihre Gemeinsamkeit ist, dass sie ein stark ausgeprägtes plattformbasiertes Geschäftsmodell haben. Sie wollen verstehen, wieso Apple, Microsoft, Google, Facebook und Co. so erfolgreich sind? Dann kommen Sie vorbei. Sie lernen Neues über virale Effekte, Netzwerkeffekte auf der Supply- und Demand-Seite sowie über die verschiedenen Rollen auf der Plattform. Ich entschlüssele Launch-Strategien - untermauert mit prominenten Beispielen und ich gebe Hinweise, unter welchen Randbedingungen ein plattformbasiertes Geschäft erfolgreich werden kann. Auch werde ich unterschiedliche Governance-Aspekte mit den jeweiligen Konsequenzen für Ihr plattformbasiertes Geschäft aufzeigen. Auf die IT gehe ich gesondert ein. Sie erfahren, welche Fähigkeiten im Kontext von plattformbasierten Geschäftsmodellen besonders wichtig sind und welchen Stellenwert hierbei das API-Management einnimmt. Angereichert wird diese Session durch eine hohe Praxisrelevanz und Erfahrungen aus meinem Projektalltag.
Angular ist ein vielversprechendes Framework, aber wie verwendet man es optimal? Welche Fallstricke gilt es zu vermeiden, damit auch in Produktion alles reibungslos läuft? Dieser Vortrag basiert auf den Praxiserfahrungen aus rund zwei Jahren Entwicklung mit Angular: Vom Design bis zum produktiven Betrieb mehrerer Systeme. Neben Tipps zum API-Design geht es um Integration von Komponenten von Drittanbietern, Komponentenschnitt und Diagnose der Anwendung. Dieser Vortrag richtet sich an Softwareentwickler und Architekten, die an Best Practices und wertvollen Tipps und Tricks für eigene Projekte mit Angular interessiert sind.
Die aktuelle Marktentwicklung treibt E-Commerce-Systeme dazu, sich von einem abgeschlossenem Shop hin zu einem offenen Ökosystem zu entwickeln. Dafür ist es zwingend notwendig, Funktionalitäten über ein externes API zu veröffentlichen. Verschiedenste Clients, wie zum Beispiel native Apps, Social-Media-Sites, IoT-Devices, Stationärhandel und externe Websites, sollen sich flexibel anbinden können.
Im Vortrag wird die verteilte Microservices-Architektur von Breuninger vorgestellt. Dabei wird vor allem auf Motivation und praktische Learnings eingegangen. Daraufhin werden Architekturlösungsansätze für öffentliche und interne APIs innerhalb von verteilten Architekturen vorgestellt und bewertet.
Develop an Augmented Reality game with UI5. The game will take place in a galaxy far, far away. Learn how you can integrate three.js and ARCore for Web into UI5.
Angular verfolgt einen relativ klassischen MVC-Ansatz mit Two-Way Data Binding. Das erleichtert den Einstieg und ist für einfache Anwendungen ausreichend. Bei komplexer werdenden Anwendungen kann dieser Ansatz aber für Schwierigkeiten in der Nachvollziehbarkeit der Datenflüsse sorgen und damit die Wartbarkeit und Erweiterbarkeit beeinträchtigen. Eine Alternative dazu ist Redux, das sich in der React-Welt weitgehend durchgesetzt hat. Redux ist sowohl ein Pattern als auch eine Bibliothek, die auf Prinzipien der funktionalen Programmierung setzt, um den Zustand einer Anwendungung zu managen. Durch die Beschränkung auf unidirektionalen Datenfluss und die explizite Modellierung von Aktionen sorgt es nicht nur für ein besseres Verständnis der Abläufe in der App, sondern auch für eine saubere Trennung der einzelnen Aspekte und Zuständigkeiten. Redux ist aber nicht auf React beschränkt, sondern technologieneutral und lässt sich ebenfalls mit Angular einsetzen. Im Vortrag werden zunächst die Idee und Funktionsweise von Redux erklärt und es wird anschließend gezeigt, wie Redux mit Angular angewendet werden kann.
Search can be just solved by using elasticsearch, or solr, out of the box, right? If you wanna learn how to make sure you completely fail at search, this is your talk. Using real world examples we will review common patterns that will make your project search fail. With this talk you will learn, how to setup search ones and never touch it again. If it works for you, is good enough, users don’t have a saying on finding items. Users know what they want, no need to help them in the process.etc. Having this tips in mind, you will completely fail on search, and your product and business owners will never come back to you with complicated stuff to change your search cluster.
This year, the SQL language will celebrate its 32nd birthday. Hibernate turns 17 years old, JPA 12 years old, and jOOQ 10 years old. All these technologies are established, mature, and we know how they work. Or do we? In 2018, we are still having many heated discussions about how to persist our data, how to query it, how to model our transactions, how to model our domains. In the Java ecosystem, SQL-centric systems are often seen as "legacy", whereas JPA-centric ones as "modern" (or standard if we consider JPA). Given the ages of these technologies, this seems understandable. But is it reasonable? The SQL approach is more bulk data processing oriented (OLAP), whereas the JPA approach is more CRUD oriented (OLTP). SQL is more stateless/sessionless/side-effect free whereas JPA is stateful/sessionful/imperative. SQL runs set-based computational logic in the database, giving access to the sophistication of modern SQL optimisers, whereas JPA offers running record-based computational logic in the client, giving access to the vast possibilities of Java libraries and client-side processing. In this talk, Vlad (from Hibernate) and Lukas (from jOOQ) will discuss the pros and cons of each paradigm.
Im Microservices-Bereich gibt es viele Lösungen für die Authentifizierung und deren Transport zu den Services, wie OAuth2, OpenID Connect, JWT etc. Welche dieser Lösungen ist eigentlich für was zuständig, und welche verschiedenen Möglichkeiten habe ich überhaupt, meine verschiedenen Rollen, Rechte usw. zu verwalten und eine darauf basierende Prüfung zu implementieren? Das natürlich, ohne dabei die Autonomie der Microservices/SCS zu verlieren. Lernen Sie hier verschiedene Möglichkeiten kennen mithilfe von praktischen Beispielen mit Spring Security 5, GitHub und Keycloak.
Grundlegende Probleme in altgedienten Anwendungen managementgerecht zu kommunizieren, ist eine schwierige Sache. Wir haben jedoch fast alles, was wir dafür brauchen, vor uns liegen: Eine umfangreiche, wertvolle Datenbasis aus Tickets, Commits, Quellcode, Logdateien und vielem mehr. In der Session stelle ich Software Analytics vor, dessen Vorgehen und Methoden darauf abzielen, die Daten aus der Softwareentwicklung so aufzubereiten, dass sie von Managern zur Entscheidungsfindung herangezogen werden können. Ich zeige auch eine Werkzeugkette (Jupyter, Python, pandas, jQAssistant, Neo4j, D3), mit der sich Analysen von Java-Anwendungen und deren Umgebung (Git, FindBugs, JaCoCo, Profiler, Logfiles etc.) in der Praxis einfach umsetzen lassen. Als Beispiele sehen wir uns die Identifikation von wertlosem Code, die Aufdeckung von Wissenslücken und die Optimierung des fachlichen Schnitts einer Anwendung an.
Testgetriebene Entwicklung in objektorientierten Sprachen setzt bislang meist auf beispielbasierte Testfälle, wie man sie leicht mit JUnit und ählichen Testframeworks erstellen kann. Schaut man jedoch über den Tellerrand und auf funktionale Programmiersprachen wie z.B. Haskell oder F#, findet man dort etwas anderes: Property-Tests. Property-Tests basieren auf der Idee, die erwünschten Eigenschaften unseres Programms zu beschreiben und anschließend das Framework selbstständig Testfälle generieren zu lassen, die diese Eigenschaften bestätigen oder falsifizieren. In diesem Vortrag werde ich sowohl auf die Theorie hinter Property-based Testing eingehen als auch konkret zeigen, wie man mit jqwik unter Java und anderen JVM-Sprachen solche Tests umsetzen kann. Dabei spielen die Muster zum Finden der Properties eine wichtige Rolle.
Die 2016 gegründete und inzwischen in der Eclipse Foundation beheimatete Initiative MicroProfile ist angetreten, die Lücke zwischen dem Enterprise-Java-Standard (Java EE aka EE4J) und den Praxisanforderungen Microservices-basierter Architekturen zu schließen. Das bestehende Momentum der JEE-Community als Hebel nutzen und organisch um den Bedarf der Microservices-Community ergänzen, so der Plan. Und dieser Plan scheint aufzugehen. In nur wenigen Monaten ist es gelungen, eine Reihe sinnvoller Microservices-relevanter APIs mit bestehenden Java-EE-7/8-APIs zu kombinieren und diese in regelmäßigen MicroProfile-Releases zu veröffentlichen. Egal ob Health Check, Metrics, Fault Tolerance, JWT Propagation, Configuration, Tracing oder Open API, MicroProfile scheint die richtigen Antworten - sprich APIs - im Gepäck zu haben. Die Session zeigt den aktuellen Stand von MicroProfile und demonstriert dessen Mehrwert anhand praktischer Beispiele.
Der Erfolg agiler Softwareentwicklung steht und fällt mit der Zusammenarbeit und Kommunikation innerhalb des Teams. Was aber, wenn ein Teil des Teams in Berlin, ein weiterer in Barcelona und der Rest in Wanne-Eickel sitzt? Kann ein verteilt arbeitendes agiles Team überhaupt dauerhaft qualitativ hochwertige Arbeit leisten? Christian Schneiker meint ja – wenn die notwendigen Voraussetzungen erfüllt sind. Welche das sind und wie die Zusammenarbeit in verteilten Teams so organisiert werden kann, dass die Teammitglieder das Gefühl haben, sie würden am gleichen Ort arbeiten, stellt er in seinem Vortrag vor. Hierbei geht er auf verschiedene Tools ein, die eine stetige, nahezu barrierefreie Kommunikation ermöglichen, und gibt Praxisbeispiele dafür, wie verteilte agile Teams effizient mit ausgewählten Werkzeugen arbeiten. Zudem zeigt er, wie ein Team-Set-up erfolgen sollte, warum es wichtig ist, auch das Management miteinzubeziehen, und welche Prozesse Scrum Master und agile Coach besonders im Auge behalten sollten, um langfristig Zufriedenheit und Qualität zu gewährleisten.
Die Einstiegshürde für Systemtests ist in Java-Enterprise-Projekten hoch und der Aufwand im Vergleich zu Unit-Tests deutlich höher. In der Folge werden in der Praxis entsprechende Tests gar nicht oder nicht von Anfang an eingesetzt. Dabei ist es gerade bei Systemtests wichtig, sie frühzeitig in ein Projekt und insbesondere in die CI Chain einzubinden. Wo liegen aber nun die konkreten Vorteile von Systemtests, und warum reichen Unit-Tests alleine nicht aus, um eine qualitativ hochwertige Software zu entwickeln?
Mithilfe dieser Session sollen der Einstieg erleichtert und Best Practices aus dem Projektalltag vorgestellt werden. Was funktioniert? Wo liegen Fallstricke? Anhand von Arquillian werden konkrete Beispiele erarbeitet, um herauszufinden, wie nachhaltig eine gute Code-Coverage und damit eine höhere Softwarequalität erreicht werden kann.
Das Spring-Data-Projekt organisiert seine Releases in ungefähr halbjährlichen Release-Trains, die ein gutes Duzend Module enthalten, um Datenzugriffsschichten für verschiedene Datenbanken zu implementieren. Mit der 2.0-Version erschien im September 2017 das erste große Major-Release nach über acht Jahren. Der Vortrag widmet sich den wichtigsten Features: dem Upgrade auf Java 8 und Spring Framework 5, Unterstützung von Reactive Programming, Änderungen im Repository-Programmiermodell und Store-spezifischen Änderungen in JPA, MongoDB, Redis und den Spring-Data-Community-Modulen. Abgerundet wird das Ganze durch einen Ausblick auf den kommenden Releasetrain Lovelace.
Lange wurde die Informationstechnologie vor allem als verlängerter Arm der Verwaltung gesehen, und noch heute berichten viele CIOs an den CFO und werden so nicht als Teil der primären Wertschöpfung des Unternehmens wahrgenommen.
Aktuell werden die Softwarebausteine, mit denen wir arbeiten, durch den technologischen Fortschritt wie beispielsweise künstliche Intelligenz nicht nur immer mächtiger, sondern auch Services und Produkte wie zum Beispiel das Auto werden aus Anwendersicht immer mehr von Software geprägt. So mutiert das Auto von einer rollenden Blechskulptur zu einem rollenden Rechenzentrum mit mehr als 100 Mio. Programmzeilen und einem Datenstrom von 25 GB pro Stunde.
Einerseits ist das ein goldenes Zeitalter für Softwareentwickler, andererseits kommt mit großem Einfluss aber auch große Verantwortung. Softwareentwickler sollten aus unserer Sicht heute einen direkten Einfluss auf die Entstehung von sogenannten vernetzten Produkten, wie zum Beispiel das vernetzte Fahrzeug, nehmen und sicherstellen, dass in der Produktgestaltung, die durch Software neu eröffneten Möglichkeiten bestmöglich ausgenutzt werden können.
In diesem Vortrag beleuchten wir zwei konkrete Aufgabenstellungen der Entwicklung von vernetzten Produkten:
Für beide Bereiche werden konkrete technische Lösungsansätze präsentiert, die leicht in eigene Projekte übernommen werden können.
Wie bitte? Microsofts Azure-Cloud auf der JAX? Ja, in der Tat. Denn nicht immer muss oder soll es AWS oder GCP sein. Azure bietet mittlerweile eine holistische Plattform für so gut wie jede Cloud-Anforderung an. Auch und vor allem in den Bereichen Cloud-native und Serverless Functions investiert Microsoft sehr viel. In dieser Session zeigt Christian Weyer neben den Grundlagen vor allem typische Anwendungsszenarien für Azure Functions. Der Fokus soll dabei auf eventgetriebenen Integrationslösungen und Workflowszenarien liegen - hier bedarf es nicht immer Unmengen von Code, um ans Ziel zu kommen. Lehnen Sie sich also zurück und sehen Sie "die andere Cloud" in Action. Keine Angst vor Azure!
NoSQL-Datenbanken sind aktuell angesagt und lösen viele Probleme. In vielen Unternehmen sind aber SQL-Datenbanken der Alltag, und das auch mit gutem Grund – wir sind ja nicht alle Netflix. Dieser Talk ist eine Liebeserklärung an die reichen Features, die SQL-Datenbanken bieten: zeilen- und spaltenübergreifende Constraints, Transaktionen, effiziente und detaillierte Abfragen, Tuning usw. Er stellt wenig benutzte Features praxisnah vor und lädt zu einer Reise in die Welt jenseits von OR Mappers ein: SQL ist auch in Zeiten von Microservices eine solide Basis für Persistenz.
Die neuen Releases von JAX-RS und CDI bringen einige interessante Neuerungen für API-Entwickler, wie etwa Unterstützung für HTTP PATCH, Server-sent Events oder asynchrone CDI-Events. In Kombination mit dem neuen JSON-B geht die Implementierung von APIs noch leichter von der Hand. Auch das neue reaktive Client-API von JAX-RS stellt ein interessantes neues Feature dar. In dieser Live-Coding-Session wird eine prototypische Anwendung entwickelt, die den Einsatz der neuen Features veranschaulicht.
How would you feel if you knew that any part of the code was at most a few minutes away from being shippable and delivered into production? How would you feel if you knew that any part of the code is a few ctrl+z's away from being shippable and delivered into production? Emboldened and confident? Test-driven development (TDD) gives you that. TDD allows you to proceed with confidence that you're building the right thing. It provides you with imminent-horizons that you can meet and measure. TDD gives developers the confidence to go faster, secure in the knowledge that what they break they will fix and be able to improve. In this talk, join Spring Developer Advocate Josh Long (@starbuxman) as he looks at how to test Spring applications and services. We'll look at how to test basic components, mocks, how to take advantage of test slices, and how to test web applications. We'll also look at how to ensure that API producers and API consumers work well together using consumer driven contract testing (CDCT) without sacrificing the testing pyramid for end-to-end integration tests.
Es muss nicht immer Airbnb, Uber oder Facebook sein. Plattformbasierte Geschäftsmodelle funktionieren auch im kleinen Stil (z.B. OpenTable). In dieser Session wollen wir mit Ihnen in 3600 Sekunden ein plattformbasiertes Geschäftsmodell entwerfern. Wir werden auf Fragen wie "Wie fließt das Geld?", "Welche Werte bieten wir auf der Plattform an?", "Wen brauchen wir als Partner?", "Wer ist unsere Zielgruppe?", "Welche Kanäle bedienen wir?", "Wie gehen wir den Launch an?", "Wie bauen wir die notwendige IT?" konkrete Antworten finden müssen. Sicherlich haben Sie auch Fragen, Ideen oder Anregungen. Für diejenigen unter Ihnen, für die die Plattformökonomie noch Neuland ist, empfehlen wir, dass sie die Einführungssession "Der heilige Gral Plattformökonomie? Bei mir finden Sie Antworten" besuchen.
Heutzutage schreiben wir große und unternehmenskritische Anwendungen mit Angular. Doch wie strukturiert man die damit umgesetzten Projekte am besten, um eine langfristige Wartbarkeit und Wiederverwendbarkeit zu gewähren? Diese Session gibt unter Verwendung einer Fallstudie gleich mehrere Antworten auf diese Frage. Sie erfahren, wie Sie Anwendungen in einzelne wiederverwendbare npm-Pakte zerteilen und über eine Haus-interne sowie öffentliche Registry bereitstellen. Zusätzlich lernen Sie den Monorepo-Ansatz kennen und sehen, welche Vorteile er gegenüber npm-Paketen bringen kann. Als weitere Möglichkeit wird der Einsatz von Angular in Microservice-Umgebungen diskutiert. Dabei werden einige Realisierungsoptionen aufgezeigt sowie deren Vor- und Nachteile diskutiert. Am Ende haben Sie einen Überblick über Möglichkeiten zum Strukturieren großer Angular-Applikationen und können diese vor dem Hintergrund Ihrer eigenen Projekte bewerten.
Since Java 8 so called lambda expressions can be used by Java developers. But what does it mean... Lambda? The talk will be about story behind this term, from a little bit more scientific point of view. Church Lambda calculus, Entscheidungsproblem and incompleteness theorem. Almost all of that will be presented in Java – in the language that you understand. And of course you can later impress your friends with some impressive math tricks. There are going to be shown some very crazy code pieces such as perfectly unusable implementation of boolean (based on lambda expressions). Come and see what purely functional really means.
Unit-Tests, Integrationstests und Co. machen es möglich, zu überprüfen, ob eine Software den Anforderungen entspricht oder Fehler vorhanden sind. Durch die zunehmende Vernetzung von Softwaresystemen und die Auslagerung von Anwendungen in die Cloud werden jedoch Securityanforderungen immer relevanter. Traditionelle Qualitätssicherungsmethoden laufen hier ins Leere. Wenn überhaupt, wird meist nur am Ende stichprobenartig getestet, ob eine Software sicher ist. Fallen Sicherheitsmängel aber erst so spät auf, sind sie in der Regel nur noch schwierig zu beheben. Schlimmstenfalls müssen sogar ganze Anwendungsteile refaktoriert werden. Deshalb ist es sinnvoll, IT-Sicherheit möglichst früh im Entwicklungsprozess zu berücksichtigen. Security Aware Development tut genau dies: Es hilft, Sicherheitsrisiken frühzeitig zu ermitteln, indem es IT-Sicherheitsanforderungen fest in den agilen Entwicklungsprozess integriert.
Warehouse Solutions erfassen aktuell und in Zukunft immer weitere Bereiche von Warenströmen von E-Commerce und Paketversendung. Die dabei verwendeten logistischen Prozesse unterliegen in den verschiedenen Anwendungsbereichen großer Vielfalt und erfordern gleichzeitig die Erstellung und Inbetriebnahme solcher Systeme in sehr kurzen Zeiträumen.
Dieser Vortrag gibt einen Überblick über die gemachten Erfahrungen und Erfolge die wir nach 365 Tagen erzielt haben sowie einen Ausblick auf aktuelle und kommende Herausforderungen.
Spring Boot 2 ist kürzlich erschienen und bringt zahlreiche Neuerungen und einige Veränderungen mit sich. In dieser Session lernen Sie, was in Spring Boot 2 neu hinzugekommen ist und wie Sie von einer bestehenden Spring-Boot-1.x-Anwendung auf die neueste Version migrieren können. Im Rahmen des Vortrags werden beispielsweise Themen wie reaktive Programmierung auf Basis des WebFlux Starters, das neue Gradle-Plug-in, Änderungen am Actuator oder der Support neuer Metriken vorgestellt. Weiterhin führt Sie der Vortrag durch zahlreiche Hinweise für die Migration von bestehenden Spring-Boot-1.x-(Fokus 1.5x-)Anwendungen auf Spring Boot 2. Hierbei werden Sie sowohl die wichtigsten Änderungen und Erweiterungen der Konfiguration sowie Code-Changes kennenlernen.
Python-basierte Frameworks wie TensorFlow und scikit-learn dominieren zurzeit den Machine-Learning-(ML-) und Artificial-Intelligence-(AI-)Bereich. Deeplearning4j ist ein Framework, das verspricht, die gleichen Aufgaben wie die Python-Platzhirsche zu lösen, bietet aber dabei EntwicklerInnen ein hundertprozentiges Java-API. Diese Session bietet eine Einführung in DL4J und zieht gleichzeitig einen Vergleich zu den etablierten Python-Frameworks. Anhand von Beispielprojekten wird erklärt, wie man seine eigene KI ganz ohne Python trainieren kann. Dieser Vortrag ist auch für ML-Neulinge geeignet, die wichtigsten Basics werden alle im Rahmen von Praxisbeispielen erklärt.
Every team runs on some level of collaboration. Whether you are sending pull requests, commenting on Jira tickets, or sitting in long project meetings, you rely on feedback to push your development forward. So, how can you program that feedback and collaboration into your development process in a standardized way without it becoming disruptive?
In this session, Damien Walsh and Ronan Trainor will outline actionable strategies that teams can use to unlock the full potential of every workflow, from design and documentation to peer code review and testing. Because effective communication means understanding your role in the conversation, they will also walk through the roles that exist on each team, and how leveraging those roles can lead to clear expectations and better-quality feedback. If your team keeps having the same conversations over and over again, this is a session you won’t want to miss out on.
Ab Mai 2018 tritt die europäische Datenschutzgrundverordnung (DSGVO) in Kraft und löst damit das bis dahin geltende Bundesdatenschutzgesetz (BDSG) ab. Die neue Verordnung stellt mit "Data Privacy by Design" und "Date Privacy by Default" auch die Entwickler von Anwendungen vor neue Herausforderungen. In dieser Session zeigt Andreas Falk, wie man mit Spring Cloud Vault sowohl die Konfiguration absichern als auch sensible Anwendungsdaten sicher verschlüsselt speichern kann. Nach einer kurzen Einführung in das Projekt Vault wird anhand mehrerer Livedemos dargestellt, wie Spring Cloud Vault die Integration von Vault in die eigene Anwendung vereinfacht und dadurch deren Datenschutz entscheidend verbessern kann.
Start-ups sind agiler und innovativer. Wir müssen wie ein Start-up denken und arbeiten. Haben Sie das auch schon gehört? Wie schafft man einen Mindset Change vom Projekt zum Produkt? Man nehme ein paar Mitarbeiter, eine Menge Motivation und kombiniere beides zu innovativen Lösungen. Das geht nicht? Und wenn man es doch macht? Wie entstehen mit Design Thinking, Scrum und weiteren agilen Methoden innovative Produkte? Warum steht das Produkt im Mittelpunkt und nicht das Projekt, und warum bedingt dies DevOps? In diesem Vortrag versuchen wir Antworten auf diese Fragen zu geben.
Bei vielen Big-Data- und IoT-Anwendungsfällen geht es darum, Daten von mehreren Quellen zusammenzubringen und einer Plattform verfügbar und so analysierbar zu machen. Die Quellen sind dabei heterogen, von einfachen Dateien über Datenbanken bis zu hochvolumigen Ereignisströmen von Sensoren (IoT-Geräten). Für diese Aufgabe der Data Ingestion haben sich spezialisierte Werkzeuge etabliert. Sie ähneln von außen betrachtet den Enterprise-Service-Bus-Infrastrukturen, die ein Unternehmen vielleicht bereits im Einsatz hat. Es gibt aber auch Unterschiede, die diese Produkte interessant machen. So können sie z. B. detailliert über den Nachrichtenfluss jeder einzelnen Nachricht Auskunft geben, selbst dann, wenn die Nachricht schon lange verarbeitet ist. Sie integrieren sich sehr gut in das Hadoop-Ökosystem und können auch mit modernen Formaten wie Avro umgehen. Daneben sind sie von Grund auf so entworfen, dass sie auf verschiedenen Plattformen betrieben werden können und damit auch lokal bei den Datenquellen, am so genannten Edge beim Internet of Things. In dieser Session werden die wichtigsten Produkte, wie Apache NiFi, StreamSets und das Kafka-Ökosystem, vorgestellt und miteinander verglichen.
Projekt Jigsaw mag sehr viel Aufmerksamkeit auf sich ziehen, aber es ist nicht die einzige interessante Neuerung im JDK 9. Ebenfalls dazugekommen sind vier auf den ersten Blick unscheinbare Interfaces in java.util.concurrent.Flow, die es in sich haben. Sie holen das Konzept von Reactive Streams direkt ins JDK. Die Interfaces erlauben die Integration von verschiedenen Libraries zu einer Streaming-Pipeline mit Flow Control. Wir werden uns Reactive Streams genauer ansehen und klären, was es mit Back Pressure auf sich hat (Tipp: ist kein Rückenleiden). Außerdem werfen wir einen Blick auf verschiedene Implementierungen (RxJava, Reactor, Akka Streams), werden betrachten, wie das Projekt Alpakka auf Basis des Flow-API unterschiedlichste Systeme integriert, und uns ansehen, was zu beachten ist, wenn man selbst eine Implementierung des Flow-API entwickeln möchte. Denn wie schon Heraklit wusste: panta rhei (alles fließt).
Transactions and Concurrency Control are of paramount importance when it comes to enterprise systems data integrity. However, this topic is very tough since you have to understand the inner workings of the database system, its concurrency control design choices (e.g. 2PL, MVCC), transaction isolation levels and locking schemes.In this presentation, I'm going to explain which data anomalies can happen depending on the transaction isolation level, with references to Oracle, SQL Server, PostgreSQL, and MySQL. I will also demonstrate that database transactions are not enough, especially for multi-request web flows. For this reason, I'm going to present multiple application-level transaction patterns based on both optimistic and pessimistic locking mechanisms. Last, I'm going to talk about concurrency control strategies used in the Hibernate second-level caching mechanism, which can boost performance without compromising strong consistency.
Wir bei Spreadshirt haben vor knapp zwei Jahren begonnen, die JVM-Sprache Kotlin einzusetzen. Schnell stellte sich heraus, dass Kotlin Java deutlich überlegen ist. Kotlin vermeidet eine signifikante Menge an Boilerplate, verhindert gängige Fehler durch kluges Sprachdesign und ist obendrein auch noch besser lesbar. Zusätzlich ermutigen die Sprachkonstrukte den Entwickler zu einem besseren Softwaredesign. Allerdings gibt es auch Pitfalls bei der Verwendung von etablierten Java-Frameworks und einigen Kotlin-Features zu beachten. Außerdem wird gezeigt, wie wir bei der Einführung von Kotlin vorgegangen sind und was aus Managementsicht zu beachten war. In diesem Vortrag möchte ich euch Kotlin vorstellen und unsere gesammelte Praxiserfahrung teilen. Abschließend wird verraten, wie es um die Zukunft von Kotlin bei Spreadshirt bestellt ist.
Unternehmen entwickeln ihren Webauftritt oft in Teams, die jeweils einen Teil der Funktionalität beisteuern. Ein Team baut das Anwenderprofil, ein anderes den Warenkorb, ein drittes Team die Bestellseite. Bald zeigen sich Überschneidungen bei nicht trivialen Use Cases. Die Adressänderung sollte im Anwenderprofil gleich funktionieren wie im Bestellformular. Klassisch hätten wir Komponenten für ein bevorzugtes Framework gebaut, eine Angular-Adressdirektive zum Beispiel. Mittlerweile entpuppt sich dieser Weg als Sackgasse. Um unseren Adressflow um QR-TAN zu erweitern, müssen wir alle Anwendungen neu ausrollen, und wir können ihn nicht mit neueren Frameworks einsetzen. Auch die Koexistenz von Anwendungen im selben Framework auf einer Seite wird zum Problem, sobald ein Team das Framework updaten muss, das andere aber nicht upgraden kann. Die Session zeigt, wie Micro Frontends mit No-Framework JavaScript dieses Problem lösen. Mit Tools wie sveltejs oder Stencil.js entstehen schlanke Micro-Frontend-Komponenten, die im Browser kein Framework benötigen, sondern auf das reine DOM API oder den Web-Component-Support des Browsers setzen, und deshalb mit anderen Anwendungen auf derselben Seite koexistieren oder als Teil einer frameworkbasierten Anwendung laufen können. Entwickler schreiben das Micro Frontend als MVC-Anwendung, und ein Compiler erzeugt daraus JavaScript-Komponenten, die im Browser kein Framework brauchen, und die wir getrennt voneinander updaten können.
Jetzt noch schnell handeln - im Mai 2018 kommen die europäische Datenschutz-Grundverordnung (DSGVO) und das neue Bundesdatenschutzgesetz (BDSG-neu) zur Anwendung und lösen damit das bis dahin geltende Bundesdatenschutzgesetz (BDSG) ab. Darauf sind Unternehmen kaum vorbereitet. Doch angesichts drastisch erhöhter Bußgelder besteht dringender Handlungsbedarf. Der praxisorientierte Vortrag leitet kurz in die bestehende Gesetzgebung ein, bietet daraufhin einen leicht verständlichen Überblick zu den Hintergründen und den Änderungen der DSGVO und gibt sodann vor allem zahlreiche praktische Tipps zu den Anforderungen in der alltäglichen Arbeit. Wie setze ich im Unternehmen auf den letzten Drücker effizient die DSGVO um? Wie bekomme ich meinen Onlineshop datenschutzkonform? Was bedeutet dies für mich als Dienstleister oder Auftragsverarbeiter? Wie betrifft mich die DSGVO als Arbeitnehmer und Entwickler? Welche Rechte habe ich als Bürger? Ein aktiver Frage- und Antwortteil rundet den Talk ab.
Digitalisierung wird vielfach mit Technologie und insbesondere der Cloud gleichgesetzt. Der Schritt in die Cloud ist für sich genommen jedoch noch keine Strategie. Vielmehr müssen Unternehmen moderne technologische Plattformen als mächtiges Werkzeug begreifen, das bei wohlüberlegtem Einsatz dabei helfen kann, schnell und kostengünstig mit neuen Geschäftsideen zu experimentieren.
Mit klugen Ideen und einer kleinen Portion Mut wagen immer mehr deutsche Unternehmen über alle Branchen hinweg den gefürchteten Umstieg in die digitale Welt und sind auf dem besten Weg, sich profitable und zukunftsfähige Geschäftsfelder zu erschließen. Mit dem richtigen Vorgehensmodell und dem Ansatz “einfach mal machen” kann jedes Unternehmen erstaunliche Dinge vollbringen.
Gamification führt zu besser motivierten Teams und besserer Software. Aber wie kann man einen praktikablen Ansatz entwickeln, um den Arbeitsalltag im Projekt und die Qualität der eigenen Software zu verbessern? Ausgehend von seinem Talk zu Codemetriken und deren Tücken auf der JAX 2017 stellt Christoph Meyer ein Konzept vor, wie sich Gamification als Clean-Code-Praktik etablieren lässt. Das bei viadee entwickelte Spielkonzept, Codename „SonarQuest“, baut direkt darauf auf, dass mit SonarQube Kennzahlen zur Codequalität im Projekt erhoben werden, und nutzt die gewonnenen Kennzahlen als Datengrundlage für eine Abenteuerreise, die das Team gemeinsam unternimmt. So werden Sicherheitslücken zu Monstern, die es zu besiegen gilt, werden fehlende Tests zu Rätseln, werden Issues und Probleme zu Abenteuern. Damit die Spieler nicht zu Einzelkämpfern mutieren, sondern als Gruppe vorankommen, wurde bei dem Konzept besonders auf den Teamworkaspekt und angemessene Belohnungen geachtet. Der „Flow“, also der bestmöglich motivierende Zustand für den einzelnen Spieler, kommt dabei ebenfalls nicht zu kurz. Der Vortrag zeigt auf, wie Gamification in (agilen) Entwicklungsteams erfolgreich praktiziert werden kann, und was häufig falsch gemacht wird. Dabei führt er über Clean-Code-Metriken als Ausgangspunkt hin zum Open-Source-Spiel „SonarQuest“, was auf SonarQube aufbaut.
Unmaintainable balls of mud everywhere, combined with the need for always going faster, bigger, more robust and more complex. To solve these challenges, we have internalized to look for the next silver bullet at the horizon (or at Stack Overflow). As IT is moving fast, it must be that way. Yesterday's knowledge cannot solve today's challenges - or can it? Well, while not all knowledge is worth preserving, some is timeless and addresses fundamental problems of IT. Yet, we tend to lose this wisdom with every new generation of developers and every new trend that presses on the market. In this talk we will try to excavate some of this timeless wisdom by re-visiting a series of classic computer science papers. We will extract the key ideas of those papers and apply them to the challenges of today's IT. Be prepared for some surprising rediscoveries! Disclaimer: We will not take responsibility for a sudden urge to start reading computer science papers after this session...
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 Start-ups sein werden. In diesem Vortrag betrachten wir zunächst die technischen Grundlagen, beleuchten Vor- und Nachteile und diskutieren schließlich praktische Szenarien, die man damit umsetzen könnte.
In unserer Begeisterung für Technologie verlieren wir oft die Folgen unseres Tuns aus den Augen. Dabei prägt die Software, die wir entwickeln, weite Teile der Welt, in der wir und andere leben. Software ermöglicht sowohl zahlreiche Fortschritte in der Medizin als auch die Zielfindung moderner Angriffswaffen. Software ernährt unsere Familien und zerstört die Arbeitsplätze Millionen anderer Menschen. Die Software hinter sozialen Netzwerken ermöglicht den einfachen Austausch unserer Familienfotos und gleichzeitig die Manipulation von Massen und Wahlen. Sind wir persönlich für die Auswirkungen unseres Handelns verantwortlich? Oder können wir uns im Zweifel auf das bloße Ausführen von Befehlen berufen? Ist Softwarequalität lediglich eine wirtschaftliche Kategorie oder eine inhärente Verpflichtung unseres Berufsstands? Wir werden im Vortrag ethische Fragestellungen diskutieren, und eine eigene, persönliche Antwort geben.
SQL ist die einzige erfolgreiche, etablierte und generell anwendbare Programmiersprache der vierten Generation (4GL). Und sie ist der Wahnsinn! Mit moderner kostenbasierter Optimierung können relationale Datenbanken endlich ihr Versprechen einhalten, ein ausdrucksstarkes, deklaratives Programmiermodell auf sich ständig verändernden produktiven Datenständen ohne Performanceeinbußen umzusetzen. Tausendzeilige, komplexe SQL-Befehle können weit unter einer Millisekunde gegen Milliarden Reihen starke Tabellen laufen, wenn Datenbankentwickler sich mit der SQL-Sprache auskennen. Und das Beste ist: Es ist nicht so schwierig! In diesem Vortrag zeige ich, wie SQL-Datenbanken jegliche von Hand geschriebenen Algorithmen mühelos übertreffen. Oder in anderen Worten: Wie SQL, eine logische Programmiersprache, die beste Sprache für Businesslogik ist.
Nach den ersten Serverless-Projekten haben sich einige Dos und Don'ts sowie Best Practices herauskristallisiert. Wir diskutieren, in welchen Kontexten man Serverless-Technologien gewinnbringend einsetzen kann, wann vielleicht besser nicht und wie eine mögliche Migration hin zu Serverless aussehen kann. Zusätzlich schauen wir uns an, wie wir im serverlosen Programmiermodell mit Caching, (Start-up-)Latenzen, Sicherheit, Monitoring und Deployment Chains richtig umgehen und welche Verantwortung wir nach wie vor für unsere Anwendung hinsichtlich Fehlerfreiheit, Zuverlässigkeit und Korrektheit haben.
Obwohl Angular von Haus aus schnell ist, bietet es dennoch eine Reihe an Ansätzen zur Performanceoptimierung. Diese Session stellt bewährte sowie neue Optionen in diesem Bereich vor. Sie lernen unter anderem Ansätze kennen, um Ihre Bundle-Größen zu minimieren und somit die Startperformance merklich zu verbessern. Dazu gehört das verbesserte AOT, Tree Shaking, der neue Angular Build Optimizer und das kürzlich eingeführte Whitespace Removal. Außerdem erfahren Sie, wie Sie bei besonders performancekritischen Anwendungen von den aggressiven Optimierungstechniken des Closure-Compilers von Google profitieren können, aber auch, welche Gefahren er mit sich bringt. Anhand eines anschaulichen Beispiels sehen Sie danach, wie Sie die Datenbindungsperformance Ihrer Anwendung mit OnPush drastisch optimieren können und wie Sie mit Lazy Loading Anwendungsteile erst bei Bedarf nachladen. Zur Abrundung wird ein Blick auf das serverseitige Vorrendern zur Steigerung der wahrgenommenen Performance bei Customer-Anwendungen geworfen.
Immer mehr Geschäftsprozesse werden digitalisiert. Softwaresysteme werden komplizierter, sowohl was den Kern der Geschäftslogik angeht als auch bezüglich querschnittlicher Aspekte wie Variabilität und Individualisierung. Die Änderungs- oder Anpassungshäufigkeit steigt, die Time-to-Market sinkt. Effiziente Entwicklungsmethoden sind also mehr denn je entscheidend für den langfristigen Erfolg eines Unternehmens, um agil auf geänderte Anforderungen reagieren zu können. Aber gerade die Entwicklung der Fachlogik für Rechenkerne von Verträgen (Versicherung, Logistik), Tarifen (Telekommunikation, Transport), Diagnose (Medizin) oder Behörden (Steuern, Gebühren, Sozialkassen) folgt immer noch einem sehr dokumentenorientierten Ansatz. Fortschritte im Prozess, beispielsweise durch den Einsatz von Scrum, helfen nur bedingt weiter. In diesem Vortrag zeigen wir eine Möglichkeit auf, den Entwicklungsprozess für Fachlogik massiv zu beschleunigen. Der Ansatz stützt sich auf domänenspezifische (Programmier-)Sprachen, die von Fachexperten direkt einsetzbar sind, um die Fachlogik zu beschreiben. Dazu nutzen sie gemischte Notationen aus Text, Prosa, Tabellen, Diagrammen und mathematischen Ausdrücken. Auch Szenariosimulationen und fachliche Tests werden direkt von den Fachlern "programmiert". Der Vortrag besteht zum großen Teil aus Beispielen, in denen wir den Ansatz in der Praxis erfolgreich eingesetzt haben. Wir gehen auch kurz auf die (Open-Source-)Werkzeuge ein, mit denen wir die Sprachen entwickelt haben. Let's build Fachlogik like they build rockets :-)
Wer stehen bleibt wird abgehängt! In der IT haben wir ständig mit neuen Technologien, Praktiken, Frameworks und komplexen Problemstellungen tun. Nur mit einem Höchstmaß an Exzellenz können wir diesen Herausforderungen gerecht werden und gute Qualität auf allen Ebenen liefern. Das bedeutet: wir Entwickler (und alle anderen natürlich auch) müssen kontinuierlich lernen. Die Qualität der Weiterbildung definiert hierbei grundlegend die Qualität der Software, denn richtig gute Qualität schaffen nur Könner. Hier haben sich Methoden wie Katas, Randoris, Pair & Mob Programming, Communities of Practice und Gilden etabliert. Doch wie überzeuge ich meine Chefs, wie spielt das mit meinem Alltag zusammen, und wie hilft das beim Üben? Oder müssen wir vielleicht sogar trainieren – denn das ist dann Üben mit System?
Wer kennt das nicht? Irgendein Stück Code in unserem Softwareprojekt schreibt einen ungültigen Zustand in die Datenbank und keiner will es gewesen sein. Aber irgendwo in den Tiefen unserer Applikation wird ein Datum geändert, ohne dass man geprüft hat, ob diese Änderung überhaupt erlaubt ist. Man kann dies natürlich an jeder Stelle prüfen und gegebenenfalls verhindern. Dies ist aber fehleranfällig und schwierig zu warten. Einfacher geht es, wenn man seine erlaubten Änderungen in einer State Machine hinterlegt und diese nur noch mit Eingaben füttert. Diese erlaubt zudem über eine Modellierung der Übergänge als Events eine lose Kopplung und einfache Modularisierung. Das Spring-Universum bietet hierfür mit Spring Statemachine ein Framework an, das dies in einer einfachen Art und Weise erlaubt. Anhand eines realen Beispiels aus dem Bereich Monitoring werden wir erleben, wie Statemachine eine prägnante und elegante Implementierung der möglichen Änderungen erlaubt. Dabei wird die Applikation zunehmend robuster gestaltet und verwaltet als Königsdisziplin einen verteilten Zustand über mehrere Instanzen hinweg.
The accelerated release cadence for the Java platform offers us many more opportunities for delivering new features -- and we plan to do just that. Join Java Language Architect Brian Goetz on a whirlwind tour of the language features under development in Project Amber.
Programmer Anarchy is a post-Agile process that focuses on empowering programmers by eliminating roles that interfere with domain knowledge and assumption of day-to-day decisions by the programmers. Originally conceived in a startup environment at Forward Internet Group in London, Programmer Anarchy has been implemented in a traditional IT shop for an established company: MailOnline, the online newspaper arm of the Daily Mail of London, as well as other start ups. This discussion will talk about the introduction of Anarchy into a Scrum shop, the training, the transition of roles, and the redesign of HR roles.
Der Erkundungsroboter Curiosity war erfolgreich und fand nach jahrzehntelanger Suche eine Wasserstelle am Mars. Nachdem sich die Lebensbedingungen auf unserem Heimatplaneten Erde zunehmend verschlechtern, soll so schnell wie möglich ein Team von Wissenschaftlern zum roten Planeten entsendet werden, um dort eine Kolonie aufzubauen. Es liegt nun an dir und deinem Team, einen Roboter zu bauen, der nach der Landung auf dem Mars selbstständig zur Wasserstelle findet. Doch beachte: Möglicherweise sind wir nicht allein im Universum …
Es kann in Teams mit zwei bis acht Personen gearbeitet werden. Als Zeitkontingent stehen 120 Minuten zur Verfügung. Eine vorherige Anmeldung ist nicht nötig, der Wettbewerb ist für alle JAX-Teilnehmer offen. Vorkenntnisse sind nicht erforderlich: Zu Beginn gibt Wettbewerbsleiter Bernhard Löwenstein eine Einführung in LEGO MINDSTORMS EV3 und das zugehörige Java-API leJOS EV3.
Sie hatten bis jetzt noch nicht viel Kontakt mit JavaScript und Frontend-Programmierung? Sie würden aber gerne einmal wissen, wie diese Libraries funktionieren und wie man Web-UIs damit baut? In diesem Talk zeige ich von Grund auf, wie React und Redux funktionieren und wie die Entwicklung damit funktioniert. Und ich erkläre gerade so viel (oder so wenig) JavaScript, wie für das Verständnis des Talks notwendig ist.
Null pointer exceptions are the bane of programmers, and have been called the "billion dollar mistake". They happen even if you think hard about your code and test it thoroughly. However, you don't have to be a victim any longer! Come learn about a simple, yet powerful, type system that prevents null pointer exceptions at compile time.
This session will explain the causes of null pointer exceptions, including their relationship to issues such as object initialization, map keys, method contracts, Java 8's Optional class, and dynamic checks. It will show how programmers' informal reasoning can be automated into a formal proof, in a way that is easier to use than Java generics or the Optional class.
You will learn how to use pluggable type-checking, and in particular a freely-available tool called the Nullness Checker (http://CheckerFramework.org/) that integrates with your development environment and toolchain. It has found hundreds of bugs in millions of lines of well-tested code, and it is easy enough for novices such as beginning CS students.
Bring your tricky nullness issues and see how they can be solved!
In der heutigen Architekturpraxis sind unterschiedliche Denkschulen und Hintergründe anzutreffen. Vertreter der klassischen Architektursicht gehen dabei drastisch anders mit Architekturproblemen um als es Vertreter der neuen Schule machen, die in Start-ups und IT-First-Unternehmen zu finden sind. In dieser Session stelle ich die Sichtweisen, Konzepte, technischen und organisatorischen Prinzipien der beiden Ansätze einander gegenüber und diskutiere die Auswirkungen und wichtigsten Vorteile sowie Nachteile. Evolutionäre Architekturansätze, Eventual Integrity, geringe Zähigkeit als Möglichkeit der weichen Governance, Servant-Leadership-Modelle für Architekten, breite Verantwortung und Crowd-Sourcing-Ideen für technische Teilaspekte sind ein Thema. Ich möchte auch diskutieren, inwiefern Themen der klassischen Architekturschule aufgeweicht werden – konkret Konzepte wie Zentralisierung und Wiederverwendung.
Funktionale Programmierung erfreut sich in den letzten Jahren zunehmend größerer Beliebtheit. Sprachen wie Haskell, Scala, Clojure, Frege, OCaml und F# gewinnen an Bedeutung. Und auch Java hat in Version 8 endlich Syntax für anonyme Funktionen und Unterstützung für Funktionen höherer Ordnung bekommen. In diesem Vortrag werden Konzepte der Sprache Clojure zum Umgang mit der Komplexität von Softwaresystemen vorgestellt, insbesondere im nebenläufigem Kontext. Clojure ist ein modernes Lisp, das auf der JVM läuft und viele aus softwaretechnischer Sicht interessante Konzepte bereitstellt, wie effiziente, persistente Datenstrukturen und Konstrukte zum Umgang mit Zustand. Es werden keine Vorkenntnisse in funktionaler Programmierung oder Lisp benötigt.
Container haben sich mittlerweile etabliert, Serverless tritt als neuer Hype auf und alle reden von Cloud Native. Ist Serverless die nächste Evolutionsstufe von Containern und löst diese bald wieder ab? Wie passt Cloud Native in den Serverless-Kontext? An vielen Ecken sprießen momentan containerbasierte Frameworks aus dem Boden, die sich ihrerseits wieder Serverless nennen. Ist dem wirklich so? Wir werden kontrovers diskutieren, aber auch Gemeinsamkeiten feststellen. Auch wenn der Talktitel mit "vs." impliziert, dass die eine Technologie besser als die andere sein könnte, so geht es hauptsächlich darum, beide Seiten zu beleuchten und ihre jeweiligen Vor-, aber auch Nachteile aufzuzeigen.
Mit Angular als Webanwendungsframework lassen sich komponentenorientierte Anwendungen entwickeln, wie wir es von Windows- und desktopähnlichen Programmiermustern bereits kennen. Dank TypeScript als Programmiersprachen erhalten wir Features, wie Generics, Lambda-Ausdrücke oder statische Typisierung, um uns auch in der Webwelt schnell wohlzufühlen. Durch Cordova können wir unsere Anwendung als native mobile App für Android, iOS und Windows verpacken und auf Plattformfeatures, wie die Kamera des mobilen Geräts, zugreifen. Electron erlaubt das Verpacken der Anwendung in eine echte native Desktopanwendung: .exe, .app und Co. In dieser Session zeigt Manuel Rauber von Thinktecture, wie mit dem Open-Source-Framework für Single-Page Applications von Google echte Cross-Plattform-Businessanwendungen entwickelt werden können und dabei das Web als zukunftsfähige Anwendungsplattform nutzt.
Skripte für relationale Datenbanken werden von Entwicklern gerne stiefmütterlich behandelt. Beim ersten Release können sie dank ORM-Frameworks generiert werden. Doch spätestens beim zweiten Release müssen Datenbankmigrationskripte geschrieben werden. Sie werden dann gerne an Tickets angehängt, per E-Mail verteilt, in Release Notes versteckt etc. Irgendwann gibt es keinen Überblick mehr, welche Datenbankskripte zu welcher Softwareversion gehören. Im Vortrag wird darauf eingegangen, warum eine Einbindung von Datenbankskripten in den Continuous-Integration-Prozess erstrebenswert ist, wie Datenbankskripte automatisiert getestet werden können und welche Voraussetzungen, nicht nur technischer Natur, dafür geschaffen werden müssen. Anhand einer Java-Anwendung wird zusätzlich gezeigt, wie Flyway dabei helfen kann.
Host Card Emulation (HCE) allows mobile application to communicate over Near Field Communication (NFC) protocol. Contactless payment cards use the same NFC protocol to perform payments. Can a mobile application perform card payment using HCE technology? Yes, but it's not as easy and simple as you might think. I will share with you what it takes to emulate a card payment based on my experience of creating Tieto Cloud Based Payment solution and going through MasterCard approval process.
Scala ist eine schöne, elegante Programmiersprache, die sich immer weiter verbreitet. Scala ist cool, ausdrucksstark und innovativ – aber einfach?! Diese Session räumt mit dem Vorurteil auf, dass Scala kompliziert und schwer zu lernen ist, und zeigt an lauffähigen Quelltexten, wie einfach und gut lesbar Scala-Quelltext sein kann, selbst für Entwickler, die bisher nur Java können. Eine sanfte Einführung in Scala, Wow-Effekt garantiert.
APIs zwischen Systemen wurden in der Vergangenheit häufig in der Web Services Description Language (WSDL) beschrieben. Technisch ist es mit WSDL 2.0 möglich, auch REST-Schnittstellen zu beschreiben, aufgrund fehlender Ressourcenorientierung ist dies jedoch nur bedingt sinnvoll. Die Web Application Description Language (WADL) adressiert dieses Problem, gilt in der Praxis aufgrund der vorliegenden XML-Struktur jedoch als umständlich und wurde nie standardisiert. Stattdessen hat sich Swagger durchgesetzt, eine leichtgewichtige Möglichkeit, um APIs im JSON- bzw. YAML-Format zu definieren. Die Spezifikation wird seit einiger Zeit herstellerneutral unter dem Mantel der Linux Foundation von der Open API Initiative (OAI) weitergetrieben und seitdem unter dem Namen OpenAPI Specification geführt. Neben dem generellen Funktionsumfang werden im Vortrag die Verbesserungen der Version 3 vorgestellt. Am Beispiel in Kombination mit JAX-RS, Apache CXF und Spring Boot wird verdeutlicht, wie einfach sich Schnittstellenbeschreibungen in den Alltag integrieren lassen.
Bei aller herrschenden Euphorie über Client-seitige JavaScript Entwicklung mit Unterstützung diverser Frameworks wagt man es gar nicht so laut zu sagen: die Effizienz sowohl während der Entwicklung als auch während der Wartung ist dürftig. - Leidtragende sind insbesondere Geschäftsanwendungen mit einer hohen Anzahl an Dialogen unterschiedlichster Komplexität, mit hohen Anforderungen an eine langfristige Lauffähigkeit und mit einer meist überschaubar großen Entwicklungsmannschaft, die das stemmen darf. - Im Vortrag werden die Effizienzprobleme einerseits dargestellt und analysiert. Andererseits werden konkrete Lösungswege aufgezeigt, die innerhalb der CaptainCasa Community entwickelt und erfolgreich umgesetzt wurden. Der Vortrag ist gespickt mit einer Menge von live-Beispielen - schließlich geht's ja um ein UI-Thema!
The way we design, develop and run applications on cloud native platforms like Kubernetes differs significantly from the traditional approach. When working with Kubernetes, there are fewer concerns for developers to think about, but at the same time, there are new patterns and practices for solving every-day challenges. In this talk, we will look at a collection of common patterns for developing cloud native applications. These patterns encapsulate proven solutions to common problems and help you to prevent inventing the wheel again. After a short introduction into the Kubernetes platform we will look at the following pattern categories:
In the end, you will have a solid overview how common problems can be solved when developing Cloud Native application for Kubernetes.
In den vergangenen Releases von JavaScript sind eine ganze Reihe von Features hinzugekommen, die das Arbeiten mit der Sprache deutlich angenehmer machen als früher. Allerdings gehört ein Typsystem bislang nicht dazu. Glücklicherweise gibt es mit TypeScript eine Sprache, die dieses Problem adressiert und ein sehr leistungsfähiges Typsystem für JavaScript zur Verfügung stellt. In dieser Session stelle ich Ihnen Konzepte und Syntax von TypeScript anhand von Codebeispielen vor. Damit Sie nach der Session entscheiden können, ob TypeScript auch für Ihr Projekt die richtige Wahl ist, werden wir einen Blick über den Tellerrand werfen. Zum Beispiel sehen wir uns an, wie Sie Ihren bestehenden Code Schritt für Schritt migrieren können, wie Sie Bibliotheken verwenden können, die nicht mit TypeScript entwickelt wurden, wie es um das Tooling (z. B. IDE-Unterstützung) bestellt ist und wie sich TypeScript-Code debuggen lässt.
Mit der Anwendung „IDMS“ haben die Bundesdruckerei und Cegeka eine innovative Blockchain-basierte Basisplattform für das Management von sämtlichen Identitäten in einem Unternehmen entwickelt. Diese ermöglicht es, die Vorteile der Digitalisierung zu nutzen und zugleich die damit verbundenen Sicherheitsaspekte zu steuern. In ihrem Vortrag berichten Dr. Manfred Paeschke, Bundesdruckerei, und Dr. Georg Loepp, Cegeka, von dem gemeinsamen Projekt. Sie erläutern das zugrunde liegende Blockchain-Konzept und schildern, wie die Lösung in Zusammenarbeit agil umgesetzt wurde. Zudem stellen sie Beispiele für konkrete Einsatzszenarien von IDMS in der Praxis vor.
Der Vortrag nimmt das Auditorium mit auf die spannende Entstehungsreise der Deutschen-Bank-Mobile-App. Vom initialen Start in einem traditionellen Umfeld bis hin zu einem global skalierten Ansatz, den die Entwicklungsteams im Bereich der Deutschen-Bank-Mobile-Apps erfolgreich leben. Wir zeigen auf, wie Agilität und Skalierung zusammen mit einem modernen Softwareentwicklungsprozess es uns ermöglichen, unseren Kunden mehrfach ausgezeichnete Produkte in kürzester Zeit zur Verfügung zu stellen. Freuen Sie sich auf einen interessanten Vortrag, in dem Sie die Möglichkeit haben, das mobile Banking der Zukunft zu erleben und einen exklusiven Einblick in die technische Welt der modernen Softwareentwicklung der Deutschen Bank Digital Factory zu erhalten.
Wenn wir im Team agil Software entwickeln, dann ist unsere Prämisse „value working software over documentation (Agile Manifesto)“. Unter diesen Bedingungen ist es schwer zu argumentieren, wozu die Architekturtapeten, die von Enterprise-Architekten oftmals upfront erstellt werden, wirklich gut sind.
Arbeite ich aber in einem Konzern, in dem für jede Applikation eine Organisationseinheit verantwortlich ist und in dem das neu zu erstellende System mit 75-90 Bestandssystemen interagiert, benötige ich eine Landkarte dieser Abhängigkeiten.
Dieser Vortrag gibt auf Basis konkreter Projektsituationen Antworten drauf , wie man diesen Spagat zwischen Agilität und Enterprise Architecture schaffen kann, ohne die Teams mit vorweggenommenen Entscheidungen vor den Kopf zu stoßen und im Elfenbeinturm zu enden.
Das Informationszeitalter hat vieles auf den Kopf gestellt, unter anderem auch die Anforderungen an Unternehmen. Um für Kunden relevant zu bleiben, müssen sich diese kontinuierlich neu erfinden. Dieser stetige Wandel hat nicht zuletzt auch Einfluss auf die Software und Systeme sowie die Personen, die diese entwickeln. Eine dabei bedeutende Aufgabe kommt den (Software-)Architekten zu. Der Vortrag geht auf die Besonderheiten der Produktentwicklung in Digitalunternehmen ein.
Ausgehend davon, was dieses Umfeld auszeichnet, wird die Rolle des Softwarearchitekten abgeleitet und zu gängigen Rollendefinitionen sowie anderen Industrien abgegrenzt. Dabei wird auch darauf eingegangen, mit welchen modernen Methoden Unternehmen (und insbesondere die Produktentwicklung) diesen Anforderungen begegnen, warum sie selbst für dieses Umfeld oft nicht weit genug gehen.
Anhand von zwei Praxisbeispielen wird die Theorie auf die Realität angewandt. Dabei wird jeweils auf die spezifischen Problemstellungen, Lösungsansätze sowie die Rolle des/der Architekten in diesem Kontext eingegangen.
Alle Softwarearchitekten und Software-Engineers, die Architekturen (von Digitalunternehmen) jeden Tag prägen und denken, dass Evolving Architecture und agile Methoden hierfür hinreichend sind, sind hier richtig aufgehoben.
Die Popularität der Sprache Kotlin ist in den letzten Jahren stark gestiegen. Fängt man an, Kotlin zu lernen und einzusetzen, übernimmt man typischerweise die Muster der bisher benutzen Sprachen. Überrascht stellt man dann beim Lesen fremden Codes fest, dass es auch anders geht. Der Vortrag stellt verschiedene Verwendungen von Kotlin vor, unter anderem: Build-Skripte in Gradle, React-Komponenten und Markup mit kotlin.js-Webanwendungen mit Ktor. Dabei wird besonders auf den kreativen Einsatz von Sprachfeatures eingegangen.
Im Docker-Universum kann man sich leicht verlaufen und verzetteln. In dieser Session möchte ich Ihnen daher einen Überblick über sinnvolle und weniger sinnvolle Praktiken im Umgang mit Docker und Werkzeugen aus dem Docker-Ökosystem geben, gesammelt in inzwischen mehr als vier Jahren produktivem Einsatz von Docker. Dabei betrachten wir Themen wie das Erstellen von Images, Volumes, Logging, das Sammeln von Metriken, und auch die Orchestrierung darf natürlich nicht fehlen.
Mobile First war gestern, Offline First heißt die neue Devise. Mit diesem Credo kommen Progressive Web Apps (PWA) nicht nur sehr nahe an native Smartphoneapplikationen heran, sie erhöhen vor allem die User Experience bei fehlender oder sehr schlechter Internetverbindung und müssen nicht mehr über App Stores ausgeliefert werden. Anhand einer Beispielapplikation werden wir die Grundkonzepte wie Service Worker, Application Shell, Caching und Push Notifications diskutieren und einen Ausblick auf die mobilen Anwendungen der Zukunft werfen.
Spring Security ermöglicht es, Microservices und Self-contained Systems auf Basis von Rollen und Rechten abzusichern. Eine Prüfung auf Objektebene, z. B. dass ein Kunde nur auf seine eigenen Bestellungen zugreifen darf, ist auch möglich und über verschiedene Wege nutzbar. Erfahren Sie hier in einer Livedemo mit der aktuellen Version von Spring Security, wie ein SCS umfassend abgesichert werden kann und welche neuen Funktionen in Version 5 dazugekommen sind.
So oder so ähnlich könnte man es beschreiben, wenn das API das Erste ist, das für ein neues Produkt entwickelt wird. In den guten alten Zeiten von Web Services nannte man dieses Vorgehen Top-down. Die WSDL war die einzige Wahrheit. Aus ihr wurden Code und Dokumentation erzeugt.Der Talk zeigt, wie das bekannte Top-down-Vorgehen in der neuen Serverless-Welt funktionieren kann. Wir zeigen, welche Vorteile das Vorgehen bringt, welche Tools und Services uns besonders geholfen haben und welche Möglichkeiten es gibt, das entwickelte API in AWS zu deployen.
It is widely accepted that in order to avoid data swamps you need metadata tags in your data lake. As the demand for business wide client and regulatory views increase, demands are also increasing with regard to operationalising the data lake itself. In this session you will see how NoSQL technologies are ideally suited to tackling this challenge. Approaches will be shown which iteratively define new entities for individual business lines, empower downstream consumers, and operationalise of the data lake itself.
As they say, nothing is more dangerous than using yesterday’s logic for today’s problems, yet we are still working in our organisations with mental models that were inspired by manufacturing. You can see artefacts of it even in the language we use: people are resources and they work in development factories. If we are surprised why our transformations are not progressing as fast as we hoped when Agile took the stage, then looking to these old mental models provides part of the answer.
In this talk I will explain from practical experience in my work, how the old models still influence us every day and how we can break away from them and learn new models. I will give positive and negative examples from real projects to show that it is normal to experience failures and how to course correct from the lessons such failures teach us.
I will also provide pragmatic steps that everyone can take in their own organisations that don’t rely on buying new tools or following specific methods. Charting your own course starts with understanding where the problem is and understanding where our mental models let us down is part of that journey.
Fehlende Typisierung, uneinheitliche Implementierungen und nicht zuletzt eine Sprache, die auch mit syntaktischen Fehlern "irgendwie" läuft, haben den Ruf von JavaScript beschädigt.TypeScript konnte viele dieser Probleme verbessern. Mit dem neuen jährlichen Releasezyklus von ECMAScript (Standardisierung von JavaScript) werden nun jedoch jedes Jahr einige Unterschiede zwischen den beiden Sprachen abgebaut. Die Session zeigt die neuesten Feature von ECMAScript, die weiterhin bestehenden Unterschiede zu TypeScript und klärt die Frage, ob wir TypeScript langfristig noch brauchen. Dabei werden neben den Erweiterungen neuerer ECMAScript-Versionen auch die Weiterentwicklungen von TypeScript beleutet und deren Vorteile für größere Entwicklungsprojekte in den Vordergrund gestellt.
What makes Cloud Foundry the best place to run Java microservices? Looking beyond the Java buildpack -- we'll examine what makes a distributed platform such a perfect fit for distributed applications. How can BOSH managed microservice infrastructure make life easier for DevOps teams once a service has been deployed? What could operational automation look like for critical functions like service discovery, circuit breaker monitoring, and configuration services? Application and operations-focused developers, Architects, and IT managers will walk away with a solid introduction to what makes Spring Boot, Spring Cloud, and Spring Cloud Data Flow workloads exciting on Cloud Foundry.
Finde heraus, wie wir "DevOps" interpretieren, um über fünfhundert Änderungen pro Woche auf eine der hundert meistbesuchtesten Websites der Welt - GitHub.com - ausspielen zu können! Erhalte einen Eindruck davon, wie ChatOps dabei hilft, Kommunikationsbarierren zwischen Entwicklern, Administratoren, Support und Vertrieb abzubauen und den DevOps-Gedanken über Abteilungsgrenzen auszudehnen!
Mit folgenden Themen wird sich diese Keynote im Deteil beschäftigen:
• GitHubs DevOps-Verständnis
• Die vier Hauptzutaten von GitHubs DevOps-Rezept
• "Zen of GitHub" als Unternehmensleitplanken für Featuredesign, interne und externe Kommunikation sowie Entscheidungsfindungen bei Unklarheiten und Konflikt
• GitHubs verteilte Organisation und "Asynchronous First"-Philosophie
• Livedemo mit Beispielen von Solutions Engineering, Marketing und Engineering
• Einführung in GitHubs Deployment-API
• Einführung in ChatOps am Beispiel von Hubot
• ChatOps im Kontext Continuous Deployment
• Feature Toggles @ GitHub
• Refactoring in Produktion @ GitHub
• GitHubs Produktvision und Hubots Rolle darin
• GitHubs DevOps-Definition für die Zukunft
RESTful Web Services sind schon seit einiger Zeit in aller Munde und sehr beliebt. Viele der bekannten öffentlichen Web-APIs behaupten von sich, RESTful zu sein. Viele aktuelle APIs erfüllen ein wichtiges Element von REST allerdings nicht: Hypermedia as the Engine of Application State (HATEOAS). Diese Session gibt einen Überblick über das Thema und zeigt an vielen konkreten Beispielen, warum RESTful Hypermedia-APIs sinnvoll und sehr nützlich sind. Dabei gehe ich sowohl auf verschiedene Repräsentationen wie HAL und Siren ein als auch auf deren Einbindung in existierende Infrastrukturen, wie den Spring Stack. Auch für das Erstellen von API-Dokumentation gebe ich praxisnahe Tipps. Ziel dieser Session ist es, am Ende selbst beurteilen zu können, ob Hypermedia für das eigene REST-API Vorteile bringt.
Apache ActiveMQ Artemis ist der potenzielle Nachfolger von Apache ActiveMQ und basiert auf dem Code der Hornet MQ, der der Apache Foundation geschenkt wurde. Da Artemis wahrscheinlich ActiveMQ beerbt, gibt es Grund genug, Artemis genauer zu betrachten. Daher gehe ich in diesem Vortrag auf die Architektur von Artemis ein und stelle seine Clustering-Fähigkeiten und die Vielzahl der neben JMS unterstützten Protokolle vor. Abgerundet wird der Vortrag durch die Vorstellung einer Message-Queue-basierten Microservices-Anwendung für ein Abrechnungssystem der Deutschen Post AG, in der Artemis zur Orchestrierung des Nachrichtenflusses eingesetzt wird.
Die Entwicklung einzelner Komponenten und Anwendungen mit React ist nicht schwierig, zumal das API von React sehr schmal und deswegen schnell erlernt ist. Für größere Enterprise-Anwendungen ergeben sich aber eine ganze Reihe von Fragen. Zum Beispiel wie die Anwendung strukturiert wird und wie Third-Party-Bibliotheken integriert werden. Oder wie ein Typ-Checker (z. B. TypeScript) verwendet werden kann, um auch Anforderungen an Langlebigkeit und Wartbarkeit der Anwendung zu erfüllen. Und nicht zuletzt: Worauf kann geachtet werden, um die Performance der Anwendung zu erhöhen? In dieser Session möchte ich Ihnen mögliche Antworten auf solche Fragen geben, und natürlich werden Sie auch Gelegenheit haben, eigene Fragen einzubringen.
In der Holzklasse fehlt es an Komfort, aber es ist billig und man kommt genauso schnell ans Ziel wie in der ersten Klasse. Kann man so auch Web Scale machen? Also hochskalierbare, hochverfügbare und sichere Systeme für ein Taschengeld bauen?
In diesem zweiteiligen Vortrag will ich zeigen, dass verteilte Architekturen weder schwarze Magie noch teurer Enterprise-Luxus sein müssen und dass man in der Cloud mit einfachen Mitteln anbieterneutral bleiben kann
Teil 1 startet mit einer empirisch-funktionalen Definition von Web Scale und dann tauchen wir ein in die harten Probleme verteilter Systeme. Ich stelle eine Systemarchitektur vor, die einem relativ unbekannten dritten Weg folgt, der die Skalierbarkeit von Microservices mit der Handhabbarkeit von Monolithen verbinden will. Und genau dieses auf Github verfügbare, technisch ausimplementierte System zeige ich dann live mit allen Konsequenzen. Denn nur mit Hello-World Komponenten und isoliertem Beispielcode kann man dem Thema Verteilung nicht beikommen. Erst zur Laufzeit werden Trade-offs und Design-Entscheidungen wirklich erlebbar.
Docker hat sich in den letzten Jahren von einer Nischentechnologie zu einer stabilen Plattform für den Betrieb von großen Produktions-Workloads entwickelt. In dieser Session werden wir den aktuellen Stand der Technik für die Entwicklung von auf Docker basierenden Anwendungen betrachten. Daneben werden wir unterschiedliche Möglichkeiten beleuchten, Container-Workloads skalierbar und sicher auf AWS zu entwickeln und zu betreiben. Neben den eigentlichen Services und Technologien für den Betrieb von Containern werden wir auch Best Practices und Patterns in Bezug auf Continuous Delivery, Sicherheit, Isolation und Skalierung behandeln.
Die Grundlagen funktionaler Programmierung, also Funktionen, unveränderbare Daten, und Assign-once-Variablen sind einfach zu verstehen. Schwieriger wird es für fortgeschrittene Konzepte. Dazu zählen unter anderem Higher-Order-Funktionen, Currying, Effekt-Tracking und Caching von Funktionsaufrufen sowie der systematische Umgang mit veränderbaren Daten oder zustandsbehaftetem Verhalten. In dieser Session erkläre ich diese Techniken auf Basis einer minimalen funktionalen Sprache. Über die letzten Jahre habe ich eine eigene funktionale Programmiersprache gebaut, die als Kern von DSLs zum Einsatz kommt. Die Struktur und das Typsystem der Sprache sind in MPS entwickelt, die Semantik ist durch einen in Java implementierten Interpreter definiert. Alle Interna der Sprache sind also weitgehend deklarativ oder mittels Java-Code realisiert und eignen sich dadurch hervorragend zur Erläuterung der Konzepte. Die Session hat nicht zum Ziel, MPS als Language Workbench zu erklären. MPS ist nur didaktisches Werkzeug, um die Implementierung der interessanten Konzepte einer funktionalen Sprache zu erläutern. Die Session besteht zum Großteil aus Demo und Live Coding.
Seinen Mitarbeitern oder Kollegen Feedback zu geben, ist gar nicht so einfach. Aber wie adressiere ich neben Lob auch Dinge, die es zu verbessern gilt? Wie schaffe ich bei meinem Gegenüber die Einsicht für Verbesserungspotenzial, ohne sie oder ihn vor den Kopf zu stoßen oder gar zu demotivieren? Auf Fehler angesprochen zu werden, ist schon unangenehm genug. Klar zu machen, dass an den Mitarbeiter höhere Erwartungen gestellt werden, bedarf einer professionellen Gesprächsstrategie, damit die Botschaft richtig beim anderen ankommt. Aber auch Lob aussprechen will gelernt sein, denn unangebrachte Streicheleinheiten für Banalitäten lösen beim Mitarbeiter eher Unmut als Zufriedenheit aus. Erfahren Sie in dieser Session, wie man Lob und Kritik erfolgreich kommuniziert und richtig dosiert. Zu Risiken und Nebenwirkungen sowie umfangreichen Fragen aus dem Arbeitsalltag wenden Sie sich an die Sprecherin.
Are you a developer who is tired of null pointer exceptions, SQL
injections, concurrency errors, and other errors that appear during
testing or in the field? You need a tool that can guarantee the
absence of these errors, and of many other important bugs.
Are you a software architect who wants to implement custom checks that
enforce correct usage and prevent errors? You need a framework that
supports you in creating a code checker that works at the semantic
level.
This tutorial is aimed at both audiences. It will teach you about
pluggable type-checking and the Checker Framework, an open-source tool
that provides more than a dozen checkers that are ready to use,
including ones for nullness, formatting, and concurrency. They have
found hundreds of bugs in well-tested open source code, including from
Oracle, Google, Apache, etc., and even when other tools like FindBugs
gave the code a clean bill of health. The Checker Framework also
enables you to create your own new pluggable type system.
You will leave the tutorial ready to improve your code.
The tool is freely available at http://CheckerFramework.org/.
You have nothing to lose but your bugs!
Die Kombination aus Java im Backend und JavaScript im Frontend gehört aktuell zu den beliebtesten Kombinationen im Architekturtechnologiedschungel. Vor allem für Projekte mit langfristigem Wartungshorizont kann diese Kombination allerdings durchaus tückisch sein. Kompatibilitätsprobleme bei Änderungen der Schnittstelle sind in großen Projekten praktisch vorprogrammiert. Mehrere Lösungsansätze sollten in Betracht gezogen werden: Schnittstellenänderungen auf ein Minimum reduzieren, Codegenerierung mithilfe einer Schnittstellenbeschreibungssprache (z.B. Swagger oder JSON Schema) oder sogar zurück zur durchgängigen Verwendung einer gemeinsamen Sprache im Frontend und Backend. Die Session gibt einen Überblick über die möglichen Umsetzungen und zeigt beispielhaft eine durchgängige Toolkette sowie ihre Vor- und Nachteile.
With the continuing rise of cyber crime it is vitally important for Java programmers to learn how to code defensively. This talk provides direct coding advice on how to avoid each of the seven categories of security errors commonly made. These categories, or the Seven Pernicious Kingdoms: as they are sometimes known, range from input validation though to environmental and infrastructure considerations. In this talk you will learn how your Java application may be vulnerable and see how to reduce your exposure. With code, tooling and practical guidance on reducing your exposure this session will teach you how to think and act defensively.
Technische Dokumentation sollte man nicht mit Textverarbeitungsprogrammen erzeugen. Stattdessen ergibt es Sinn, die Erstellung in die normalen Entwicklungsprozesse einzubeziehen, sie zu automatisieren (Continuous Documentation) und mit den typischen Werkzeugen der Entwickler sowie mittels leichtgewichtigen Textformaten zu bearbeiten (Documentation as Code).
Anhand einer Architekturdokumentation zeigen wir, wie Sie mit dem arc42-Template im AsciiDoc-Format und Gradle als Build-Tool einfach Diagramme in Ihre Dokumentation integrieren, Stakeholder-spezifische Dokumente erzeugen und verschiedene Ausgabeformate generieren. Reviewfähige PDF-Dokumente? Publishing nach Confluence? Integration einer Präsentation? Alles kein Problem! Einige Teile der Doku können Sie sogar automatisiert testen. Zwischendurch bekommen Sie zahlreiche Tipps, wie und wo Sie systematisch den Aufwand für Dokumentation reduzieren können und trotzdem lesbare, verständliche und praxistaugliche Ergebnisse produzieren. Dokumentieren soll endlich auch Spaß machen.
Vorbei sind inzwischen die Zeiten, in denen man rein mit Docker-Containern Systeme in Produktion gebracht hat. Load Balancer, Storage, Multihostumgebungen usw. sind immer wichtiger für die Produktionsführung. Wer Zero Downtime Deployment und einige andere Benefits nutzen will, hat dies inzwischen mit Kubernetes und einem großen Baukasten and Komponenten umgesetzt. Doch warum immer alles selbst „zusammenbauen“? CI/CD und automatisches Deployment sowie automatische Skalierung stehen ebenso auf der Wunschliste des ambitionierten DevOps-Engineers. OpenShift bietet hier eine mächtige Sammlung an Unterstützung; die perfekte Ergänzung zu Docker und Kubernetes. Der Vortrag zeigt die Konzepte und gibt mit reichlich Demos erste Einblicke in OpenShift und macht Lust auf mehr.
"Composition over Inheritance" - mit diesem Schlachtruf forderten wir in Teil 1 die Gottesanbieterin PAAS heraus. Die spannende Frage war: können die Services mit unserer Choreographie selbständig tanzen oder werden wir am Ende alle orchestriert?
In Teil 2 des Vortrags erkläre ich mit welchen Holzklasse-Mitteln wir die Schlacht (hoffentlich) gewonnen haben. Besprochen werden anbieterneutrale Cloud APIs, Service Discovery, client- und serverside Load Balancing, Transportverschlüsselung, Infrastructure as Code, PubSub, selbstheilende Systeme, Secrets Management, schemafreie Datenhaltung, JavaScript Micro-Frameworks und einiges mehr. Dazu gibt es noch eine Demo "Auto-Scaling ohne Auto" oder "How I learned to Stop Worrying and Love Cut&Paste".
Über die Gesamtdauer des Vortrags ist zu rechnen mit provokanten Thesen, irren Memes und unheilvollen Rants - in Teil 2 dann beispielsweise zum Thema "Sicherheit in Zeiten von NoSQL und Single Page Applications". Ein pragmatischer Spickzettel sorgt am Ende aber dafür, dass man auch etwas Handfestes mit nach Hause nehmen kann.
Von Docker hat sicher jeder Entwickler schon einmal gehört. Doch Container allein reichen nicht aus, um komplexe Anwendungen containerbasiert in Produktion zu bringen. Load Balancing, Fehlertorleranz, Continuous Integration und Delivery, Logging/Monitoring sowie Releasemanagement sind einige weitere wichtige Bereiche, um erfolgreich Softwareprodukte auszurollen.
Kubernetes hilft in vielen Bereichen, diese Ziele und Aufgaben zu meistern. Dabei kommen weitere Begriffe und Konzepte zum Einsatz, die den Bereich der Container in die Cloud übergeben und es erlauben, aus vielen „kleinen” Hosts einen einzelnen großen Host zu modellieren, der dann von vielen Automatismen profitiert. Aber auch Kubernetes ist lediglich ein Stück Technologie, das die Grundlage für weitere Themen, wie die Unterstützung der entsprechenden Release- und Entwicklungsprozesse vereinfachen soll.
Für den allumfassenden Blick auf das DevOps-Thema kommt schlussendlich noch OpenShift von Red Hat ins Spiel. Hier können alle zuvor genannten Aspekte zusammengeführt und genutzt werden.
Wie das Zusammenspiel der unterschiedlichen Technologien funktioniert, wird umfassend und praxisnah in diesem Workshop vermittelt. Von den Grundbegriffen der Container bis hin zum Liveaufbau einer privaten Cloud auf physikalischen Hosts wird den Teilnehmern einiges geboten, was über die Inhalte typischer Tutorials und Blog-Posts hinausgeht.
Java Persistence API und Hibernate als dessen beliebteste Implementierung werden häufig für die Erstellung einfacher CRUD Use Cases verwendet. Erfahrenen Entwicklern bietet das Framework aber deutlich mehr als nur die Persistierung einfacher Datenstrukturen in einer relationalen Datenbank. Neben einem mächtigen API zur typsicheren, programmatischen Erzeugung von Datenbankabfragen und der Verwendung beliebiger Stored Procedures und Datenbankfunktionen können auch eigene Datentypen mit nur geringem Entwicklungsaufwand unterstützt werden. Wie und wann Sie diese Features in Ihren Projekten einsetzen können, zeige ich in diesem Workshop. Im Rahmen dieses Workshops wird eine Auswahl fortgeschrittener Hibernate-Features anhand praktischer Beispiele und Übungsaufgaben vorgestellt. Dazu zählen:
Das automatisierte Konfigurieren von Servern ist dank Orchestrierungswerkzeugen wie Puppet und Chef heute kein Problem mehr. Doch eignen sich diese Werkzeuge wenig für die regelmäßige Softwareverteilung von typischen Java-Webapplikationen. Ansible hat dieses Problem erkannt und liefert Lösungen für das Konfigurationsmanagement und für die Softwareverteilung aus einer Hand. Dieser Workshop erklärt am Beispiel einer Infrastruktur für eine Java-Webapplikation die Funktionsweise von Ansible. Die Teilnehmer lernen Schritt für Schritt, wie eine Serverkonfiguration und auch das Deployment der Java-Webanwendung mit Ansible automatisiert wird.