Domain-Driven Design Fundamentals [2021, ENG] torrent

Обучающие видео » Компьютерные видеоуроки и обучающие интерактивные DVD » Программирование (видеоуроки)

Domain-Driven Design Fundamentals (2nd edition)

Год выпуска: 2021
Производитель: pluralsight
Сайт производителя: https://www.pluralsight.com/
Автор: Steve Smith (@ardalis), Julie Lerman
Продолжительность: 04:48
Тип раздаваемого материала: Видеоурок
Язык: Английский
Описание: In this course, Domain-Driven Design Fundamentals, you’ll learn the key concepts and means to implement DDD. First, you’ll explore how to model a software problem. Next, you’ll discover the elements of DDD. Finally, you’ll learn how to leverage DDD in a sample software application. When you’re finished with this course, you’ll have the skills and knowledge of Domain-Driven Design needed to unravel the complexity of your domain, build smarter software and gain an even deeper understanding of DDD.

Pluralsight DDD Fundamentals Sample
[spoiler="Содержание"]
Код:
01. Course Overview 01:51
01. Course Overview 01:51
02. Introducing Domain-Driven Design 24:37
01. Introduction and Overview 01:24
02. What to Expect from This Course and This Module 01:47
02. Understanding the Value of Domain-Driven Design 02:31
03. Gaining a High-Level Understanding of DDD 03:25
04. Exploring the Benefits and Potential Drawbacks of DDD 04:03
05. Inspecting a Mind Map of Domain-Driven Design 02:33
06. Introducing Our Sample Application 03:24
07. Exploring the Sample Apps High-level Structure 03:55
08. Review and Resources 01:38
03. Modeling Problems in Software 45:12
01. Introduction and Overview 01:11
02. Introducing Our Domain 01:10
03. Planning Ahead to Learn About the Domain 01:06
04. Conversation with a Domain Expert: Exploring the Domain and Its Subdomains 03:23
05. Conversation with a Domain Expert: Exploring the Scheduling Subdomain 04:51
06. Reviewing Key Takeaways from Meeting with Domain Experts 02:16
07. Taking a First Pass at Modeling our Subdomain 01:04
08. Using Bounded Contexts to Untangle Concepts that Appear to Be Shared 04:39
09. Conversation with Eric Evans on Subdomains and Bounded Contexts 01:16
10. Introducing Context Maps 04:59
11. Addressing the Question of Separate Databases per Bounded Context 01:26
12. Specifying Bounded Contexts in our Application 02:05
13. Understanding the Ubiquitous Language of a Bounded Context 03:49
14. Conversation with a Domain Expert: Working on our Ubiquitous Language 05:34
15. Reviewing Important Concepts from This Module 05:07
16. Review and Resources 01:15
04. Elements of a Domain Model 32:21
01. Introduction and Overview 01:34
02. The Importance of Understanding DDD Terms 01:57
03. Focusing on the Domain 02:54
04. Identifying Events Leads to Understanding Behaviors 01:31
05. Comparing Anemic and Rich Domain Models 02:51
06. Understanding Entities 01:53
07. Differentiating CRUD from Complex Problems that Benefit from DDD 01:22
08. Switching Between Contexts in a UI 03:56
09. Using GUIDs or Ints for Identity Values 02:34
10. Talking with Eric Evans About the Responsibility of Entities 01:10
11. Implementing Entities in Code 06:00
12. Synchronizing Data Across Bounded Contexts 01:49
13. Review and Resources 02:52
05. Understanding Value Objects & Services in the Model 22:55
01. Introduction and Overview 00:43
02. Getting Acquainted with Value Objects 01:45
03. Recognizing Commonly Used Value Objects 04:36
04. Getting More Insight from Eric Evans and Vaughn Vernon 03:52
05. Implementing Value Objects in Code 05:19
06. Understanding Domain Services 03:14
07. Review and Resources 03:27
06. Tackling Complexity with Aggregates 34:40
01. Introduction and Overview 01:01
02. Tackling Data Complexity 01:43
03. Introducing Aggregates and Aggregate Roots 02:43
04. Considering Associations in Aggregates 05:39
05. Handling Relationships that Span Aggregates 02:10
06. Evolving the Appointments Aggregate 01:51
07. Using Invariants to Better Understand Our Aggregate 02:00
08. Modeling Breakthroughs and Refactoring 01:20
09. Recognizing Signs of a Misidentified Aggregate 02:55
10. Considering Schedule as Our New Aggregate 01:44
11. Exploring the Schedule Aggregate in Our Application 07:53
12. Sharing Our Tips for Aggregate Design 01:25
13. Review and Resources 02:17
07. Working with Repositories 49:56
01. Introduction and Overview 00:41
02. Introducing Repositories 03:42
03. Repository Benefits 01:18
04. Repository Tips 03:10
05. Avoiding Repository Blunders 02:49
06. Addressing the Debates Around Using Repositories 04:37
07. Returning IQueryables: Pros and Cons 06:41
08. Considering Generic Repositories and Interfaces 04:50
09. Exploring Repositories in our Application 06:34
10. Introducing the Specification Pattern 06:25
11. Using Specifications with Repositories in Our App 06:26
12. Review and Resources 02:43
08. Adding in Domain Events and Anti-corruption Layers 29:41
01. Introduction and Overview 01:00
02. Introducing Domain Events 03:15
03. Identifying Domain Events in Our System 01:40
04. Designing Domain Events 01:28
05. Applying Domain Events to a Simple App 08:58
06. Exploring Domain Events in Our Application 06:57
07. Introducing Anti-Corruption Layers 03:37
08. Review and Resources 02:47
09. Evolving the Application Easily Thanks to DDD 46:44
01. Introduction and Overview 00:54
02. Reviewing Our Current System Design 01:48
03. Addressing a New Feature with the Domain Expert 02:00
04. Planning Our Implementation Steps 01:18
05. Introducing Message Queues 03:18
06. Sending a Message to the Queue 02:35
07. Reading From the Message Queue and Acting on the Message 03:46
08. Using Multiple Queues to Handle Various Communications 03:14
09. Debugging to See the Detailed Implementation in Code 07:26
10. Considering Microservices 03:40
11. Sharing Some Tips for Extending and Running the Sample Application 01:52
12. Considering the UI in the Domain Design 02:56
13. Modeling with Event Storming and Other Techniques 02:11
14. Eric Evans on the Fallacy of Perfectionism 01:28
15. Lessons Learned Since Our 2014 Course 04:49
16. Review and Resources 03:29
[/spoiler]
Файлы примеров: не предусмотрены
Формат видео: MP4
Видео: AVC1 (h264), 1280x720 (16:9), 30fps, ~152kbps (VBR)
Аудио: AAC, 48.0kHz, 96kbps (CBR), 2ch
[spoiler="Скриншоты"]

[/spoiler]
[spoiler="Course Overview"]
Welcome to Pluralsight. My name is Julie Lerman, and this is Steve Smith. Together, we'd like to welcome you to our course, Domain‑Driven Design Fundamentals. Steve is a trainer and architect with NimblePros and spends a lot of time helping teams write better code, faster. And Julie is well known in the DDD community for helping reluctant teams embrace domain‑driven design. In this course, we give you a strong foundation for learning how to build applications and microservices using domain‑driven design. DDD has proven to be a very effective approach for managing complex requirements. The original version of this course has helped many thousands of learners leverage domain‑driven design, and they have shared amazing feedback. Now, we've updated the course and its sample application to reflect ideas and tools that have emerged since that first version. Some of the major topics that we'll cover include what are the essential ideas of domain‑driven design? What are the main patterns used in domain models? We'll also talk about how to break up concepts into smaller parts and how these smaller aggregates and contexts communicate with one another. By the end of this course, you'll know how to break down customer requirements into a maintainable domain model and structure a solution using domain‑driven design. Before beginning the course, you should at least be familiar with software development, ideally using C#. From here, you should feel comfortable diving into DDD and design patterns with courses on the DDD learning path and the design patterns learning path. We hope you'll join us on this journey to learn domain‑driven design with the Domain‑Driven Design Fundamentals course, at Pluralsight.
[/spoiler]