3 day hands-on workshop. You can’t simultaneously fight your code and be Agile—it slows you down too much. The problem is always rooted in big-up-front-design thinking. Your code’s design must evolve along with your understanding of the product. This class teaches you everything you need to create highly adaptable designs literally as you implement them. Along the way, you’ll also experience Event Storming, TDD, mob-programming, and #NoEstimates techniques.
We live in a world of volatile requirements, where systems not deliberately structured to welcome change do real damage. You struggle to implement even small changes, and to make matters worse, the program structure becomes more intractable with every new requirement. You cannot be agile in any meaningful sense when you’re constantly fighting your code.
It’s impossible to solve this problem with an up-front design, because you learn as you work. Up-front designs are always wrong. Instead, you need to design as you’re working—as new requirements emerge. In an agile environment, every developer on the team needs this skill. A single Architect is too much of a bottleneck.
Evolutionary (or incremental, or emergent) design solves this problem. While focusing tightly on your customer’s environment and the problems that our customers need to solve, you provide a highly valuable solution to a very small problem. Then gradually, you mix in other small solutions until you have a large solution to a large problem. The resulting system directly models the customer’s world so that changes mandated by that world map directly to your code and are easy to implement. As the scope of the problems grow, the code’s structure grows in an organic way that relies on the actual domain for coherence.
This is not just a “design” process, because you have to literally create an architecture as you’re coding. DbC (Design by Coding) is a technique for doing exactly that. Built on TDD (Test Driven Development) principles, DbC is a way to eliminate the up-front design process, even on a micro scale, and is the most effective way to integrate design into your development. Since the most adaptive systems are reactive, we also explore Event Storming—the most effective design technique for this approach.
In this practical, hands-on workshop, you’ll learn how to build adaptable systems that evolve incrementally as you learn. These systems can easily accommodate changing requirements, and are particularly suited for microservice and Agile-development environments.
You’ll learn the entire process, starting with user stories and planning strategies, and ending with a implementation. We’ll go from ideas to actual code using TDD and Design-by-Coding for the final implementation and Event Storming as a design technique. You’ll also learn something about mob programming along the way. 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 build an system incrementally in such a way that it can stand up to change. In particular, you’ll learn:
- how to create a system metaphor that will guide architectural coherence.
- how to create effective user stories that bring real value to your customers
- how do do value-based planning, with no need for formal estimation (not even points)
- how to narrow (slice) stories and otherwise reduce their size to manageable chunks,
- how to build an architectural model from the stories and metaphor, and create a coherent system architecture.
- how to develop effective interfaces and microservice APIs.
- how to code effectively in a volatile environment, including Event Storming, TDD and mob programming.
- how to design reactive (event based) as well as declarative (synchronous) systems.
- how to incrementally create a coherent architecture as you’re coding.
- how to modify that architecture as new requirements are added without damaging architectural coherence or integrity.
You also learn about the best physical architectures for volatile environments, including microservices, messaging, and agents.
The class can be presented in house in both a hands-on and 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. If you want to work on a full-blown business problem, it would be best to allocate a full week.
This hands-on course is aimed both at working developers in all roles (developer, tester, front end, back end, etc.) and technical managers. UX people who work closely with the teams will also benefit. In an Agile shop, it’s best to present to the entire team as a single unit.
- Basic principles: Domain-focused architecture
- What is an object?
- Bounded Contexts
- Defining a story
- The conversation
- Story maps
- Story Maps
- Cumulative flow diagrams
- The Kanban board
- The server (microservices)
- Modeling Basics
- Domain-focused architecture
- The System Metaphor
- Defining the problem (problem statements)
- CRC-card walls
- Refining stories
- Factoring (narrowing)
- Stories to Activities
- Responsibility-based design
- CRC cards and roles
- Using code to develop architecture
- Demo: authentication
- Interaction and API design
- Diagramming complex systems
- Simplified UML as a communication tool.
- Designing the UI/UX incrementally
- Design Thinking and its problems
- Lean UX
- Mob Programming
- Test-Driven Development/Design (TDD)
- Refactoring existing code
- Design by Coding (DbD)
- API design
- Exercise: Developing a problem statement
- Exercise: Creating and organizing stories
- Exercise: Key abstractions
- Exercise: Translating stories to activities
- Exercise: Event Storming
- Exercise: Activities to code/DbC
- Implementation Architecture
- Leveraging Simulation
- Micro- and Mini-services: A short introduction
- Essential characteristics and how to implement them
- Interservice communication and messaging
- Services as objects
Only logged in customers who have purchased this product may leave a review.