RÜCKBLICK AUF DAS PROGRAMM 2021

Thema: Microservices

Nach Tracks filtern
Nach Themen filtern
Alle ausklappen
  • Montag
    08.02.
  • Dienstag
    09.02.
  • Mittwoch
    10.02.
  • Donnerstag
    11.02.
  • Freitag
    12.02.
, (Montag, 08.Februar 2021)
14:00 - 17:00
Mo 12
Really Simple Reactive Architecture and Programming
Really Simple Reactive Architecture and Programming

Applications, services, and systems are changing out of necessity because of the kinds of platforms that are available today: distributed and multi-core. Have you been curious about Reactive Architecture and Programming but haven't had time to dig in? Join this session.

Maximum number of participants: 75

Target Audience: Architects and Developers
Prerequisites: Java Programming
Level: Advanced

Extended Abstract:
Applications, services, and systems are changing out of necessity because of the kinds of platforms that are available today: distributed and multi-core. Have you been curious about Reactive Architecture and Programming but haven't had time to dig in? Join this session and you will be in a good position to put Reactive to use on your projects. We will start from foundational building blocks and scale up to full Reactive implementations. If you bring your laptop and Java 1.8+ or C# for .NET Core 2.1+ you can try out Reactive during the session.

Vaughn Vernon is an entrepreneur, software developer, and architect with more than 35 years of experience in a broad range of business domains. Vaughn is a leading expert in Domain-Driven Design and Reactive, and champions simplicity. He consults and teaches around Domain-Driven Design and Reactive software development, helping teams and organizations realize the potential of business-driven and reactive systems as they transform from technology-driven legacy web implementation approaches. Vaughn is the author of three best-selling books published by Pearson/Addison-Wesley, and has been commissioned by them as the curator and editor of his own Vaughn Vernon Signature Series.
Vaughn Vernon
Vaughn Vernon
flag VORTRAG MERKEN

Vortrag Teilen

18:30 - 20:00
Nmo 5
Strangle Your Legacy Code
Strangle Your Legacy Code

Given an ancient codebase that makes refactoring risky and expensive, how do you clear a path to continued delivery? The old wisdom says the best time to plant a tree was 20 years ago. The next best time to preserve your software investment is today: plant a Strangler, a pattern for reaping continuous value from your existing system while growing new functionality alongside it.

We'll test-drive new features into a real legacy system. You'll leave with a powerful strategy for extending the useful life of valuable software.

Target Audience: Architects, Developers, Testers, Product Managers
Prerequisites: Familiarity with refactoring and legacy code; preference for learning-by-doing
Level: Advanced

Extended Abstract:
Given an ancient codebase that makes refactoring risky and expensive, how do you clear a path to continued delivery? The old wisdom says the best time to plant a tree was 20 years ago, and the next best time is today. But if you already have a gnarled old source tree, preserve your software investment by planting a Strangler: a pattern for reaping continuous value from your existing system while growing new functionality alongside it.

We'll take a quick look at a Strangler and the basics of Mob Programming, then work together to test-drive new features into the system. You'll leave with a powerful strategy for extending the useful life of working, valuable software -- especially when it's hard to change -- and with a free bonus development practice to accelerate your team's learning. For a limited time only!

Amitai Schleier is an independent software development coach, legacy code wrestler, non-award-winning musician, and award-winning bad poet. He publishes fixed-length micropodcasts at Agile in 3 Minutes, writes variable-length articles at schmonz.com, and contributes to notable open-source projects such as NetBSD, pkgsrc, ikiwiki, and qmail. Amitai’s music and puns have been tolerated at the International Rachmaninoff Conference and the Alfred Joyce Kilmer Memorial Bad Poetry Contest.
Amitai Schleier
Amitai Schleier
Vortrag: Nmo 5
Themen: Microservices
flag VORTRAG MERKEN

Vortrag Teilen

, (Dienstag, 09.Februar 2021)
14:00 - 14:45
Di 5.2
Domain-Driven Design für Monolithen und Microservices
Domain-Driven Design für Monolithen und Microservices

Software ist in nahezu allen Bereichen unseres Lebens unverzichtbar. Neben der Forderung, dass die Software fachlich tut, was sie soll, ist wichtig, dass unsere Softwaresysteme langfristig wartbar und erweiterbar bleiben.

In diesem Talk bekommen Zuhörende Anleitungen, Erkenntnisse, Hinweise und viele Beispiele aus der Praxis, wie die Techniken aus Domain-Driven Design für Softwaresysteme verwendet werden können, die über Jahre gewachsen und möglicherweise ohne Architekturverständnis entwickelt wurden.

Zielpublikum: Architekt:innen, Entwickler:innen, Projektleiter:innen, Manager:innen, Entscheider:innen
Voraussetzungen: Projekterfahrung, Architekturerfahrung
Schwierigkeitsgrad: Fortgeschritten

Dr. Carola Lilienthal ist Geschäftsführerin bei der WPS Workplace Solutions GmbH. Sie hat an der Universität Hamburg studiert und dort zum Thema "Komplexität von Software-Architekturen" promoviert. Seit 2003 analysiert sie im Auftrag ihrer Kunden in ganz Deutschland regelmäßig die Zukunftsfähigkeit von Software-Architekturen und spricht auf Konferenzen über dieses Thema.
Carola Lilienthal
Carola Lilienthal
flag VORTRAG MERKEN

Vortrag Teilen

16:15 - 17:15
Di 1.3
Fundamental IDEALS for Modeling Microservices
Fundamental IDEALS for Modeling Microservices

SOLID principles are well-known for designing object-oriented systems. But what if you are developing microservices? IDEALS, is yet another silly mnemonic acronym and are the core principles for microservice design. The acronym stands for: Interface segregation, Deployability, Event-driven, Availability over consistency, Low Coupling, and Single responsibility. We will relate these IDEALS to techniques, tools, technologies, and domain modeling principles we use today to develop modern service-based distributed systems (microservices).

Target Audience: English, Developers, Architects, QAs, Testers, Product Owners, Managers
Prerequisites: Basic Understanding of architecture and microservices and familiarity with domain modeling
Level: Advanced

Extended Abstract:

It's been seven years since we've started creating microservices. Practice has shown what design principles give you a sound foundation for a successful microservice architecture. Join us in this session to find out what they are, and how to realize them. For OO systems, Robert Martin compiled the five SOLID principles. For designing microservice-based solutions, we propose developers follow the "IDEALS":  

(I) Interface segregation tells us that different types of clients (e.g., mobile apps, web apps, CLI programs) should be able to interact with services through the contract that best suits their needs. 

(D) Deployability (is on you) acknowledges that in the microservice era, which is also the DevOps era, there are critical design decisions and technology choices developers need to make regarding packaging, deploying and running microservices. 

(E) Event-driven suggests that whenever possible we should model our services to be activated by an asynchronous message or event instead of a synchronous call. 

(A) Availability over consistency reminds us that more often end users value the availability of the system over strong data consistency, and they're okay with eventual consistency. 

(L) Loose-coupling remains an important design concern in the case of microservices, with respect to afferent (incoming) and efferent (outgoing) coupling. 

(S) Single responsibility is the idea that enables modeling microservices that are not too large or too slim because they contain the right amount of cohesive functionality. 

We will relate these IDEALS to techniques, tools, technologies and domain modeling principles we use today to develop modern service-based distributed systems (microservices).

Paulo Merson has been programming in the small and programming in the large for over 25 years. Paulo is a software developer at the Brazilian Federal Court of Accounts. He is a Visiting Scientist with the Software Engineering Institute (SEI) and is also a certified instructor for SOASchool and a faculty member of the master program in Applied Computing at University of Brasilia. Paulo often delivers professional training to software developers in the US, Latin America, and Europe.
Joseph (Joe) Yoder is president of the Hillside Group and principle of The Refactory. He is best known as an author of the Big Ball of Mud pattern, illuminating fallacies in software architecture. Joe teaches and mentors developers on agile and lean practices, architecture, flexible systems, clean design, patterns, refactoring, and testing. Joe has presented many tutorials and talks, arranged workshops, given keynotes, and help organized leading international agile and technical conferences.
Paulo Merson, Joseph Yoder
Paulo Merson, Joseph Yoder
flag VORTRAG MERKEN

Vortrag Teilen

16:15 - 17:15
Di 3.3
Decoupled Streaming Microservices Architecture with Apache Kafka, Kubernetes and Istio Service Mesh
Decoupled Streaming Microservices Architecture with Apache Kafka, Kubernetes and Istio Service Mesh

Apache Kafka became the de facto standard for microservice architectures. Decoupled applications and Domain-driven Design (DDD) are key benefits. However, that also introduces new challenges like observability of the whole ecosystem. This session explores the problems of distributed Microservices communication and how Kafka, Kubernetes and a Service Mesh like Istio address them. Learn some approaches for combining them to build a reliable and scalable microservice architecture with decoupled and secure microservices.

Target Audience: Software Architects, Consultants, Developers, Project Leads
Prerequisites: Experience with distributed systems / messaging frameworks is helpful
Level: Advanced

Extended Abstract:
Apache Kafka became the de facto standard for microservice architectures. It goes far beyond reliable and scalable high-volume messaging. In addition, you can leverage Kafka Connect for integration and the Kafka Streams API for building lightweight stream processing microservices in autonomous teams. Decoupled applications and Domain-driven Design (DDD) are key benefits. However, microservices also introduce new challenges like observability of the whole ecosystem.

A Service Mesh technology like Istio (including Envoy) complements the architecture. It describes the network of microservices that make up such applications and the interactions between them. Its requirements can include discovery, load balancing, failure recovery, metrics, and monitoring. A service mesh also often has more complex operational requirements, like A/B testing, canary rollouts, rate limiting, access control, and end-to-end authentication.

This session explores the problems of distributed Microservices communication and how both Apache Kafka and Service Mesh solutions address it together on top of Kubernetes. I cover different approaches for combining both to build a reliable and scalable microservice architecture with decoupled and secure microservices.

Kai Waehner is a Technology Evangelist at Confluent. He works with customers across the globe and with internal teams like engineering and marketing. Kai’s main area of expertise lies within the fields of Big Data Analytics, Machine Learning, Hybrid Cloud Architectures, Event Stream Processing and Internet of Things. 
Kai Wähner
Kai Wähner
flag VORTRAG MERKEN

Vortrag Teilen

, (Mittwoch, 10.Februar 2021)
09:00 - 10:30
Mi 9.1
Microservice Deployments mit Kubernetes Operatoren
Microservice Deployments mit Kubernetes Operatoren

Microservices kommen als Architektur-Idee gut an, Kubernetes etabliert sich als ihre Laufzeitumgebung - plus seiner Komplexität.

Praktisch ist jedoch, dass es auch mit eigenen Operatoren erweitert werden kann. Sie können im Test und Deployment der Services mit all ihren definierten Abhängigkeiten und deren Konfigurationen durch Automatisierung helfen. Dies rundet Microservices ab und erleichtert das Leben.

Lassen Sie sich in die Idee und die Entwicklung von Operatoren einführen.

Zielpublikum: Entwickler:innen, DevOps
Voraussetzungen: Basiskenntnisse in Go und Kubernetes
Schwierigkeitsgrad: Anfänger

Extended Abstract:
Das Ausrollen von Microservices in einem Kubernetes-Cluster kann ein recht manueller Prozess sein, welcher sich mit externen Tools automatisieren lässt. Doch dies lässt von Service zu Service noch viel Freiraum zu, insbesondere in Bezug auf Abhängigkeiten wie Datenbanken, Message Queue und weiteren Tools.

Kubernetes Operatoren erlauben die Verlagerung der Automatisierung von außen nach innen. Die durch die Services zu nutzenden Tools und ihre Standardkonfigurationen lassen sich so zum Beispiel vordefinieren, sodass für das Rollout eines neuen Service nur mehr eine relativ begrenzte Konfiguration notwendig ist. Ebenso können Tests automatisch angestoßen werden. Die Einsatzzwecke sind vielfältig.

Die Session führt in die Idee der Operatoren ein, zeigt die Client-Bibliothek ebenso wie den Kubebuilder und nimmt dann in die Entwicklung eines Microservice Operators mit.

Frank Müller, Solution Engineer und Consultant bei Kubermatic, bewegt sich seit über dreißig Jahren in der Welt der Software. So unterschiedlich wie die Projekte waren auch die eingesetzten Sprachen und abgedeckten Rollen. Ab 1999 kamen Fachartikel, Talks sowie ein Buch über Go hinzu. Frank verfolgt die Entwicklung dieser Sprache seit ihrer Ankündigung 2009 und setzt sie seit nun bald 10 Jahren hauptberuflich im Umfeld verschiedener offener und geschlossener Projekte rund um Microservices, Cloud-Systeme und Kubernetes ein.
Frank Müller
Frank Müller
Vortrag: Mi 9.1
flag VORTRAG MERKEN

Vortrag Teilen

11:00 - 11:45
Mi 7.2
Evolving Monoliths to Microservices
Evolving Monoliths to Microservices

This talk will examine principles that assist with successfully evolving from a monolith to Microservices. Deciding what to decouple along with when and how to incrementally evolve a system are the main architectural challenges in this process. It is important to commit to "stop adding to the monolith" - all new code is added as microservices; the "Strangler Pattern". The new features are microservices, occasionally replacing part of the monolith. Also, when writing new microservices code, it is important to avoid dependencies to the monolith.

Target Audience: English, Developers, Architects, QAs, Testers
Prerequisites: Basic Understanding of architecture and microservices and familiarity with domain modeling
Level: Advanced

Extended Abstract:
Being Agile, with its attention to extensive testing, frequent integration, and focusing on important product features, has proven invaluable to many software teams. When building complex systems, focus on features provides a lot of value and starting with a monolith architecture can be advantageous. However, over time, although you might be committed to keeping the code clean, and having lots of tests — the architecture can become harder to evolve. Ultimately technical debt and design problems will creep in until it becomes muddy, making it hard to deliver new features quickly and reliably. Also, evolving the system quickly can become harder. If things are changing quickly with lots of teams, evolving using the microservices architectural style can have many possible benefits.

Many Microservices architectures start from the evolution of a Monolith system by gradually applying the microservices architectural style. There are considerations and principles that assist with successfully evolving from a monolith to Microservices. Deciding what to decouple along with when and how to incrementally evolve a system are the main architectural challenges in this process. There are good principles that help with this evolutionary process. For example, it is important to commit to "stop adding to the monolith" - all new code is added as microservices. This is the core of the "Strangler Pattern". The new features are microservices, occasionally replacing part of the monolith. Also, there might be important pieces of the monolith that are getting hard to maintain and you want to pull these out. When this happens, you find design seams within the monolith, refactoring these out to components, that can ultimately be replaced with microservices. Early on, it is ok to create macro services first and then evolve (refactor) them to microservices. Also, when writing new microservices code, it is important to avoid dependencies to the monolith. Finally, you can use DDD modeling to identify aggregates and bounded contexts to pull them out from the monolith. This talk will examine various patterns when evolving from the monolith to microservices specifically with variations of the Strangler Pattern.

Joseph (Joe) Yoder is president of the Hillside Group and principle of The Refactory. He is best known as an author of the Big Ball of Mud pattern, illuminating fallacies in software architecture. Joe teaches and mentors developers on agile and lean practices, architecture, flexible systems, clean design, patterns, refactoring, and testing. Joe has presented many tutorials and talks, arranged workshops, given keynotes, and help organized leading international agile and technical conferences.
Joseph Yoder
Joseph Yoder
flag VORTRAG MERKEN

Vortrag Teilen

11:00 - 11:45
Mi 8.2
Test Automation in the age of digital banking Darwinism
Test Automation in the age of digital banking Darwinism

Raiffeisen Bank International (RBI) started in 2017 with “Group Digital Solutions” a journey in order not to oversleep the digitization of the banking industry.

Due to new approaches such as DevSecOps & Continuous Testing, the topic of software tests, whether manual or automated, had to be completely redesigned and implemented.

This talk gives insights into the test strategy & the fullstack test automation architecture that were used.

Target audience: testers, developers, architects, managers
Prerequisites: none
Level: Advanced

Extended Abstract:
So that Raiffeisen Bank International can keep up with digitization in the banking sector, the company relies on the use of native apps, microservices and REST APIs in the Amazon cloud when implementing its mobile banking strategy. 

In order to support the DevOps mantra "Automate everything", a full stack test automation strategy was developed that is based on open source tools and takes all components of the system architecture into account.

The independent services of the microservice architecture make additional interfaces visible that are not available in a monolithic architecture. The advantage is that they can be deployed and tested independently of each other.

Testing these systems is much more complex than testing a conventional monolithic application and needs additional demands on test automation, with classic integration tests being even more important for the overall structure. 

These integration tests were usefully supplemented by consumer contract tests. But end-2-end tests should not be missing either, since an effective test strategy must take into account both the isolated testing of individual services and the verification of the overall system behavior.

Aligning test automation with the classic test pyramid is a very useful approach if the individual layers are seen as the basis for “what is being tested” and not as a measure of the number of tests. Because the old wisdom still counts: “Quality over quantity!”.

Rudolf Grötz has been in IT for 30 years and has been a passionate software tester since 2008. He works as an agile engineering coach for the topic & test automation at Raiffeisen Bank International in Vienna and lives the motto "Test automation is not an act, test automation is a habit!". In addition to various author activities, including for IX-Magazin, he organizes the Agile (Test) Automation Meetup in Vienna and the TestBustersNight Vienna 6 times a year. ------------------ Rudolf Grötz ist seit 30 Jahren in der IT unterwegs und seit 2008 passionierter Softwaretester. Er ist als Agile Engineering Coach für das Thema & Test Automation bei der Raiffeisen Bank International in Wien tätig und lebt den Leitspruch „Testautomation is not an act, Testautomation is a habit!“. Neben diverser Autorentätigkeiten, u.a. für das IX-Magazin, organisiert er in Wien das Agile (Test) Automation Meetup und 6x pro Jahr die TestBustersNight Vienna.
Matthias Zax works as an agile engineering coach at Raiffeisen Bank International AG (RBI). Actually a trained software developer, he has been testing software with a focus on test automation in the DevOps environment since 2018 and organizes the RBI Test Automation Community of Practice. ------------------ Matthias Zax arbeitet als Agile Engineering Coach bei Raiffeisen Bank International AG (RBI). Eigentlich gelernter Software Developer, beschäftigt er sich seit 2018 mit dem Testen von Software mit Schwerpunkt Testautomation im DevOps-Umfeld und organisiert die RBI Testautomation Community of Practice.
Rudolf Grötz, Matthias Zax
Rudolf Grötz, Matthias Zax
Vortrag: Mi 8.2
flag VORTRAG MERKEN

Vortrag Teilen

15:45 - 16:30
KeyMi2
KEYNOTE: Software Architecture: The Past, The Present, and the Future
KEYNOTE: Software Architecture: The Past, The Present, and the Future

Over the history of software systems, the way we build such artifacts, the way we design them, the way we express them have evolved in seemingly disruptive ways. Even today, the pendulum swings between low ceremony agile methods to more rigid waterfall-ish ones; from big balls of mud to microservices and then back to big balls of microservices. In this talk, we'll examine the past, the present, and the future of software architecture: the role it plays in software systems, and the timeless fundamentals that remain across the fullness of time.

Grady Booch is Chief Scientist for Software Engineering at IBM Research where he leads IBM’s research and development for embodied cognition. Having originated the term and the practice of object-oriented design, he is best known for his work in advancing the fields of software engineering and software architecture. A co-author of the Unified Modeling Language (UML), a founding member of the Agile Alliance, and a founding member of the Hillside Group, Grady has published six books and several hundred technical articles, including an ongoing column for IEEE Software. Grady was also a trustee for the Computer History Museum. He is an IBM Fellow, an ACM and IEEE Fellow, has been awarded the Lovelace Medal and has given the Turing Lecture for the BCS, and was recently named an IEEE Computer Pioneer. He is currently developing a major trans-media documentary for public broadcast on the intersection of computing and the human experience.
Grady Booch
Grady Booch
Track: Keynote
Vortrag: KeyMi2
flag VORTRAG MERKEN

Vortrag Teilen

17:00 - 18:00
Mi 1.4
Die Matrix: Enterprise-Architekturen jenseits von Microservices
Die Matrix: Enterprise-Architekturen jenseits von Microservices

Man gewinnt den Eindruck, Microservices seien die Universallösung für all unsere (Architektur-)Probleme. Dabei sind Microservices lediglich Mittel zum Zweck. Was also, wenn meine Probleme nicht zur Lösung „Microservices“ passen? Ist es nach wir vor legitim, einen Monolithen zu bauen? Oder gibt es andere Architekturansätze, mit denen sich Monolithen aufbrechen lassen? In der Session werfen wir einen kritischen Blick auf Microservices und beleuchten – immer ausgehend von bestehenden Problemfeldern – eine Reihe alternativer Architekturen.

Zielpublikum: Architekt:innen, Entwickler:innen, Projektleiter:innen, Management, Entscheider:innen
Voraussetzungen: Projekterfahrung, Enterprise Computing
Schwierigkeitsgrad: Anfänger

Extended Abstract:
Getreu dem Motto "choose Microservices for the benefits and not because your codebase is a mess."
(Zitat: Simon Brown), beleuchtet die Session typische Problemstellungen aus großen Projekten und zeigt auf, für welche dieser Microservices eine Lösung darstellen und für welche eher nicht. Anhand verschiedener Real-Life-Anforderungen, werden alternative Architekturen als Lösungsansätze gezeigt und bewertet.

Lars Röwekamp, Gründer des IT-Beratungs- und Entwicklungsunternehmens OPEN KNOWLEDGE GmbH, beschäftigt sich im Rahmen seiner Tätigkeit als 'CIO New Technologies' mit der eingehenden Analyse und Bewertung neuer Software- und Technologietrends. Ein besonderer Schwerpunkt seiner Arbeit liegt derzeit in den Bereichen Enterprise und Cloud Computing, wobei neben Design- und Architekturfragen insbesondere die Real-Life-Aspekte im Fokus seiner Betrachtung stehen.
Lars Röwekamp
Lars Röwekamp
Vortrag: Mi 1.4
flag VORTRAG MERKEN

Vortrag Teilen

17:00 - 18:00
Mi 3.4
Application Integration Patterns (not only) for Microservices
Application Integration Patterns (not only) for Microservices

Eine wesentliche Auswirkung beim Einsatz einer Microservice-Architektur ist, dass ein großer Teil der Kommunikation zwischen den einzelnen Komponenten über das Netzwerk erfolgt. Um die Vorteile dieses Architekturstils auch wirklich nutzen zu können, dürfen die einzelnen Microservices lose miteinander gekoppelt sein. In dieser Session lernen Sie die grundlegenden Integrations-Muster kennen, und sehen anhand eines konkreten Szenarios, wie Sie diese Patterns zu einer funktionierenden Anwendung verknüpfen können.

Zielpublikum: Architects, Developers
Voraussetzungen: Basic architectural knowledge
Schwierigkeitsgrad: Fortgeschritten

Dennis Traub ist Developer Advocate bei Amazon Web Services (AWS). Er arbeitet seit über 25 Jahren in der Web- und Software-Entwicklung, u.a. bei ThoughtWorks, codecentric und zuletzt als Global Solutions Architect bei AWS. Heute teilt er seine Erfahrung mit Entwickler:innen, Architekt:innen und Systemadministrator:innen und zeigt ihnen, wie sie sichere und hochverfügbare Anwendungen in der Cloud entwickeln und betreiben können.
Dennis Traub
Dennis Traub
Vortrag: Mi 3.4
flag VORTRAG MERKEN

Vortrag Teilen

18:30 - 20:00
Nmi 1
Mono-, Modu-, Microliths - oder welche Steine nutze ich zum Bauen
Mono-, Modu-, Microliths - oder welche Steine nutze ich zum Bauen

Seit dem Artikel von M. Fowler und J. Lewis in 2012 sind Microservices die Antwort auf alle Fragen. Sie schienen die Antwort auf die steigende Komplexität von Softwareprojekten und Cloudanwendungen zu sein. Aber da sind Ausnahmen, die unterschiedlich beantwortet werden müssen. The Vortrag diskutiert Vorteile und Nachteile von Microservices, Modulithen und Monolithen unter Benutzung von realen Beispielen. Als Ergebnis werden Checklisten vorgestellt, die die Entscheidungen in einem solchen komplexen Umfeld einfacher machen.

Zielpublikum: Architekt:innen, Entwickler:innen, Entscheider:innen
Voraussetzungen: Prinzipielles Verständnis von Software-Architektur
Schwierigkeitsgrad: Fortgeschritten

Extended Abstract:
Microservices als ein einfacher Service ist einfach zu verstehen. Aber eine ganze Sammlung von ihnen ist schwierig zu verstehen. Ein Monolith als solcher ist einfach zu verstehen, aber all die komplexe Geschäftslogik innerhalb ist schwierig zu verstehen.

Wo ist die Linie zwischen beiden – was kann verstanden werden und wann wird es zu kompliziert? Der Vortrag diskutiert diese Fragen und gibt zumindest einige Antworten.

Dr. Annegret Junker ist Lead Architect bei Allianz Deutschland AG. Dr. Junker arbeitet seit mehr als 25 Jahren in der Software-Entwicklung in unterschiedlichen Rollen und unterschiedlichen Domänen wie Automotive, Versicherungen und Finanzdienstleistungen. Besonders interessiert sie sich für DDD, Microservices und alles was damit zusammenhängt. Derzeit arbeitet sie in einem großen Versicherungs-Projekt als übergreifende Architektin.
Annegret Junker
Annegret Junker
Vortrag: Nmi 1



flag VORTRAG MERKEN

Vortrag Teilen

, (Donnerstag, 11.Februar 2021)
14:30 - 15:30
Do 9.3
Deployment Patterns for Confidence: Quality Delivery Pipeline
Deployment Patterns for Confidence: Quality Delivery Pipeline

DevOps as a software engineering practice unifies software development (Dev) and software operation (Ops). To assist with quality delivery in with DevOps you need to provide a “Quality Delivery Pipeline” to assure the delivery meets the requirements and proper validation and checks are done before releasing into full production. This talk will focus on the “Quality Delivery Pipeline” as a practice that can help sustain delivering with confidence by addressing important qualities in the pipeline.

Target Audience:
English, Developers, Architects, QAs, Testers, Product Owners
Prerequisites: Basic Understanding of architecture and microservices and familiarity with DevOps
Level: Advanced

Extended Abstract:
Many software development processes such as Agile and Lean focus on the delivery of working software that meets the needs of the end-users. Many of these development processes help teams respond to unpredictability through incremental, iterative work cadences, and through empirical feedback. There is a commitment to quickly deliver reliable working software that has the highest value to those using or benefiting from the software. DevOps has become a common practice to assist with quality delivery in these practices, specifically when developing using the microservices architectural style. DevOps as a software engineering practice unifies software development (Dev) and software operation (Ops). To assist with quality delivery in these practices you need to provide a “Quality Delivery Pipeline” to help assure the delivery meets the requirements and proper validation and checks are done before releasing into full production. At the end of the pipeline the validated system will be deployed into production. There are various deployment techniques to help successfully and reliably deploy more quickly. The goal is to give confidence by providing "reliable, working software" to the user (making the user confident in the system). Also, the teams will have more confidence the system is working. This talk will focus on the “Quality Delivery Pipeline” as a practice that can help sustain delivering with confidence by addressing important qualities in the pipeline.

Joseph (Joe) Yoder is president of the Hillside Group and principle of The Refactory. He is best known as an author of the Big Ball of Mud pattern, illuminating fallacies in software architecture. Joe teaches and mentors developers on agile and lean practices, architecture, flexible systems, clean design, patterns, refactoring, and testing. Joe has presented many tutorials and talks, arranged workshops, given keynotes, and help organized leading international agile and technical conferences.
Ademar Aguiar is a Professor at Faculty of Engineering of University of Porto (FEUP) and researcher at INESC Porto, with over more than 20 years of experience on software development, software architecture and design (patterns, frameworks, infrastructures), agile methods, wikis, and open collaboration tools.
Joseph Yoder, Ademar Aguiar
Joseph Yoder, Ademar Aguiar
flag VORTRAG MERKEN

Vortrag Teilen

, (Freitag, 12.Februar 2021)
09:00 - 16:00
Fr 3
(AUSGEBUCHT) Designing Bounded Contexts for Microservices Using Visual Collaboration
(AUSGEBUCHT) Designing Bounded Contexts for Microservices Using Visual Collaboration

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.

João Rosa believes that empowered teams working in a network-based system are the future of organisations. He uses Domain-Driven Design, Visual Collaboration Tools and Teal organisation principles to help companies to move to new operating models.
Leveraging Deep Democracy, Domain-Driven Design, Continuous Delivery and visual collaborate tools, Kenny Baas-Schwegler empowers organisations, teams and people in building valuable software products.
João Rosa, Kenny Baas-Schwegler
João Rosa, Kenny Baas-Schwegler
flag VORTRAG MERKEN

Vortrag Teilen

Zurück