A Craftsman’s Guide to Designing
a Clean Architecture
In 2018, it seems like Microservices are the de
facto standard for a system architecture, but do they really live
up to the hype?
The talk will show you an alternative approach - how we can tame
complexity with the help of a clean, monolithic architecture that
is modular to the core. Java has been deliberately built from
the ground up on a modular basis: Methods, classes, packages.
Additionally, the module system was introduced in Java 9. Modularity
is based on the fundamental concepts of high cohesion and low
coupling. We will look at these concepts, as well as some further
measures, in detail. We'll check out what they are, how they are
related to one another, and what the best practices are for applying
them on all levels of the architecture.
The talk will show you how you can apply these basic concepts
to develop a clean, monolithic architecture, based on Java 9 modules
and the hexagonal architecture pattern. Finally, we'll learn how
to achieve a clean microservice architecture based on a modular
Marcus Biel (@MarcusBiel) is a Software Craftsman, a Clean Code
Evangelist and Java influencer. Since 2001, Marcus has worked
as a developer and architect on many different Java related projects,
mostly in the finance and telecommunications industries. Right
now he is working on https://cleancodeacademy.com/, an online
platform dedicated to teaching aspiring Java Craftsmen.
Bridging the Divide between Architecture
Static diagrams on wikis and white-boards might
capture the vision of architects, but they don’t much help
programmers to understand how the code they’re working on
right now fits into the architecture. Nor are the programmers
warned when they violate the diagrams as they forge changes, line-by-line.
This is a huge problem – it is ultimately individual lines
of code that make or break an architecture; and we know that a
clean architecture will help teams develop a more flexible product,
with less complexity, less wasted effort, etc. Worse, without
practical architectural guidance, programmers wrestle with invisible
structures that emerge from thousands of inter-dependent lines
of code. And being invisible, these structures become ever more
complex, coupled, and tangled. In fact, uncontrolled structure
actively fights against productive development. This talk shows
how to rein in emergent code-base structures and gradually transform
them into a cogent, defined architecture. You will see how…
• Visualizing the emergent structure makes a code-base easier
• Restructuring to remove tangles and reduce coupling makes
the visualized code-base easier to work on.
• Specifying layering and dependency rules converts good
structure into a controlled architecture that guides the team
as the code-base evolves and grows. A key ingredient is a live
visualization, inside the IDE, of the detailed code the programmer
is working on, in the context of the overall architecture. In
short, you will learn how bridging the architect/programmer divide
can convert code-base structure from liability into an asset that
actively works for development productivity.
The presenter, Chris Chedgey, is co-founder, product
designer, and developer at Structure101 - a team dedicated to
creating techniques and technology for transforming and controlling
the structure of large evolving code-bases. During a career spanning
30 years, Chris also worked on large military and aerospace systems
in Europe and Canada, including the International Space Station.
He has spoken at many user groups and conferences including Oredev,
JavaOne, JAX, Javaland, 33rd Degree, JFocus, and Devoxx.