Training: [SOLD OUT] Architecture Without an End State
What you'll learn, and how you can apply it
By the end of this two-day training course, you'll understand:
- How to design systems that can evolve over time in the face of technological and business change
- When the “single system of record” pattern applies and when it does not
- How to separate concerns for better information hiding
- Ways to isolate information to allow independent change
- Why aiming for the “end state” never works and what to do about it
And you'll be able to:
- Combine microservices with legacy systems
- Make your systems glide smoothly from web to mobile to chat apps
- Build systems in simpler pieces that can be recombined and recomposed to enable new business capabilities, all without running afoul of YAGNI
Abstract
Architecture plans in enterprises tend to resemble late-night infomercials. First, you see a person or system that seems incapable of survival—a situation that can be immediately rectified if you just buy into the product. (One popular infomercial shows incompetent people mangling tomatoes transitioning into Ginsu-wielding sous chefs; similarly, the architecture pitch starts with hideous complexity then moves to clean orthogonal box diagrams.) Operators are always standing by.
Real architecture never reaches that blissful end state. Something always interrupts the program: businesses change, technology changes, or funding dries up. What would happen if you did reach the end state, anyway? Is IT in the company done? Of course not.
The truth is that there is no end state. We must all learn to build systems that evolve and grow. We need to stop aiming for the end state and understand that change is continuous. We cannot predict the details, but we can learn the general patterns.
Michael Nygard demonstrates how to design and architect systems that admit change—bending and flexing through time. Using a blend of information architecture, technical architecture, and some process change, Michael walks you through examples of rigid systems to show how to transform them into more maneuverable architecture.
This workshop includes both teaching and hands-on design sessions. Design sessions will be paper and whiteboard work in small groups. You’ll work on real problems drawn from a variety of industries.
Outline
Day 1
Foundations:
- Information hiding
- Decision hiding
- Separation of concerns
- Architectural styles
Architectural patterns:
- Layers
- Pipes and filters
- Broker
- Proxy
- Components and glue
- Interpreter
- Microkernels
- Event stream/CQRS
- Command
Application architecture:
- Consumer-driven contracts
- Segregated interfaces
- Bounded context
- Layers redux
- Hexagonal architecture
Day 2
Living in complex systems:
- Organizations as complex systems
- Local viewpoints
- Local optimization, global deoptimization
- Second-order effects, the law of unintended consequences
Team-scale autonomy:
- Safety in systems
- Independent action
- “Without permission”
Evolutionary architectures:
- Microservices
- Message-driven systems
- Microkernels
Information architecture:
- Identifiers and their many issues
- Single system of record
- Augment upstream
- Contextualize downstream
- Pluralism
- Open-world systems
High-leverage architecture:
- Data/metadata unification
- Rules-based systems
- Generalized minimalism
Other Workshops:
Tracks
Monday, 5 November
-
Microservices / Serverless Patterns & Practices
Evolving, observing, persisting, and building modern microservices
-
Practices of DevOps & Lean Thinking
Practical approaches using DevOps & Lean Thinking
-
JavaScript & Web Tech
Beyond JavaScript in the Browser. Exploring WebAssembly, Electron, & Modern Frameworks
-
Modern CS in the Real World
Thoughts pushing software forward, including consensus, CRDT's, formal methods, & probabilistic programming
-
Modern Operating Systems
Applied, practical, & real-world deep-dive into industry adoption of OS, containers and virtualization, including Linux on Windows, LinuxKit, and Unikernels
-
Optimizing You: Human Skills for Individuals
Better teams start with a better self. Learn practical skills for IC
Tuesday, 6 November
-
Architectures You've Always Wondered About
Next-gen architectures from the most admired companies in software, such as Netflix, Google, Facebook, Twitter, & more
-
21st Century Languages
Lessons learned from languages like Rust, Go-lang, Swift, Kotlin, and more.
-
Emerging Trends in Data Engineering
Showcasing DataEng tech and highlighting the strengths of each in real-world applications.
-
Bare Knuckle Performance
Killing latency and getting the most out of your hardware
-
Socially Conscious Software
Building socially responsible software that protects users privacy & safety
-
Delivering on the Promise of Containers
Runtime containers, libraries, and services that power microservices
Wednesday, 7 November
-
Applied AI & Machine Learning
Applied machine learning lessons for SWEs, including tech around TensorFlow, TPUs, Keras, PyTorch, & more
-
Production Readiness: Building Resilient Systems
More than just building software, building deployable production ready software
-
Developer Experience: Level up your Engineering Effectiveness
Improving the end to end developer experience - design, dev, test, deploy, operate/understand.
-
Security: Lessons Attacking & Defending
Security from the defender's AND the attacker's point of view
-
Future of Human Computer Interaction
IoT, voice, mobile: Interfaces pushing the boundary of what we consider to be the interface
-
Enterprise Languages
Workhorse languages found in modern enterprises. Expect Java, .NET, & Node in this track