Reactive-Streams wenden die bewährtesten Architektur-Paradigmen auf verteilte Systeme in Internet-Dimension an. Non-Blocking Back-Pressure ist der Schlüssel zur Entkopplung bei individueller Versorgung unterschiedlichster Clients. Mit der Klasse Flow haben sie es ins JDK geschafft und gehören somit in den Werkzeugkasten der versierten Java-Entwickler:innen. In diesem Tutorial erlenen Sie die effiziente Architekturkonzeption und Programmierung mit Reactive-Streams. So lernen Sie auch einzuschätzen, für welche Use-Cases dieses Paradigma geeignet ist.

Maximale Teilnehmerzahl: 25

Zielpublikum: Entwickler/Architekt:innen mit Bezug zu nachrichtenbasierten, reaktiven, nebenläufigen Systemen
Voraussetzungen: Java-Sprachverständnis
Schwierigkeitsgrad: Anfänger

Extended Abstract:
Back to the Future:Reactive-Streams greifen die Lehren aus Jahrzehnten der Software-Architektur auf und wenden die etabliertesten Patterns und Paradigmen auf die Anforderungen des Internet-Zeitalters an. Sie treten mit dem Versprechen an, Architekturziele wie Skalierbarkeit, Resilienz, Verfügbarkeit und Wartbarkeit zu erreichen. Dafür postuliert das Reactive-Manifesto einen Architekturstil, der Lose Kopplung der Komponenten eines verteilten Systems mit individueller und kontinuierlicher Versorgung aller Clients mit spezifischen Datenströmen durch das Konzept des Non-Blocking Back-Pressure verbindet, „Observer Pattern done right“.

Heute ist das Reactive-Streams-Paradigma ein fundamentaler Baustein für APIs in unterschiedlichsten Anwendungsfeldern, von Netflix APIs bis hin zu Datenbank- und Netzwerkschnittstellen, und mit der Klasse Flow hat es Eingang ins JDK gefunden. Somit gehört es zum Basiswissen eines jeden versierten Entwicklers und Architekten.

In diesem Tutorial erlernen Sie den praktischen Umgang mit Reactive-Streams unter Verwendung der umfangreichen RxJava-Bibliothek, die ein Baukasten für die Realisierung verschiedenster Anwendungsfälle ist.

Sie sehen, wie Entkopplung elegant durch implizite Asynchronität realisiert werden kann, und Sie setzen Reactive-Streams ein, um zentrale nichtfunktionale Anforderungen, wie Skalierbarkeit und Performance, durch Parallelität und Nebenläufigkeit zu erreichen.

Sie erhalten einen tiefen Einblick in die Realisierungsstrategien aktueller Reactive-Streams Frameworks. Sie lernen dadurch einzuschätzen, für welche Use-Cases diese geeignet sind, und wie sie sich hinsichtlich funktionaler und nichtfunktionaler Charakteristika von anderen Technologien unterscheiden. Auf dieser Basis können Sie dann tragfähige Technologie- und Architekturentscheidungen für Ihre Projekte treffen.

You already heard a lot about Docker and Kubernetes, but never got really in touch with it ? Are you looking to build your very own Docker container and deploy it to Kubernetes with some rules of thumb?

This workshop provides participants with in-depth knowledge and hands-on experience with Docker & Kubernetes. We will start with explaining the main concepts before moving onto more advanced topics and with some insights & lessons learned from projects.

The workshop will include a combination of slides and hands-on exercises.

Maximum number of participants: 25

Target Audience: Engineers, architects, developers, juniors, students
Prerequisites: A notebook with internet connection, please see description
Level: Basic

Extended Abstract:
Containerize a distributed application, Deploy it to a Kubernetes Cluster, Connect the components to each other, Deploy for end-user including automatic scaling without downtime. Optional: Recovery, Logging, Testing

Technical Requirements:

Participants will be able to work in a provided cloud environment. They will need their own laptop/workstation with a stable Internet connection and a tool for secure terminal connections (putty, ssh or similar).

There is an industry trend where businesses are moving towards autonomous product teams. These teams aim to be end-to-end responsible for the product they are building and maintaining. To achieve end-to-end team autonomy, companies move towards a microservices architecture to successfully inspect and adapt. However, to be successful organisations need to have the correct boundaries for the microservices. Using the bounded context pattern from Domain-Driven Design it is possible to achieve team autonomy!

Maximum number of participants: 24

Target Audience: Architects, Developers, Testers, Analysts, Product Owner, Manager, Decision Makers
Prerequisites: None. It is an interactive workshop, with brown paper, post-its and whiteboards
Level: Basic

Extended Abstract:
There is an industry trend where businesses are moving towards autonomous product teams. These teams aim to be end-to-end responsible for the product they are building and maintaining. With the help of Continuous Delivery, teams have faster feedback cycles in which they can probe if a certain feature works. To achieve end-to-end team autonomy, companies move towards a microservices architecture to successfully inspect and adapt. To be effective with a microservices architecture, we require Conway's alignment, engineering teams aligned to business models/products; to achieve Conway’s alignment it’s required to design and model the domain. Domain-Driven Design’s bounded context is the essential pattern that helps to create Conway’s alignment.

Join us in this hands-on session where we show you how visual collaboration is the most effective way in co-creating sustainable Conway’s alignment. We will distil bounded contexts with visual collaboration tools Big Picture EventStorming, Context Mapping and the Bounded Context Canvas.

With visual collaboration:

- We create a shared understanding of the business flow, uncovering inconsistencies and competing goals

- Using the Theory of Constraints, we can discover, highlight and create a shared vision and strategy to focus our effort

- A critical part of doing visual collaboration is effective facilitation, especially facilitating workshops with +30 people at the same time

You leave our session understanding that to be effective with microservices, you need to start discover and design bounded contexts. You will learn heuristics that guide you in using visual tools in specific situations, and how to move on towards microservices.

It has been said that immutability changes everything. But what does that mean in practice? What does it mean for existing code that looks more like the mutant apocalypse than an elegant application of mathematical thinking?

Full immutability is not always possible. Refactoring, on the other hand, is all about the art of the possible. In this hands-on workshop (bring a laptop!), we'll be looking at some tricks and tips to help reduce mutability in code.

Maximum number of participants: 16

Target Audience: Developers, Architects
Prerequisites: Java or C# knowledge
Level: Advanced

Extended Abstract:
It has been said that immutability changes everything. But what does that mean in practice? What does it mean for existing code that looks more like the mutant apocalypse than an elegant application of mathematical thinking? Mainstream programming languages are normally grounded in imperative styles — from updating local variables to updating records in databases. But although they have grown from imperative roots, languages such as C# and Java are expressive and evolved enough that they can embrace many different approaches. Indeed, trends in the development of many languages have made immutability and the reduction of mutability easier to support.

Immutability is attractive because it makes code easier to reason about, reduces the possibility of many classes of bug, improves the testability of code, reduces the amount of validation and error-handling code, makes code more scalable when threaded and makes code more thread-safe. However, immutability can be an ideal that is hard to reach, and much advice doesn’t cover enough of the situations developers find in their codebases. Refactoring, on the other hand, is all about the art of the possible.

Whether you’re working in the cloud or on the desktop, in the mobile space or on the web, steering your code and design style towards immutability offers both short-term and long-term practical benefits. In this hands-on workshop, we’ll be looking at guidance and practice to help reduce the mutability of state in your codebase.

So bring a laptop, but don't worry about IDEs, editors, compilers and all that — just a browser and WiFi access! We'll be running the hands-on part using cyber-dojo.org, working with unit tests and good humour :-)

Agile testers need to lead the team, other testers, product owners and customers towards better quality. Yet agile teams don’t generally bestow formal authority. And, as testers, we’re often trying to lead from a position that is still not always appreciated.

The workshop will focus on hands-on exercises and activities for achieving enablement for whole team quality. No programming skills are necessary, but we will be doing some work involving code in groups and in a safe learning environment.

Maximum Number of participants: 12

Target Audience: Testers, developers
Prerequisites: None
Level: Basic

Extended Abstract:
The role of a tester on an agile team is so much more than “hey can you test this with your super testing skills”. Testers are, on the one hand, chameleons who need to adapt their skills to new situations within the team. On the other hand, we can’t just react to situations – we need to lead the team, other testers, product owners and customers towards better quality. Yet agile teams don’t generally bestow formal authority. And, as testers, we’re often trying to lead from a position that is still not always appreciated (“agile teams don’t need testers”, “testers are just bad developers”, “you’re just a tester”…).

In complex situations where we’re dealing with unknown unknowns plus sticky, messy humans, communication is key. A degree in psychology would sometimes be helpful. Multiple years of cat-herding too. In this workshop, Alex will focus on communication.

The workshop will consist of the following topics:

- Communicating the value and role of testing

- Testers as the communication glue for various stakeholders and within the team: talking about  testing, risk and quality at the right level for the right audience

- Enablement: Teaching, coaching, coercing and encouraging others within the team to take on quality- related tasks and to support the value of the product through testing

- What testers and other team members can do together, resulting in better and more efficient results

The workshop will focus on hands-on exercises and activities. No programming skills are necessary, but we will be doing some work involving code in groups and in a safe learning environment.

Big Data und Machine Learning sind aktuelle Konzepte und Technologien, die neue Anwendungsmöglichkeiten für IT in Unternehmen schaffen. Eine Einarbeitung ist normalerweise mit erheblichem Aufwand verbunden. In diesem eintägigen Workshop lernen Sie, wie Sie schnell und auf einfache Weise Aufgabenstellungen im Bereich Big Data und Machine Learning mithilfe der freien, offenen grafischen Umgebung "KNIME" selbst bearbeiten können. Sie bearbeiten hierbei in einem Scrum-Team eigenständig jeweils Fallstudien aus dem Bereich Big Data und Machine Learning zur Verarbeitung von OpenData aus dem Bereich Car-Sharing (Flinkster).

1. Analysieren Sie die Fahrzeugdaten (Big Data)

2. Analysieren Sie die Stationen, Buchungen und Buchungsdaten (Big Data)

3. Trainieren Sie ein ML-System mit Fahrzeugdaten und lassen Sie es Fahrzeugdaten voraussagen (Machine Learning)

Maximale Teilnehmerzahl: 20

Für die Bearbeitung der Aufgaben wird ein weiterer Rechner benötigt.

Zielpublikum: Entwickler:innen, (Unternehmens-)Architekten:innen, IT-Management/IT-affine Mitarbeitende
Voraussetzungen: Grundkenntnisse Programmierung, Big Data, Machine Learning
Schwierigkeitsgrad: Anfänger

Extended Abstract:
Big Data und Machine Learning sind aktuelle Konzepte und Technologien, die neue Anwendungsmöglichkeiten für IT in Unternehmen schaffen. Eine Einarbeitung ist normalerweise mit erheblichem Aufwand verbunden. In diesem eintägigen Workshop lernen Sie, wie Sie schnell und auf einfache Weise Aufgabenstellungen im Bereich Big Data und Machine Learning mithilfe der freien, offenen grafischen Umgebung "KNIME" selbst bearbeiten können. Sie bearbeiten hierbei in einem Scrum-Team eigenständig jeweils Fallstudien aus dem Bereich Big Data und Machine Learning zur Verarbeitung von OpenData aus dem Bereich Car-Sharing (Flinkster).

1. Aufgabe: Analysieren Sie die Fahrzeugdaten (Big Data)

2. Aufgabe: Analysieren Sie die Stationen, Buchungen und Buchungsdaten (Big Data)

3. Aufgabe: Trainieren Sie ein Machine-Learning-System mit den Fahrzeugdaten und lassen Sie von diesem System Informationen wie den Treibstofftyp und den Fahrzeugtyp von Fahrzeugen aus sonstigen Fahrzeugdaten voraussagen (Machine-Learning)

Produkte entstehen aus innovativen Ideen. Durch gutes Innovationsmanagement können Sie Kreativität gezielt fördern, um kundenorientierte Lösungen zu entwickeln. In diesem Workshop durchlaufen wir anhand einer Simulation den gesamten Innovationsmanagementprozess von der Ideenentwicklung bis zum Bau eines ersten Prototyps. Wir geben Ihnen für jeden Prozessschritt die passende Methode (z.B. aus dem Design Thinking) und entsprechende Kreativitätstechniken an die Hand, sodass Sie das vermittelte Wissen in Ihrem Berufsalltag anwenden können.

Maximale Teilnehmerzahl: 25

Zielpublikum: Management, Projektleiter:innen, Entscheider:innen, alle, die erfahren wollen, wie Innovation mit kleinem Budget geht
Voraussetzungen: Interesse an Innovation, unterschiedlichen Methoden und dem Wunsch, einen Schritt weiter zu kommen
Schwierigkeitsgrad: Anfänger

In unserem Workshop werden wir:

* Die notwendigen Grundlagen erklären

* Ein kleines Aggregate mittels Event-Sourcing von Grund auf implementieren

* Es wird dabei vorwiegend "test-driven" (TDD) gearbeitet

Voraussetzungen:

* Grundverständnis taktischer DDD Patterns: Value Object, Event, Command, Entity/Aggregate

* Laptop mit IDE und Unit-Test-Framework

* Pair-Programming ist erwünscht

* Der Workshop ist unabhängig von Programmiersprachen

Maximale Teilnehmerzahl: 16

Zielpublikum: Architekt:innen, Entwickler:innen
Voraussetzungen: Grundverständnis taktischer Patterns aus DDD: Value Object, Event, Command, Entity und Aggregate
Schwierigkeitsgrad: Fortgeschritten

Extended Abstract:
Event-Sourcing erhält in letzter Zeit viel Aufmerksamkeit, obwohl es beileibe kein neues Architekturpattern ist. Der grundlegende Ansatz, die Änderungen anstatt des aktuellen Zustandes zu speichern, wird seit geraumer Zeit z.B. in der Buchhaltung verwendet. Im Computerzeitalter kommt es unter anderem in den "binlogs" von Datenbanken oder bei GIT zum Einsatz.

Zu den Vorteilen dieses Patterns im Vergleich zu klassischen "Stateful Models" zählen unter anderem:

* leichtere Änderbarkeit des "Code-Models" ohne Datenbankmigration

* Experimente mit alternativen Models

* ein simples Datenbankmodell, das ohne ORM auskommt

* neue Möglichkeiten des Debuggings

* Models mit zeitbasiertem Verhalten

* Auditing

In unserem Workshop werden wir:

* Die Grundlagen von CQRS erklären, da Event-Sourcing ohne CQRS kaum möglich ist

* Erklären, was ein "Aggregate" eigentlich ist

* Ein kleines Aggregate mittels Event-Sourcing von Grund auf implementieren, inklusive einiger "Events", "Commands" und "Value Objects"

* Unsere Grundlage dafür wird das Ergebnis einer (fiktiven) "Event Storming" Session sein

* Wir werden dabei "test-driven" (TDD) arbeiten, um nur zu implementieren, was auch wirklich benötigt wird

Voraussetzungen:

* Die Teilnehmenden des Workshops sollten ein Grundverständnis taktischer Patterns aus Domain-driven Design mitbringen: Value Object, Event, Command, Entitiy und Aggregate

* Der Workshop ist grundsätzlich unabhängig von Programmiersprachen

* Die Coaches können: Golang, Java, C# und PHP und haben ein Grundverständnis funktionaler Programmierung

* Die Teilnehmenden sollten einen Laptop mit ihrer liebsten IDE und einem installierten Unit-Test-Framework mitbringen

* Pair-Programming mit anderen Teilnehmenden ist selbstverständlich auch möglich