Track: Back to Basics of Design, Architecture, and Programming
- Dienstag
04.02. - Mittwoch
05.02.
How to structure your program right? This has been a central question since the beginning of software development. This talk takes a look into the history of software architecture to understand why we are building software the way we are. We start with foundations like information hiding, modularity, separation of concerns, loose coupling. We move on to principles like layering and design patterns. We conclude with an outlook to modern ideas like hexagonal architecture, onion architecture, SOLID, and the software architecture hamburger.
Target Audience: Developers and architects
Prerequisites: Programming
Level: Advanced
Henning liebt Programmieren in hoher Qualität. Diese Leidenschaft lebt er als Coder, Coach und Consultant bei der WPS – Workplace Solutions aus. Dort hilft er Teams dabei, gewachsene Monolithen zu strukturieren oder neue Systeme von Anfang an mit einer tragfähigen Architektur zu errichten. Häufig kommen dann Microservices oder Self-Contained Systems heraus. Henning ist Autor von "Domain Storytelling" (Addison-Wesley, 2022) und dem www.LeasingNinja.io sowie Übersetzer von "Domain-Driven Design kompakt" (dpunkt, 2017).
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/experten/henning-schwentner/
Die Entwicklung typischer aktueller Webanwendungen kann einen erschlagen: Umfangreiche, komplexe JavaScript-Frameworks, Client-Side-Rendering/Server-Side-Rendering, (De-)Hydration, komplizierte Buildprozesse und und und
Die unterliegenden Technologien, Protokolle und Architekturmuster wie HTTP(2/3), HTML/CSS, Web Components, Representational State Transfer (REST) u. a. geraten dabei manchmal völlig aus dem Blick. Für die Entwicklung von Webanwendungen, die nachhaltig und skalierbar sein sollen, ist die Kenntnis dieser grundlegenden Prinzipien aber unerlässlich. Ansonsten droht die Gefahr, in einer ewigen Spirale dem gerade gehypten Framework, Architektur-/Entwicklungsansatz fürs Web nachzulaufen.
Dieser Vortrag versucht, den Blick wieder auf diese grundlegenden Prinzipien zu richten.
Zielpublikum: Architekt:innen, Entwickler:innen
Voraussetzungen: Grundlegende Erfahrungen mit der Entwicklung und Architektur von Softwaresystemen
Schwierigkeitsgrad: Basic
Christoph Iserlohn ist Senior Consultant bei INNOQ. Er hat langjährige Erfahrung mit der Entwicklung und Architektur von verteilten Systemen. Sein Hauptaugenmerk liegt dabei auf den Themen Skalierbarkeit, Verfügbarkeit und Sicherheit. Er ist Host des INNOQ Security Podcasts.
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/experten/christoph-iserlohn/
Vortrag Teilen
Vortrag Teilen
We make decisions all the time in software – our architectures are the sum of them; both conscious and unconscious.
Yet we have so little awareness about *what* decisions are and *how* we decide. This is not only the source of great friction and waste, it is leading to terrible outcomes for our software.
In this talk I’ll describe what architectural decisions are, and the different ways that we approach them (individually and collectively) making clear the pros and cons of each. I’ll then compare them all, describing the ideal characteristics of a decision-process for modern software development. As a consequence, not only will you be able to decide better as an individual, you will also be able to diagnose failings in your group decision processes and resolve them.
Target Audience: Architects, Lead developers, Product Managers, Project Managers
Prerequisites: Experience delivering a software system
Level: Advanced
Andrew Bruce Harmel-Law is a highly enthusiastic, self-starting and responsible Tech Principal and Author. Andrew specialises in Java / JVM technologies, agile delivery, and architecture with a specific focus on domain-driven design.
Experienced across the software development lifecycle and in many sectors including government, banking, and eCommerce, what motivates him is the production of large-scale software solutions, fulfilling complex client requirements. He understands that people, tooling, architecture and process all have key roles to play in achieving this.
Andrew has a passion for open source software and its communities. He has been interested in and involved with OSS to a greater or lesser extent since his career began; as a user, contributor, expert group member, or paid advocate.
Finally, Andrew enjoys sharing his experience as much as possible. This sharing is not only seen in his formal consulting engagements, but also informally through mentoring, blog posts, conferences (speaking and organising), and open sourcing his code.
Vortrag Teilen
In den letzten Jahren hat das Strategische Design aus DDD einen enormen Zuspruch gewonnen, was auf jeden Fall gut und wichtig ist. Aber das bedeutet nicht, dass wir das Taktische Design von DDD vernachlässigen sollten.
Für diesen Vortrag beginnen wir mit einer starren und fragilen Codebase, wie sie häufig im Laufe der Jahre entsteht. Wir führen Schritt für Schritt Refactorings durch, wobei wir den Supple Design Strategien (supple: englisch für “geschmeidig”) aus DDD sowie anderen bekannten Refactoring-Patterns folgen. Dabei führen wir Value Objects, Entities und weitere Elemente des Taktischen Designs nach und nach ein. Dies erlaubt es uns, die Codebase klar zu strukturieren, so dass Änderungen schnell und leicht möglich sind und das Arbeiten mit dem Code wieder Freude bereitet.
Konkret lernen die Teilnehmer, in welchen Schritten diese Strategien gut anwendbar sind. Die einzelnen Schritte sind einfach und klar verständlich. Sie fordern zum Nachdenken heraus und geben Einblicke, mit denen wir das Domänenmodell im Laufe des Refactorings signifikant verbessern.
Zielpublikum: Architekten, Entwickler
Voraussetzungen: Programmiererfahrung, Erfahrung mit größeren und älteren Codebasen hilfreich
Schwierigkeitsgrad: Advanced
Nicole Rauch ist freiberufliche Softwareentwicklerin und Softwareentwicklungscoach mit umfangreichem Hintergrund in Compilerbau und formalen Verifikationsmethoden. Neben Specification by Example, Domain-Driven Design, React/Redux und der Sanierung von Legacy-Code-Applikationen gehört auch funktionale Programmierung zu ihrem Repertoire. Des Weiteren ist sie Fachbeiratsmitglied bzw. Mitorganisatorin mehrerer Konferenzen sowie einer Fachzeitschrift und Mitbegründerin der Softwerkskammer, einer deutschsprachigen User Community zum Thema Software Craftsmanship.
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/experten/nicole-rauch/
Martin has been consulting and supporting companies in the implementation of their software projects as a software architect and agile coach for many years. He always has the big picture in mind, looking for the boundaries that naturally divide the domain into conceptual units in order to build robust and efficient systems from these parts. Additionally, his profound experience in facilitating workshops helps him to accompany groups in their process of gaining insights and decision-making and to enable all team members to interact in an appreciative and effective manner.
Vortrag Teilen
Schwer zu ändernde Codebasen haben zwei Probleme: fehlende Ausrichtung an Domänengrenzen und fehlender Ausdruck architektonischer Ideen im Code. Entwickler:innen verwenden Separation-of-Concerns-Architekturen wie Onion-, Clean- und Hexagonal-Architektur, um dieses Problem anzugehen. Diese Ansätze erzielen jedoch gemischte Ergebnisse, da sie sich hauptsächlich auf die Trennung von technischem und Business-Code konzentrieren, ohne strukturelle Aspekte der Domäne zu berücksichtigen.
In der Präsentation diskutieren wir Strategien zur Übersetzung von architektonischen Ideen und Designpatterns in Code. Wir erkunden, wie Frameworks und Bibliotheken im Java-Ökosystem die Metainformationen im Code nutzen, um strukturelle Überprüfung, Testbarkeit und Dokumentationsgenerierung zu unterstützen.
Zielpublikum: Softwarearchitekt:innen, Senior Entwickler:innen.
Voraussetzungen: Grundlegende Softwarearchitektur, Basis Java (konzeptionell reicht)
Schwierigkeitsgrad: Expert
Oliver Drotbohm ist Teil des Spring-Engineering-Teams bei Broadcom. Seine Arbeitsschwerpunkte liegen im Bereich Softwarearchitektur, Domain-Driven Design, REST, Spring und Persistenztechnologien. Sein neues Buch „Modulithic Applications with Spring“ erscheint 2024.
Vortrag Teilen
Consider for example, this line of C++ code:
std::pmr::vector<std::variant<int,double,std::pmr::string>> values;
Are you aware that this line of code contains at least five Gang-of-Four (GoF) design patterns? If not, then this talk is definitely for you! It will help you realize that design patterns are everywhere. They are the key to managing dependencies between software entities. They help us to structure our software, to separate concerns, and to communicate our intentions. Even better, they are universally applicable to object-oriented programming, function programming, and generic programming. And no, design patterns are not old-fashioned, outdated, or even dead. They are at the very core of our software and our daily work.
Target Audience: Architects, Developers
Prerequisites: Foundational knowledge in C++ (examples in C++)
Level: Advanced
Klaus Iglberger is a freelance C++ trainer and consultant. He shares his expertise in popular C++ courses — from beginner to advanced — all around the world. He is the author of “C++ Software Design” [1], one of the organizers of the Munich C++ user group [2], and the (co-)organizer of the Back-to-Basics [3] and Software Design [4] tracks at CppCon [5].
[1] https://learning.oreilly.com/library/view/c-software-design/9781098113155/
[2] https://www.meetup.com/MUCplusplus/
[3] https://cppcon.org/b2b/
[4] https://cppcon.org/softwaredesign/
[5] https://cppcon.org
Vortrag Teilen
BDD is not new, but is very useful. If you have never used it before, or have tried and it didn't work, this session will give a good grounding to using BDD successfully. We'll cover the basics, working through some examples and discuss how to succeed.
We will focus on the process, learning how to write scenarios and have a brief glimpse at what happens under the hood. We'll also think about helping everyone engage with testing.
If you want more people to get involved in testing and need ideas, come along. I'll tell you about my experiences and what has and hasn't worked. You can share your experience too, so we can all go away ready to test, think and communicate better.
Target Audience: Developers, testers, business or product owners
Prerequisites: An awareness of automatic testing
Level: Advanced
Frances Buontempo is currently editor of the ACCU’s Overload magazine and has written two books, one on Genetic Algorithms and Machine Learning and the other on Learning C++ for those who got left behind since C++11. She has worked as a programmer at various companies, mostly in London with a focus on finance. She enjoys testing and deleting code and tries to keep on learning.
Vortrag Teilen
Die Architekturmodelle Clean, Onion und Hexagonal Architecture basieren auf dem Dependency Inversion Principle (DIP). Damit bspw. Domänenlogik nicht von der Datenbank abhängig ist, wird ein Interface dazwischen gestellt. Die Anwendung des DIP ist so allgegenwärtig, dass wir uns an die damit verbundenen Umstände wie Tests mit Attrappen gewöhnt haben.
Mit der Integration Operation Data API Architecture (IODA) gibt es eine Alternative: Durch das Herauslösen der Integration als eigene Verantwortlichkeit entsteht ein einfacheres Architekturmodell. In seinem Vortrag erläutert Stefan Lieser die Prinzipien und Hintergründe. Ferner stellt er die Architekturmodelle anhand von Beispielen gegenüber und zeigt, wie gut die IODA-Architektur sich auf Korrektheit und Wandelbarkeit von Software auswirkt.
Zielpublikum: Architekten, Softwareentwickler
Voraussetzungen: Architekturkenntnisse
Schwierigkeitsgrad: Expert
Stefan Lieser ist Experte für Clean Code und Flow Design. Er hat Ende 2008 die Clean Code Developer Initiative mitbegründet und arbeitet als Trainer und Berater zu den Themen Clean Code Developer, Entwurf mit Flow Design sowie Softwarearchitektur. In seinem Buch „Mit Flow Design zu Clean Code“ beschreibt er einen Softwareentwicklungsprozess, bei dem das systematische Zerlegen der Anforderungen sowie der Entwurf im Vordergrund stehen. Er ist Geschäftsführer der CCD Akademie GmbH.
CCD Initiative - https://clean-code-developer.de
Flow Design - https://flow-design.info
CCD Akademie GmbH - https://ccd-akademie.de
Was haben wir nach 30 Jahren Systementwicklung eigentlich alles gelernt? Im Kern stoßen wir immer wieder auf die gleichen Grundprinzipien, die in überraschend vielfältiger Form auftreten. So unterschiedlich Systeme sind, die Hauptprobleme lassen sich tatsächlich häufig auf die gleichen Ursachen zurückführen.
In dieser Session beleuchten wir unsere wichtigsten „üblichen Verdächtigen“ und zeigen auf, wie man sie adressieren kann. Gewürzt mit zahlreichen Anekdoten, plaudern Jutta und Nico aus ihrem Nähkästchen.
Zielpublikum: Architekten, Entwickler, Projektleiter, Manager, Entscheider, ...
Voraussetzungen: Keine
Schwierigkeitsgrad: Advanced
Jutta Eckstein ist seit 30 Jahren als Business-Coach, Beraterin und Autorin in der Softwareentwicklung unterwegs. Ihr Schwerpunkt liegt dabei auf Agilität und Nachhaltigkeit, worüber sie etliche Bücher geschrieben hat. Sie hat ein Assessment für (agile) Teams mitentwickelt, um deren Auswirkungen auf die ökologische, soziale und wirtschaftliche Nachhaltigkeit zu messen. Sie war von 2003 bis 2007 im Vorstand der AgileAlliance und hat die „Agile Sustainability Initiative“ gegründet, zum Schärfen des Bewusstseins der Agile-Community bzgl. Nachhaltigkeit.
Mehr Inhalte dieses Speakers? Schaut doch mal bei sigs.de vorbei: https://www.sigs.de/experten/jutta-eckstein/
Nicolai Josuttis ist seit 30 Jahren als Entwickler, Autor und Trainer und in der Softwareentwicklung tätig. Sein Schwerpunkt liegt dabei auf C++, über das er etliche Bücher geschrieben hat und bei dem er seit Jahren an der Standardisierung beteiligt ist.