CONFERENCE PROGRAM OF 2021

Please note:
On this site, there is only displayed the English speaking sessions of the OOP 2021 Digital. You can find all conference sessions, including the German speaking ones, here.

Theme: Microservices

Sort by Tracks
Sort by Themes
Alle ausklappen
  • Monday
    08.02.
  • Tuesday
    09.02.
  • Wednesday
    10.02.
  • Thursday
    11.02.
  • Friday
    12.02.
, (Monday, 08.February 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 EVENT 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
Talk: Nmo 5
Themen: Microservices
flag EVENT MERKEN

Vortrag Teilen

, (Tuesday, 09.February 2021)
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 EVENT 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 EVENT MERKEN

Vortrag Teilen

, (Wednesday, 10.February 2021)
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 EVENT 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
flag EVENT 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
Talk: KeyMi2
flag EVENT MERKEN

Vortrag Teilen

, (Thursday, 11.February 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 EVENT MERKEN

Vortrag Teilen

, (Friday, 12.February 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 EVENT MERKEN

Vortrag Teilen

back