Engineering the Future of Software
29–31 Oct 2018: Tutorials & Conference
31 Oct–1 Nov 2018: Training
London, UK

Building Incremental Architecture (Day 2)

Allen Holub (Holub Associates)
Location: Westminster Suite

What you'll learn

By the end of this two-day training course, attendees will understand:

  • How to develop effective systems and APIs around bounded contexts.
  • How to define effective user stories.
  • How to refine those stories and narrow them into implementable small increments.
  • How to develop a domain model and a system metaphor from those stories
  • How to turn that into and architecture that evolves incrementally in a way that maintains system coherence
  • How to design incrementally as you’re actually implementing.

And they’ll be able to:

  • Create an architecture in incremental steps rather than a single up-front process.
  • Optimize that architecture so that it can evolve over time to accommodate changing requirements.
  • Create and size high quality user stories and build an architecture around these stories.
  • Use mob programming and TDD to develop code in and agile way.

Description

Modern development practices rarely use large up-front design, but if you are still using them, you’ve likely encountered problems as you implement. Nowadays, you must create an architecture incrementally as you work, and you have to be able to easily modify that architecture as new requirements emerge. The solution is to build around a domain-focused metaphor that allows for incremental changes while maintaining coherence throughout. Allen Holub demonstrates how to develop an effective and coherent architecture incrementally as the code evolves. The techniques you’ll learn in this workshop are essential when building effective microservice APIs, and in any development shop where requirements change as you’re working. The things you learn in this class will be particularly appropriate for Microservices environments.

This workshop takes a very hands-on approach to learning, and we’ll spend much more time doing than listening to lectures. Over the course of two days, we’ll actually design a system that can handle incremental development, and then evolve it incrementally. We’ll learn how to start with a real world problem provided by either you or your classmates, and we’ll end up with a domain-based architecture that can grow as the system grows.

Photo of Allen Holub

Allen Holub

Holub Associates

Allen Holub (http://holub.com, allenholub, allenholub.com) is one of the countries foremost software architects and Agile-transformation consultants. He specializes in lean/agile-friendly process and implementation technology (like microservices). He provides in-house training, consulting, and organizational assessment and improvement services internationally, and regularly presents at conferences all over the world. He excels at building highly functional Lean/Agile organizations and designing and building robust, highly scalable software suitable for agile environments. He’s worn every hat from CTO to grunt programmer, and is an expert-level programmer in many languages and platforms.

Allen is widely published. His works include 10 books, hundreds of articles in publications ranging from Dr. Dobb’s Journal to IBM DeveloperWorks), and video classes for agilitry.com (Agility with Allen) and Pluralsight (Swift in Depth, Picturing Architecture, Object-Oriented Design) and O’Reilly (Design Patterns in the Real World), and Lynda/LinkedIn.

Leave a Comment or Question

Help us make this conference the best it can be for you. Have questions you'd like this speaker to address? Suggestions for issues that deserve extra attention? Feedback that you'd like to share with the speaker and other attendees?

Join the conversation here (requires login)