JUG Bonn

18:00 - Einlass und Begrüßung 18:15 - Talk #1: Warum kompliziert, wenn es auch einfach geht? 19:00 - Talk #2: Microservices mit Domain-Driven Design fachlich schneiden 19:40 - Pause 20:20 - Talk #3: Herausforderungen, Datenbanken in Containern zu betreiben 21:00 - Networking Dank freundlicher Unterstützung vom Rheinwerk Verlag verlosen wir an dem Abend 2 Bücher! ------------------------------------------- Talk #1: Warum kompliziert, wenn es auch einfach geht? Kennen Sie das auch? Ein Team diskutiert über ein Problem. Am Anfang werden die „einfachen“ Lösungen diskutiert, schnell aber als „Das ist zu einfach! Das kann nicht sein!“ verworfen. Meist geschieht dies, ohne ernsthaft über die „simple Lösung“ als echte Möglichkeit nachzudenken. Es folgt eine lebhafte, zeitweilen zeitintensive Diskussion, begleitet von Annahmen und Hypothesen, die in der Regel gar nicht überprüft, sondern als gegeben angesehen werden. Am Ende steht dann die komplizierte Lösung. Und bei der Umsetzung stellt sie sich als falsch heraus! Oder es werden Lösungen gebaut, die außer dem Urheber niemand versteht oder extrem viele Abhängigkeiten aufweisen – allerdings wird das meist erst Monate später – oft schmerzhaft – klar! Doch obwohl wir alle das KISS-Prinzip (Keep it simple, stupid!) kennen, neigen wir dazu, „einfache Lösungen“ als minderwertig zu betrachten. In diesem Vortrag schauen wir auf die Auswirkungen in der Softwareentwicklung, wenn wir Ansätze wie „Kiss“ oder „Ockham´s Razor“ ignorieren. Wir betrachten dabei besonders die Aspekte Zeit, Wartbarkeit und Abhängigkeiten. Außerdem werden wir einen Blick auf die Bedeutung dieses Verhaltens auf die Bereiche Veränderung, Improvement und Innovation werfen. Wir werden außerdem uns damit beschäftigen, warum es wichtig ist, ein Problem zu verstehen, um die richtige Lösung zu finden. Verschiedene Ideen für Teams, sich dieser Thematik zu nähern, werden in dem Vortrag erörtert. Speaker: Sabine Wojcieszak (getNext IT) Twitter: @SabineBendixen ---------------------------------------------------- Talk #2: Microservices mit Domain-Driven Design fachlich schneiden Beim Bauen von Microservices werden tolle Technologien, Programmiersprachen und Tools eingesetzt. Das ist gut und richtig. Aber leider wird dabei oft aus den Augen verloren, dass das Entscheidende nicht die Technik, sondern die *Fachlichkeit* ist. Wenn wir unsere Microservices nicht nach fachlichen Aspekten schneiden, dann entsteht der BigBallofMud einfach nur auf der nächst höherer Ebene. Um das zu verhindern, zeige ich Ihnen in diesem Vortrag, welche Konzepte DDD für uns bereithält, damit unsere Microservices fachlich sinnvoll abgeschlossene Einheiten bilden. Speaker: Dr. Carola Lilienthal (WPS) Twitter: @Cairolali ---------------------------------------------------- Talk #3: Herausforderungen, Datenbanken in Containern zu betreiben In den vergangenen Jahren haben wir unsere Anwendungen in Container verpackt, um diese zu isolieren und einfach auslieferbar zu machen. Nun kämpfen wir damit, Anwendungen mit Daten in Containern zu betreiben, um sie fehlertoleranter und skalierbarer zu machen. Daher betreiben wir Datenbanken meistens in separaten Clustern, weil es doch relativ hart ist, diese sinnvoll in Containern zu orchestrieren. Das bedeutet allerdings, dass wir unsere Cluster nicht optimal ausnutzen und Skalierungseffekte zwischen zustandslosen und zustandsbehafteten Anwendungen verschenken. Aber was bedeutet es eigentlich, eine Datenbank in einen Container zu stecken? Über welche Dinge sollte ich mir Gedanken machen? In dieser Session werden wir analysieren, welche Auswirkungen Container auf Plattenzugriffe, auf Netzwerke oder CPU-Auslastung haben. Weiterhin werden wir Persistenz, Replikation, Backups oder Integration in modernen Orchestrierungs-Frameworks wie Kubernetes oder DC/OS diskutieren. Speaker: Johannes Unterstein (Neo4j) Twitter: @unterstein

18:30 - Einlass und Begrüßung 19:00 - Talk #1: Zwischen den Zeilen lesen - Datenanalyse mit Graphen 19:40 - Pause 20:20 - Talk #2: Continuous Integration Extreme! 21:00 - Networking Dank freundlicher Unterstützung vom Rheinwerk Verlag verlosen wir an dem Abend 2 Bücher! ------------------------------------------- Talk #1: Zwischen den Zeilen lesen - Datenanalyse mit Graphen n diesem Vortrag zeigen wir an einem Anwendungsfall aus der Dokumentenverwaltung auf, wie man neue Erkenntnisse aus existierenden Daten und besonders deren Strukturen gewinnen kann. Viele arbeiten mit verstreut gespeicherten Daten, die nicht wirklich gut ausgewertet und hinterfragt werden können. Fragen nach kausalen Zusammenhängen können oft nicht beantwortet werden. Detektivisch begeben wir uns auf die Suche nach Antworten und erläutern nebenbei grundlegende Graphenalgorithmen und den Umgang mit verlinkten Daten. Schritt für Schritt gehen wir von der Modellierung in die Analyse der Daten über. Es werden Wege aufgezeigt, wie komplexe Zusammenhänge zwischen Daten aus verschiedenen Quellen aufgespürt werden können. Graphdatenbanken sind das Tool der Wahl, wenn es um Verknüpfung heterogener Daten geht. Ob aufgrund der verschiedenen Datenquellen, Datentypen oder Formate: Durch das flexible Schema lassen sich die in einem Graphenmodell abgelegten Daten nach Bedarf dynamisch umstrukturieren und neu verlinken. Wie das funktioniert, wird während des Vortrags demonstriert. Unser Werkzeuge sind die Graphendatenbank Neo4j und die Abfragesprache Cypher. Beide sind sehr intuitiv, einfach und trotzdem mächtig in der Benutzung. Die für uns relevanten Handgriffe im Umgang mit den Tools werden begleitend erläutert, sodass Zuhörer auch ohne Vorkenntnisse dem Vortrag folgen können. Speaker: Iryna ist IT-Consultant und Software-Entwicklerin mit Schwerpunkt Data Engineering by PRODYNA AG. Themen wie Linked Data, Graphen und Graphendatenbanken gehören zu Ihren Steckenpferden. ---------------------------------------------------- Talk #2: Continuous Integration Extreme! „If it hurts, do it more often“ ist das Credo, das die DevOps Bewegung populär gemacht hat. Aber das Prinzip ist alter Käse. Schon das XP Framework hatte in den 1990ern mit „Continuous Integration“ eine Praktik im petto, die auf dieser Einsicht fußt. Paradoxerweise gewinnen Feature Branching und „Git Flow“ heute an Popularität und die unterliegende Einsicht scheint immer mehr in Vergessenheit zu geraten. Nur manchmal dämmert so manch einem die Erkenntnis, warum das Merging von langlaufenden Feature Branches immer so aufwendig ist und jedes Refactoring bei den Kollegen auf wenig Gegenliebe stößt. Nach einer kurzen Rückbesinnung auf die ursprüngliche CI Praktik möchte ich euch zeigen, wie weit man mit dieser Praktik eigentlich gehen kann. Und welche Vorteile eine konsequente kontinuierliche Integration hat. Dabei meine ich nicht Continous Delivery. Wir werden uns mit den Techniken beschäftigen, die eine kontinuierliche Integration von Großen Refactorings möglich machen. Und wir werden sehen, dass man auch mit Depenendcies wie Libraries, Frameworks oder sogar Services kontinuierlich integrieren kann. Und das, ohne dass der Build durch „Upstream Changes“ kaputt gemacht wird. Aber auch das lästige Problem, dass ein kaputter Stand im Repo gelandet ist, wird uns beschäftigen. Ihr werdet sehen, dass Continuous Integration mehr als nur das Aufsetzen eines Build Servers bedeutet. CI ist vielmehr eine Art zu arbeiten, die sehr viele Vorteile mit sich bringt. Speaker: Johannes Seitz studierte Informatik an der Goethe Universität Frankfurt und der ETH Zürich. Als Architekt und Coach hilft er bei INNOQ Teams dabei passende Softwarearchitekturen zu finden, die Projekten zum Erfolg zu verhelfen. Darüber hinaus schreibt und redet er gerne über Methoden der agilen Softwareentwicklung, DevOps Praktiken, moderne Softwarearchitektur, Domain-driven design und testgetriebene Entwicklung.