You are viewing content from a past/completed QCon

Training: [SOLD OUT] Event-Oriented Domain-Driven Design

Location: Garden B

Duration: 9:00am - 4:00pm

Day of week: Thursday and Friday

Level: Intermediate

Prerequisites

Much of two days will be spent implementing using Java or C#. At least 5-10 years of programming experience is recommended. You are required to supply your own computer, programming environment with build and test facilities that you use regularly, and your thinking cap.

Using events to deliver core business value

This intensive, two-day, hands-on workshop teaches you DDD within an explicitly event-oriented microservices business domain. You will learn both strategic and tactical design. This workshop is specially designed for mid-level and senior software developers and architects who are interested in applying event-driven and microservices architectures using DDD. This is a hands-on workshop. Students are strongly encouraged to engage in workshop exercises and write source code that includes implementing multiple interacting Microservices that are event-driven and that use DDD strategic and tactical design.

This hands-on, code-prolific, DDD workshop teaches you the essentials of how to implement using the Domain-Driven Design approach. Students first receive an overview of DDD’s strategic and tactical design, including ways to develop a Ubiquitous Language within a Bounded Context, using both Event Storming and Specification by Example.

Following this, teams of students use these tools to reach a shared understanding of a Core Domain and Subdomains. Each team presents their “big picture” and “design level” direction and receive helpful feedback before the implementation begins. This step leads to a succession of strategic and tactical design learning and implementation steps with either Java or C#. Implementations may use Event Sourcing and traditional domain model persistence.

Takeaways:

  • Essential DDD, with strategic and tactical design, including developing a Ubiquitous Language in a Bounded Context
  • Bounded Contexts, Core Domain, Subdomains, and Context Mapping
  • Domain Events and Aggregates
  • Project acceleration and management tools
  • Learn the basics of Event Storming using “big picture” and “design level” modeling
  • Apply your storming results to actual implementations using Aggregates and Domain Events
  • Use Domain Events to integrate with multiple Bounded Contexts
  • The tradeoffs of using traditional domain model persistence and Event Sourcing

Outline

  • Domains, Subdomains, and Bounded Contexts

Grasp the core concepts of DDD strategic modeling, and put them to use. Learn to vigorously gather core concepts and separate irrelevant ones. Learn why strategic design is so essential. Develop the ability to determine when your domain models are composed correctly and when they required more rigorous design.

  • Context mapping

Learn how to integrate with other subsystems using DDD and straightforward design techniques. Context Maps are not just drawings. Use them for cross-team communications, project thinking, learning, planning, and as an integration tool.

  • Architectures that support DDD

See how the Microservices Architecture, Ports and Adapters Architecture, along with an Event-Driven Architecture, can be used to support your DDD projects. Coupled with DDD, these architecture styles and patterns will support your microservices efforts.

  • Domain events and event storming

Learn to use Domain Events and Event Storming for both “big picture” systems designs and “detail level” tactical designs. Exercises will lead to using and Event-Driven Architecture in Day-2 implementations.

  • Aggregates

Demystify effective aggregate designs with the use of a set of simple rules. Learn how to design object clusters for correct transactional consistency, performance, and high scalability.

  • Acceleration and management tools

Every project stakeholder knows the urgency of staying on task and on time. What techniques and tools can be used to accelerate your DDD effort, provide project estimates, time box domain modeling efforts, collaborate with domain experts, and how much time will that require? The answers are given and reenforced through practical guidelines.

Speaker: Vaughn Vernon

DDD Expert, Author of "Implementing Domain-Driven Design" & Architect @kalele_io

Vaughn Vernon is a software developer and architect with more than 30 years of experience in a broad range of business domains. Vaughn is a leading expert in Domain-Driven Design, and a champion of simplicity and reactive systems. He consults and teaches around Domain-Driven Design and reactive software development, helping teams and organizations realize the potential of business driven and reactive systems as they transition from technology driven legacy web implementation approaches. As he does so, he puts strong emphasis on embracing simplicity whenever possible. Vaughn is the author of three books: Implementing Domain-Driven Design, Reactive Messaging Patterns with the Actor Model, and Domain-Driven Design Distilled, all published by Addison-Wesley.

Find Vaughn Vernon at

Speaker: Tom Stockton

Principal Architect at MAXIMUS

Tom Stockton is a Principal Architect at MAXIMUS, providing software solutions to support government health and human services programs in the United States.  Tom has been a Java enthusiast since the Java World Tour in '97, is a proponent of reactive systems, Domain-Driven Design, and an early vlingo/platform adopter.

Find Tom Stockton at

Proposed Tracks

  • Machine Learning without a PhD

    AI/ML is more approachable than ever. Discover how deep learning and ML is being used in practice. Topics include: TensorFlow, TPUs, Keras, PyTorch & more. No PhD required.

  • Production Readiness: Building Resilient Systems

    Making systems resilient involves people and tech. Learn about strategies being used from chaos testing to distributed systems clustering.

  • Building Predictive Data Pipelines

    From personalized news feeds to engaging experiences that forecast demand: learn how innovators are building predictive systems in modern application development.

  • Modern Languages: The Right Language for the Job

    We're polyglot developers. Learn languages that excel at very specific tasks and remove undifferentiated heavy lifting at the language level.

  • Delivering on the Promise of Containers

    Runtime containers, libraries and services that power microservices.

  • Evolving Java & the JVM

    6 month cadence, cloud-native deployments, scale, Graal, Kotlin, and beyond. Learn how the role of Java and the JVM is evolving.

  • Trust, Safety & Security

    Privacy, confidentiality, safety and security: learning from the frontlines.

  • Beyond the Web: What’s Next for JavaScript

    JavaScript is the language of the web. Latest practices for JavaScript development in and out of the browser topics: react, serverless, npm, performance, & less traditional interfaces.

  • Modern Operating Systems

    Applied, practical & real-world deep-dive into industry adoption of OS, containers and virtualization, including Linux on.

  • Optimizing You: Human Skills for Individuals

    Better teams start with a better self. Learn practical skills for IC.

  • Modern CS in the Real World

    Thoughts pushing software forward, including consensus, CRDT's, formal methods & probabilistic programming.

  • Human Systems: Hacking the Org

    Power of leadership, Engineering Metrics and strategies for shaping the org for velocity.

  • Building High-Performing Teams

    Building, maintaining, and growing a team balanced for skills and aptitudes. Constraint theory, systems thinking, lean, hiring/firing and performance improvement

  • Software Defined Infrastructure: Kubernetes, Service Meshes & Beyond

    Deploying, scaling and managing your services is undifferentiated heavy lifting. Hear stories, learn techniques and dive deep into what it means to code your infrastructure.

  • Practices of DevOps & Lean Thinking

    Practical approaches using DevOps and a lean approach to delivering software.

  • Operationalizing Microservices: Design, Deliver, Operate

    What's the last mile for deploying your service? Learn techniques from the world's most innovative shops on managing and operating Microservices at scale.

  • Developer Experience: Level up your Engineering Effectiveness

    Improving the end to end developer experience - design, dev, test, deploy and operate/understand.

  • Architectures You've Always Wondered About

    Next-gen architectures from the most admired companies in software, such as Netflix, Google, Facebook, Twitter, & more