Video accessible from your Account page after purchase.
Register your product to gain access to bonus material or receive a coupon.
8+ Hours of Video Instruction
Learn the benefits of strategic innovation and purposeful event-driven architecture for large-scale system design on brownfield and greenfield systems alike.
Today, businesses and software developers must rapidly innovate and compete while maintaining order and balance with software architecture. In this video, expert Vaughn Vernon teaches you to think and make decisions like a CTO and Chief Architect. Learn to identify core purpose, and then make informed decisions about architecture, programming languages, patterns, and tools to support that purpose.
You will learn about innovative thinking and how design and implementation can align with strategic business goals. You will explore how to use EventStorming, Impact Mapping, Domain-Driven Design, and Event-Driven Architecture, and to deploy right-sized services. Whether the best choice is a monolithic architecture, microservices, or a hybrid, you will learn to identify what helps you and your team deliver what the business demands: success with strategic software.
Learn How To:
Who Should Take This Course
Course Requirements:
Basic knowledge of business software requirements, programming; software architecture and leadership is a plus but not necessary; a willingness to consider alternative approaches to software building that are driven by business strategy rather than technology fascination.
Lesson descriptions:
Lesson 1: This lesson explores how strategic software innovation leads to digital transformation. Using an example of high-level architecture, it covers good and bad architectures, and what has positive and negative effects on both. It explores why software development goes wrong and how to rethink software based on strategic motivations. It also discusses the purposeful use of monoliths and microservices.
Lesson 2: This lesson explores what factors contribute to sound decision making. It teaches how to make good decisions by understanding timing and how to avoid failure and rebound from wrong decisions.
Lesson 3: This lesson covers software-based commands and events. It shows how good models make business complexities understandable, and how to map business processes to software components within a domain model. It also covers EventStorming and Events-First Modeling, and shows how these tools support communication, experimentation, and learning at low cost.
Lesson 4: This lesson discusses the meaning of a software domain and the concept of Domain-Driven Software Modeling. It takes you through a high-level use of how domains and subdomains can be used for strategic innovation.
Lesson 5: This lesson covers domain-driven concepts that must be understood to benefit from the approach to software development. These include Bounded Context, Ubiquitous Language, Core Domain, as well as Supporting and Generic Subdomains.
Lesson 6: This lesson covers Domain-Driven Context Mapping, the use of various mapping relationships, and Topography Architecture Modeling. It also covers the concepts of good failure and how to achieve it; bad failure and how to avoid it; and how to maximize success through practical steps.
Lesson 7: This lesson covers Domain-Driven Tactical Modeling tools, including Entities, Value Objects, Aggregates, Domain Events, and Domain Services. It also highlights modeling with functional programming techniques while using an imperative programming language.
Lesson 8: This lesson introduces architectural styles, patterns, and decision drivers, as well as Ports and Adapters Architecture. It also covers common quality attributes, including security, privacy, performance, and scalability.
Lesson 9: This lesson introduces Message- and Event-Driven Architectures, including the use of REST for both message- and event-based services. It covers process management from both choreography and orchestration aspects, Event Sourcing, CQRS, Serverless Architecture and Function as a Service (FaaS).
Lesson 10: This lesson covers why legacy systems often fail to withstand perpetual changes over time and how to overcome this trend. It covers how to achieve better architecture from the outset, how to correct failed architecture, and how to ensure that successful architecture endures.
Lesson 11: This lesson covers the mental shift required for the additional complexity of working with distributed systems. It covers breaking some contexts of a modular monolith into one or more microservices, as well as breaking a Big Ball of Mud into microservices. It also covers unplugging a legacy system following complete replacement.
Lesson 12: This lesson reviews the importance of seeking balance with quality attributes and following the path of strategic innovation with business-driven purpose, as well as the benefits of leveraging event-driven lightweight modeling and architecture. It emphasizes the importance of maintaining an unbiased attitude toward architecture and of prioritizing essential innovation.
About Pearson Video Training:
Pearson publishes expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. These professional and personal technology videos feature world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, Pearson IT Certification, Prentice Hall, Sams, and Que Topics include: IT Certification, Network Security, Cisco Technology, Programming, Web Development, Mobile Development, and more. Learn more about Pearson Video training at http://www.informit.com/video.
Video Lessons are available for download for offline viewing within the streaming format. Look for the green arrow in each lesson.
Introduction
Module 1: Transformational Strategic Learning Through Experimentation
Lesson 1: Business Goals and Digital Transformation
1.1 Digital Transformation: What is the Goal?
1.2 Why Software Goes Wrong
1.3 Your Enterprise and Conways Law
1.4 (Re)Thinking Software Strategy
1.5 Monoliths Bad? Microservices Good?
1.6 Dont Blame Agile
1.7 Getting Unstuck
Lesson 2: Essential Strategic Learning Tools
2.1 Making Decisions Early and Late, Right and Wrong
2.2 Culture and Teams
2.3 Modules First
2.4 Deployment Last
2.5 Everything in Between
2.6 Strategic Architecture
Lesson 3: Events-First Experimentation and Discovery
3.1 Commands and Events
3.2 Using Software Models
3.3 Rapid Learning with EventStorming
Module 2: Driving Business Innovation
Lesson 4: Reaching Domain-Driven Results
4.1 Meaning of Domain and Domain-Driven
4.2 Domains and Subdomains
Lesson 5: Contextual Expertise
5.1 Bounded Context and Ubiquitous Language
5.2 Core Domain
5.3 Supporting and Generic Subdomains
5.4 Technical Mechanisms
5.5 Business Capabilities and Contexts
5.6 Not Too Big, Not Too Small
Lesson 6: Mapping, Failing, and SucceedingChoose Two
6.1 Context Mapping
6.2 Topography Architecture and Modeling
6.3 Ways to Fail and Succeed
Lesson 7: Modeling Domain Concepts
7.1 Tactical Modeling Tools
7.2 Functional Behavior
Module 3: Events-First Architecture
Lesson 8: Foundation Architecture
8.1 Architectural Styles, Patterns, and Decision Drivers
8.2 Quality Attributes
Lesson 9: Message- and Event-Driven Architectures
9.1 Introduction to Message- and Event-Driven Architectures
9.2 Message- and Event-Based REST
9.3 Event-Driven and Process Management
9.4 Event Sourcing
9.5 CQRS
9.6 Serverless and Function as a Service
Module 4: The Two Paths for Purposeful Architecture
Lesson 10: Building Monoliths Like You Mean It
10.1 Historical Perspective
10.2 Right from the Start
10.3 Right from Wrong
10.4 Keeping It Right
Lesson 11: Monoliths to Microservices Like a Boss
11.1 Mental Preparation with Resolve
11.2 Modular Monolith to Microservices
11.3 Big Ball of Mud to Microservices
11.4 Unplugging the Legacy Monolith
Lesson 12: Require Balance, Demand Strategy
12.1 Balance and Quality Attributes
12.2 Strategy and Purpose
12.3 Event-Driven Lightweight Modeling
12.4 Driving Business Innovation
12.5 Events-First Architecture
12.6 Monoliths as a First-Order Concern
12.7 Purposeful Microservices from a Monolith
12.8 Balance Is Unbiased, Innovation Is Essential
Summary