We live in a world of volatile requirements.
We've learned that big up-front design processes don't work. You have to approach
design incrementally so that you can incorporate lessons learned. Our designs
are constantly under stress, because they're constantly changing.
Programs not designed to handle that stress will kill your project.
Code that resists change slows you down so much that
Agile processes will fail, no matter how well you execute.
A new approach to design is essential.
Traditional N-tier architectures just don’t work in this environment, for example.
The best way to handle volatility is to
firmly ground your architecture in the domain and then implement it in a highly modular way where the
modules really are independent. Microservices and messaging are integral to this approach, and systems
developed in this way are scalable, robust, and well suited for deployment in a cloud environment.
This hands-on class covers the entire system-design process, starting with planning
strategies and “user stories” and ending with a full microservice-based implementation architecture.
You'll work on real-world problems that you bring to class rather than a pedagogic exercise.
What you’ll learn
Over the course of a few days:
- you'll learn how to create Problem Statements that establish an overall architecture.
- you'll learn what user stories really are, and at how to write and organize them effectively.
- you'll learn how to factor stories, how to extract architectural elements from them,
and how to derive classes and microservices from those elements.
- you'll learn how to build an architectural model from the stories,
and how to forge that model into a coherent system architecture.
- you'll learn about the best physical architectures for volatile environments,
including microservices, messaging, and agents.
You'll come away with
You'll come away from this class understanding how to build a scalable and robust
system that can easily expand incrementally and accommodate new and changing requirements. In particular,
- understand the entire system design process, starting with “user stories” and ending with a full implementation architecture
- learn how to develop stories, how to factor them into smaller units, how to extract architectural elements from them, and how to derive classes and microservices from them
- know how to look at your system design from both the within-the-application coding architecture and the system architecture perspective
The class can be presented in an abbreviated, lecture only, format.
However, designing around volatility requires thinking about both the problem
and solution in a new way, and this shift in thinking can be difficult
to achieve without a guided exercise. I can also add an extra day or two
of hands on if you want to work on a complex problem.
This hands-on course is aimed both at:
- Engineers who’ve learned (or are learning) an agile process but are
unsure how best to build code that works well with that process
- Architects currently migrating architectures from monolith to microservices.
Prior understanding of object-oriented concepts
(classes, interfaces, subclassing, etc.) is helpful.
This is a design, not a programming class.
We will be working in groups, and each group may opt to use
a shared computer for document creation, so it can’t hurt to
bring yours along, but we can do everything on a whiteboard.