Richard Groß
Head of Software Archaeology
Frankfurt am Main, Germany
Actions
Richard is a software archeologist, developer and auditor. After 11 years in the business he's become a teenager developer. He's consulted legacy and greenfield projects at all large german organizations or knows someone who has and has now held multiple talks about his experience at international conferences and meetups. He enjoys mastering TDD, BDD, DDD, decoupled design and even practices that don't include two D's, like building TestDsls. Most importantly though is that he likes to break the fourth wall and engage his audience. Do you like that as well?
Area of Expertise
Topics
Building dynamic web apps with Kotlin, WebComponents and Htmx
The complexity of single-page application (SPA) frameworks is increasing every year. Developers are not only faced with a steep learning curve, but a never-ending one. Every year, existing concepts are replaced by new ones, some of which radically change how we build applications.
Granted, it is not impossible to keep up and write SPAs well. It just takes a lot of time, dedication and knowledge. This leads to teams being **fragmented** into (a few) frontend experts and the others.
In this talk we will look at a modern approach with Kotlinx.html, Htmx and WebComponents that is much simpler and can deliver at least the same user experience as a SPA. Teams don't have to learn two separate stacks for backend and frontend. This gives us full-stack teams that can be productive together. They can focus on the business logic again and less on the technical aspects.
The Surprising Similarities Between Renovating your House and your Code Base
Code and buildings have nothing in common. One is a malleable construct of our minds, while the other is an observable object, constructed of brick and mortar, amongst other things. Given that code and buildings have no similarities it is clear that we cannot apply metaphors from constructing a building to "constructing" a code base. Or so we thought.
Last year we each bought a house and started renovating it, while at the same time we renovated a legacy code base. It turns out that while construction of code and buildings is very different, renovating them has some surprising similarities.
In this experience report we'll show lots of pictures from our house renovation - full of torn down walls, replaced floors and the like - and draw analogies to our legacy code renovation. We'll share helpful tips for code renovation that can be understood by anyone due to the building analogies and hopefully entertain you along the way. By the end we hope that we've convinced you that renovating a legacy code base is a much nicer task than renovating a house, where each torn down wall can lead to brick and mortar raining down on your malleable head.
Remote Scaled Trunk-Based Development
How do we coordinate teams of 20 or more developers and achieve consistent quality in a remote setting? Plenty scaling methods have been proposed but these models are usually based on Scrum and leave out the technical practices needed to achieve quality at scale.
In this talk we‘ll explore how my project grew from a local six person scrum team to a remote 20 person continuous flow team and beyond. We‘ll take a look at the iterations we needed until we achieved our flow, how we implemented Xp practices like trunk-based development and what practices we adopted in our all-remote setting.
By the end I hope to have provided you with all the information you need to achieve quality at scale in a remote setting.
How to Build the Greatest and Best Pipeline in the World, a Tribute
The Heart of any well-performing team is it‘s own hand-crafted Engineering process. But a heart would be useless without veins that pass along the blood and can take the pressure that the heart builds. In a similar manner a team needs it’s own hand-crafted pipeline. Most teams today have one but only few teams have a pipeline that can take the pressure and not collapse. This talk is how to build this Greatest and Best Pipeline in the world.
To be realistic though, it‘s more of a tribute to the greatest and best pipeline in the world. Not because we couldn’t remember but because we want to show you how you can build your greatest and best pipeline.
Since your process is different from ours we‘ll show you how to hand-craft your pipeline and not prescripe a solution that won't fit.
The examples will cover building, bundling, testing and securing your deployment artifact. They'll be written in Gitlab-Ci format and deploy to Kubernetes, but you can apply the same principles and patterns to any other pipeline and any other environment.
Fixing the Billion Dollar Mistake
Sir Anthony Hoare calls the null reference his billion dollar mistake because it has led to "innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years." Whether the order of magnitude is true remains to be proven by the scientific community but I think it's fair to say that null references are one of the leading causes of sleep deprivation for developers about to release. Thankfully most programming languages have been extended with alternate ways to handle "the absence of value" that lead to more expressive code, less room for errors and better sleep.
In this talk we will explore the Nullability possibilities that C#8 and 9 provide, the alternate ways that other languages like Python, Kotlin or F# have picked and techniques such as Railway-Oriented Programming or the Null-Object-Pattern that can help if the language of choice does not provide an option. Finally we'll look at migration options for older code bases.
Beehive Architecture - Decouple legacy code without being hindered by structure-sensitive tests
Our team has decoupled multiple large legacy code bases without being slown down by structure-sensitive tests. In fact we were able to painlessly grow our suite of business critical tests while we were completely reimagining our internal structure and without our users being impacted.
We did this with a variation of the hexagonal architecture that we now call the beehive architecture. The beehive architecture defines the structure as well as decoupling and test patterns that help you scale beyond 10.000 lines of code. Its structure is that of multiple stacked hexagons that talk to each other only via their driving facades, which makes it look like a large beehive.
This talk explores the isolation mechanisms in the beehive that support decoupling even large applications and the refactoring-friendly test patterns that are possible due to the structure.
Domain Re-discovery Patterns for Legacy Code
In the world of software development, legacy code often poses significant challenges. Existing codebases, built years ago, may lack documentation and understanding of the original domain. This lack of knowledge can hinder effective maintenance, upgrades, and feature development. The process of rediscovering the domain of legacy code is invaluable for developers seeking to enhance and extend these systems.
In this talk we'll delve into various domain re-discovery patterns that help in identifying and reconstructing the domain model that the legacy code represents. These patterns go beyond merely deciphering the code's functionality; rather, they provide strategies to comprehend the underlying concepts, behaviors, and relationships in the domain.
Attendees can expect to gain practical insights, methodologies, and practical tips to tackle the challenges associated with legacy codebases. By embracing domain rediscovery patterns, developers can bring order and coherence to legacy systems, paving the way for future enhancements and system evolution.
Continuous Delivery for Legacy Code
This is based on a true story.
My day job is software archeology. I find joy in recovering and analyzing code bones and culture as well as making the skeleton walk again. A short time ago, however, I was confronted with the most horrible code base I have ever seen. This talk is about how we managed to save it and achieve bi-weekly deployments with a high level of confidence.
Five million lines of code in multiple languages (Classic ASP, .NET, VBScript, VBA, JavaScript, T-SQL, PL-SQL) in one monolith. The business logic stretched from the UI (WebForms, Scripting, SQL Queries) down to the database (Stored Procedures), there was no test coverage and an enormous amount of hidden coupling. A version control system was not used, we had no test environment, deployments required developers to copy their local compilation to production and multiple customer installations are supported by uncommenting and commenting code.
Together we will explore what to do when you inherit such a thing: how to identify hotspots, find hidden coupling, explore how connascence can help you, ways to test as well as refactor and how to achieve a regular deployment schedule.
JavaLand 2025 Upcoming
Actually in "Nürburg, Rhineland-Palatinate, Germany" but the search tool does not know the town.
Build Stuff 2024 Lithuania Sessionize Event
Domain-Driven Design Europe 2024 Sessionize Event
NDC London 2024 Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top