In this 4 day DDD Immersion Workshop, taught by Gojko Adzic and authored by Eric Evans, you will learn to strike a healthy balance between digging into your subject matter and addressing technological issues, which, while unavoidable, cannot be allowed to dominate the development process for commercially viable systems.
This particular session of the course uses .NET as the basis for examples, but the course can be attended by Java developers too, as the examples are for illustration only and will not be difficult to understand by Java developers.
Finding and exploiting domain models is key to success with large software systems. In this Domain Modeling Workshop, a team will learn to cultivate a strong connection between the language used by experts, users, and developers, so that the right kind of models can dramatically accelerate the process of translating the customers' needs into working software. Upon completion of this Domain Modeling workshop, the team will have a strong domain modeling capability coupled with programming best practices such as exploiting design patterns, refactoring and test-driven development and will know how to yield a principled yet practical approach to the development of large software systems.
IS THIS COURSE FOR YOU? Managers and analysts (critical) as well as developers (at least half of the attendees) with programming skills on the target platform (Java or C#), and would like to learn how, as a team, you should strike a healthy balance between digging into your subject matter and addressing technological issues, this is the course for you!
NOTES: This course is offered in two forms: one for Java/J2EE; one for C#/.NET.
Please note that the April 2009 course will be taught in C#/.NET.
Programme Day 1 Morning: Ubiquitous Language
* Domain-driven design overview
* Ubiquitous language exercise
Day 1 Afternoon Lab: Expressing a Model in Software
* Tactical domain model patterns (entities, value objects, repositories, etc.)
* Intro to test-driven development (TDD) and test writing as a modeling process
Day 2 Morning: The Model Discovery Process
* Making implicit concepts explicit
* Modeling with domain experts
* Applying design patterns and analysis patterns
Day 2 Afternoon Lab: Supple Design
* writing tests (in TDD) to characterize objects (interfaces and behavioral assertions)
* making code obvious
* advanced techniques for making code easier to use
Day 3 Morning: Context Mapping
* Pragmatic approach to dealing with diverse models and designs on real projects
* Relationships between subsystems/ relationships between teams
Day 3 Afternoon Lab: Multi-Subsystem/ Multi-Team Design
* writing tests at subsystem boundaries
* identifying hotspots
* writing tests at hotspots
* writing translation layers
Day 4 Morning: Making Enterprise Frameworks Work for You This module is usually focused on the technology family (most of) the team uses. This example is for a J2EE project
* Presentation/discussion/Q&A
* Typical mistakes with Servlets and EJBs
* Problems of mixing domain logic with J2EE framework components such as Servlets and EJBs
* How to limit coupling your design to the frameworks (making migration to later versions easier)
* Making code easier to understand
* Making code easier to test
* When to use framework features and when to use POJOs
* Avoiding becoming a "fashion victim"
Day 4 Late Morning: Strategic Distillation
* Distinguishing the core from the mass
* Ways of focusing effort
* Clarifying a shared vision
Day 4 Afternoon: Segregating the Core
* Getting an unobstructed view of essential domain logic
* Taking advantage of new insights and opportunities resulting from the clarity
* Making a generic subdomain easy to use and maintain
* When “good enough” is good enough -- When better is better.
Comments