-
Introduction to Queues
After mastering the fundamentals of software development; you can develop feature-rich applications for a variety of platforms. In this video; Jamie Campbell explains queues in C#.
-
GRASP - Controller
Controller is one of the key principles of the GRASP notation in Object-Oriented Design. In this video; Chris Keenan discusses the role of the Controller principle in the GRASP pattern and how it can be implemented.
-
GRASP - Polymorphism
Polymorphism is the ability to use an object as if it were an object of its superclass while still using its overridden methods. Polymorphism is one of the key principles of the GRASP notation .In this video; Chris Keenan discusses the role of the Polymorphism in the GRASP pattern and how it can be used.
-
Creating Classes and Objects
In OOD; you can define and implement classes and objects. In this video; Chris Keenan demonstrates how to create a class and instantiate a Java object.
-
Implementing Inheritance
In OOD; you can use inheritance to define new classes based on existing classes. In this video; Chris Keenan demonstrates key aspects of inheritance with some examples.
-
Working with Abstract Classes
In OOD; you can use abstract classes and define common methods and variables for their subclasses. In this video; Chris Keenan demonstrates concepts of abstract classes.
-
Class Responsibility Collaboration Card
In OOD; you can use the class responsibility collaboration card to map various objects of your program. In this video; Chris Keenan discusses the class responsibility collaboration card and how it can be implemented.
-
Don't Repeat Yourself (DRY)
In OOD; the Don't Repeat Yourself (DRY) principle helps you prevent duplication of logic in objects used in programs by writing reusable modular code. In this video; Chris Keenan discusses the Don't Repeat Yourself principle.
-
General Responsibility Assignment Software Patterns
In OOD; General Responsibility Assignment Software Patterns (GRASP) lists the best practices for object-oriented design. In this video; Chris Keenan discusses the General Responsibility Assignment Software Patterns.
-
GRASP – Creator
The Creator is one of the key principles of the GRASP notation in Object-Oriented Design. In this video; Chris Keenan discusses the role of the Creator principle in the GRASP pattern and how it can be used.
-
GRASP - High Cohesion
High Cohesion is one of the key principles of the GRASP notation in Object-Oriented Design. In this video; Chris Keenan discusses the role of the High Cohesion principle in the GRASP pattern and how it can be implemented.
-
GRASP - Indirection
In OOD; Indirection helps you decouple multiple objects by creating an intermediary class to act as a middleman between the objects so that they are not directly coupled. Indirection supports low coupling and reuse. In this video; Chris Keenan discusses Indirection.
-
GRASP - Information Expert
In OOD; the GRASP Information Expert assigns a responsibility to the class that has the information needed to fulfill it. In this video; Chris Keenan discusses the GRASP Information Expert.
-
GRASP - Low Coupling
Low Coupling is one of the key principles of the GRASP notation in Object-Oriented Design. In this video; Chris Keenan discusses the role of the Low Coupling principle in the GRASP pattern and how it can be implemented.
-
GRASP - Protected Variations
In OOD; Protected Variations help you avoid the impact of changes of some objects on others in the system by using interfaces to stabilize predicted changes and variations on the system. In this video; Chris Keenan discusses Protected Variations.
-
GRASP - Pure Fabrication
In Object-Oriented Design; Pure Fabrication helps you assign the responsibility for handling a specific operation to a fake class; which does not fit with the other objects in the system; to support high cohesion. In this video; Chris Keenan discusses Pure Fabrication.
-
Introduction to Object Oriented Fundamentals
In OOD; you can use the concepts of objects; classes; abstraction; polymorphism; inheritance; and encapsulation for object oriented programming. In this video; Chris Keenan discusses the fundamentals of object oriented programming.
-
Introduction to Unified Modeling Language
In OOD; you can use UML to create graphical representation of a system or a solution. In this video; Chris Keenan demonstrates key aspects of Unified Modeling Language.
-
Object-Oriented Design Concepts
Object-Oriented Design is the process of analyzing and designing objects and products. In this video; Chris Keenan discusses Object-Oriented Design concepts.
-
SOLID - Introduction to SOLID Design Principles
The SOLID principle is a series of best practice methods for Object Oriented Design. In this video; Chris Keenan discusses about the SOLID principles.
-
SOLID - The Dependency Inversion Principle
In OOD; the Dependency Inversion Principle states that high level modules should not depend upon low level modules and that both should depend on abstractions. In this video; Chris Keenan discusses the Dependency Inversion Principle.
-
SOLID - The Interface Segregation Principle
In OOD; the Interface Segregation Principle states that clients should not be forced to depend upon interfaces that they do not use; and so you should break that larger single interface into smaller multiple ones for easy use. In this video; Chris Keenan discusses the Interface Segregation Principle.
-
SOLID - The Liskov Substitution Principle
In OOD; the Liskov Substitution Principle states that you should be able to substitute a child class for a parent without losing any of the functionality of that parent class because child classes inherit the methods and properties of the parent. In this video; Chris Keenan discusses the Liskov Substitution Principle.
-
SOLID - The Open Closed Principle
In OOD; the Open Closed Principle states that a class should be open for extension but closed for modification. In this video; Chris Keenan discusses the Open Closed Principle.
-
SOLID- The Single Responsibility Principle
The first principle for the SOLID design principles is the Single Responsibility Principle. In this video; Chris Keenan discusses the basic concepts of the Single Responsibility Principle and how to implement it.
-
UML Activity Diagrams
You can use the UML activity diagram to design your activity processes. In this video; Chris Keenan demonstrates how to use the UML activity diagram.
-
UML Class Diagrams
In Object-Oriented Design; the UML class diagram helps you model your classes and their relationships with other classes before you create the code for those classes. In this video; Chris Keenan discusses UML class diagrams.
-
UML State Charts
You need to use state chart while using UML to model and design your software solution. In this video; Chris Keenan demonstrates how to create and use UML state charts.
-
UML Use Cases
In Object-Oriented Design; you can use UML use cases to generate a graphical representation of a system or a solution. In this video; Chris Keenan demonstrates the key aspects of UML use cases and creates a basic use case in MS Visio.
-
Understanding Encapsulation
In OOD; you can use encapsulation by combining associated variables and methods within the same object. In this video; Chris Keenan demonstrates concepts of encapsulation.
-
Understanding Polymorphism
Polymorphism in Object Oriented Design provides the ability to use an object as if it were an object of its superclass while still using its overridden methods. In this video; Chris Keenan explains the concept of Polymorphism.
-
Beginning the Planning Process
After watching this video; you will be able to describe the initial steps taken in planning your software application project.
-
Creating the Design Document
After watching this video; you will be able to identify the main components of a design document.
-
Importance of the Planning Process
After watching this video; you will be able to identify why it is important to properly plan your project.
-
Integrating Planning with Design
After watching this video; you will be able to describe how the planning documentation is helpful during the design stage of your project.
-
Maintaining Design Documentation
After watching this video; you will be able to identify the importance of maintaining and updating your design documentation.
-
Planning Documentation Maintenance
After watching this video; you will be able to identify the importance of maintaining and updating your planning document.
-
Project Planning Documentation
After watching this video; you will be able to identify the main components included in a planning document.
-
Software Planning Fundamentals
After watching this video; you will be able to describe the concept of planning and its part in the creation of a software application .
-
Command Query Separation Principle
The Command and Query Separation principle can be described as the bedrock of CQRS. In this video; Chuck Easttom discusses the Command Query Separation principle; including its benefits; and how the principle is related to object-oriented programming where there are separate object methods to do commands and queries.
-
Commands
Commands allow users to modify the state of some part of a system. In this video; Chuck Easttom discusses the purpose of commands in CQRS; the appropriate naming of commands; and how commands relate to functions or methods at the class and object levels in the context of layered or tiered system architecture.
-
Command Query Responsibility Segregation
Command Query Responsibility Segregation (CQRS) is a software development term that describes the concept of separating queries and commands. CQRS is derived from the Command and Query Separation principle. In this video; Chuck Easttom provides an overview of CQRS.
-
and Event Sourcing
Command Query Responsibility Segregation (CQRS) has a symbiotic relationship with event sourcing. In this video; Chuck Easttom demonstrates how event sourcing allows you to determine the origin of an event; and considers the role provides the connection between commands and events.
-
and Persistent View Model
CQRS uses a persistent view model; meaning that there is constant viewing of data occurring. In this video; Chuck Easttom discusses how the interaction between the view model and CQRS works.
-
Command Validation
Commands are how you interact with data; whether updating; deleting; or inserting new data. In this video; Chuck Easttom discusses how to use commands to validate commands in a CQRS framework.
-
Commands and Domain Objects
A very close relationship exists between commands and domain objects in CQRS; because there is an ideal environment for CQRS contained within domain driven design. In this video; Chuck Easttom demonstrates how CQRS commands and domain objects interact.
-
Query Data
When dealing with CQRS it’s very important to consider the data view model classes you are working with when it comes to implementing queries. In this video; Chuck Easttom discusses why you don’t need relational databases in CQRS.
-
CRUD Architecture
The CQRS pattern segregates read and update operations; providing many advantages over the traditional create; read; update; and delete (CRUD) approach. In this video; Chuck Easttom demonstrates CRUD architecture and the limitations that make it better suited to simple systems.
-
DDD and N-layer Architecture
In CQRS; N-layered; or N-tiered; architecture is an approach to software architecture that works well together with domain-driven design. In this video; Chuck Easttom demonstrates the key characteristics of both approaches and describes how they can interface with one another.
-
Dealing with Constraints
In CQRS; constraints define the limits on how you can interact with data. In this video; Chuck Easttom demonstrates how to deal with SQL constraints within the CQRS framework.
-
Handling Events in C#
If you want to separate events in CQRS you can run them in separate services. In this video; Chuck Easttom demonstrates how to handle CQRS events in C# so you can implement entirely separate services for commands and queries.
-
Implementing Commands in C#
You can implement the essentials of CQRS commands in C#. In this video; Chuck Easttom demonstrates how to use C# to issue CQRS commands to query and retrieve values from a data store.
-
Implementing the Pattern in C#
In CQRS you can make a service more robust by adding a complex event handling structure that follows a prescribed pattern. In this video; Chuck Easttom demonstrates the CQRS pattern you need to follow to create the elements needed to implement a service containing multiple events.
-
Introduction to Domain-driven Design
Domain-driven design is central to CQRS. In this video; Chuck Easttom discusses what domain-driven design is and defines the basic concepts and terms associated with it; such as domain; domain model; context; entity; value object; and aggregate.
-
Model-driven Design
In CQRS; model-driven architecture is an approach to software design that involves using highly specific; well-defined models to drive the architectural process. In this video; Chuck Easttom discusses model-driven architecture; explaining what it involves and its key characteristics.
-
Task Based UIs
In CQRS; the concept of task-based user interfaces is closely related to that of domain-driven design. In this video; Chuck Easttom discusses the approach involved in creating task-based user interfaces; how it differs from traditional; data-focused approaches to software architecture; and how the role of these interfaces within a basic software system is conceptualized.
-
The Pattern
CQRS is largely defined by the CQRS pattern. In this video; Chuck Easttom demonstrates how; not only are commands and queries separate; but that they are implemented in entirely different services or constructs.
-
Abstract and Sealed Classes
Once you master a common set of concepts and methodologies used to create programs; you can develop feature-rich applications for a variety of platforms. In this video; Jamie Campbell demonstrates how to use abstract and sealed classes in C#.
-
Access Modifiers
You can develop feature-rich applications in a variety of platforms if you master the fundamentals in any one programming language. In this video; Jamie Campbell explains the various access modifiers in C#.
-
Accessing Objects with the This Keyword
In C#; you can use the this keyword to access objects. In this video; Jamie Campbell explains how to use the this keyword with examples.
-
Base and Derived Classes
When you develop software; you can create useful algorithms by using base and derived classes; which are powerful features of object-oriented programming. In this video; Jamie Campbell discusses base and derived classes.
-
Casting Between Types
Once you master a common set of concepts and methodologies used to create programs; you can develop feature-rich applications for a variety of platforms. In this video; Jamie Campbell discusses casting between types.
-
Creating a Class in C#
When you understand classes; you can develop feature-rich applications for a variety of platforms. In this video; Jamie Campbell explains how to create a class and add objects to it using C#.
-
CSS and DIVs
In HTML; you can create page layout by using the DIVs and CSS styles. In this video; Jamie Campbell demonstrates how to use both DIVs and CSS to create a page layout in HTML.
-
How to Capture User Input
In C#; you can use user input to make applications interactive. In this video; Jamie Campbell demonstrates how to capture user input in a C# console application.
-
How to Create a File and Write Data to It
When you develop software; you can create a file and write data to it easily by using C#. In this video; Jamie Campbell demonstrates how to create a file and write text to it.
-
How to Create a Random List of Numbers
After mastering the fundamentals of software development; you can develop feature-rich applications for a variety of platforms. In this video; Jamie Campbell demonstrates how to create a list of unique random numbers.
-
How to Create Objects
During software development; you can create many objects from one class. In this video; Jamie Campbell demonstrates how to create an object from a class by using C#.
-
How to Read and Display Files
In C#; you can read and display the contents of a file. In this video; Jamie Campbell demonstrates the method to read and display files in C#.
-
Introduction to Exception Handling
You can create feature-rich applications for a variety of platforms after you have mastered the software development fundamentals. In this video; Jamie Campbell demonstrates exception handling in C# with some examples.
-
Introduction to For and Foreach Loops
You can create feature-rich applications for a variety of platforms after you have mastered the software development fundamentals. In this video; Jamie Campbell demonstrates how to use for and foreach loops in C# with some examples.
-
Introduction to If Statements
Software development using programming languages require creating algorithms and decision structures. In this video; Jamie Campbell explains how to use if statements.
-
Introduction to If-else Statements
Software programming involves checking and comparing several variables; and "if-else" statements enable users to do that. In this video; Jamie Campbell explains how to use if-else statements.
-
Introduction to Math Operators
In Software Development Fundamentals; you can create various algorithms by using math operators. In this video; Jamie Campbell demonstrates how to use math operators.
-
Introduction to Methods
Software development involves using several different kinds of methods within a Main method. In this video; Jamie Campbell introduces methods.
-
Introduction to Recursion
You can create feature-rich applications for a variety of platforms after you have mastered the software development fundamentals. In this video; Jamie Campbell demonstrates how to use recursion in C# with some examples.
-
Introduction to Switch Statements
While developing software using C#; you can also use switch case statements to various conditions. In this video; Jamie Campbell explains how to use switch statements.
-
Introduction to Variable Data Types
In Software Development Fundamentals; you can write various algorithms by using data type variables. In this video; Jamie Campbell discusses different variable data types.
-
Introduction to Variables and Constants
Understanding the structure of a program in any language or platform is an important aspect of software fundamentals. In this video; Jamie Campbell demonstrates the variables and constants in a C# program.
-
Introduction to While and Do-while Loops
You can create feature-rich applications across a variety of platforms after you have mastered the software development fundamentals. In this video; Jamie Campbell demonstrates how to use while and do-while loops in C# with some examples.
-
Multiple Document Interface Applications
In Windows application; you can add multiple windows inside the main application window using C#. In this video; Jamie Campbell explains MDI Windows form application.
-
Opening Files
When developing software; you need to create file dialogs in Windows form applications to provide information to users. In this video; Jamie Campbell demonstrates how to open a file dialog.
-
Programming Windows Forms Applications
After mastering the basics of C#; you can create graphically rich Windows applications and modify form elements. In this video; Jamie Campbell demonstrates programming with Windows forms.
-
Saving Files
In Visual Studio; you can add a control to save files in your Windows forms application. In this video; Jamie Campbell demonstrates how to save files in the Windows forms application.
-
Setting Up a Windows Algorithm
In Software Development Fundamentals; you can set up algorithms for Windows applications. In this video; Jamie Campbell demonstrates how to set up a Windows algorithm.
-
String Indexing
In C#; you can use the various indexing options for operations. In this video; Jamie Campbell demonstrates how to perform string indexing in C#.
-
String Literals
In C#; you can do a number of different things with string literals. In this video; Jamie Campbell demonstrates how to use string literals in C# and the different rules of string literals.
-
The Structure of a C# Program
Understanding the structure of a program in any language or platform is an important aspect of software fundamentals. In this video; Jamie Campbell demonstrates how to create the structure of a C# program.
-
Windows Alerts and Dialogs
In Visual Studio; you can use message boxes and dialog boxes while developing applications. In this video; Jamie Campbell demonstrates how to use message boxes and dialog boxes in the applications.
-
Windows Form Events
In C#; you can use Windows form events to add various events to your applications. In this video; Jamie Campbell demonstrates how to add Windows form events in C#.
-
Windows Forms Applications
You can create graphically rich Windows applications after mastering the basics of C#. In this video; Jamie Campbell demonstrates how to design Windows forms applications.
-
Working with Substrings
In Software Development Fundamentals; you can use substrings to get the string value. In this video; Jamie Campbell demonstrates how to use substrings.
-
Introduction to Arrays
In C#; arrays are extremely powerful aspect of any programming language. In this video; Jamie Campbell demonstrates how to use arrays in C#.
-
Introduction to CSS
After mastering the fundamentals of software development; you can develop applications for a variety of platforms. In this video; Jamie Campbell discusses cascading style sheets in HTML.
-
Introduction to Interfaces
Interfaces are methods that allow you to create an interaction between two different objects or multiple objects in C#. In this video; Jamie Campbell demonstrates how to use the IComparable interface.
-
Introduction to JavaScript
JavaScript is a dynamic client-side scripting language that unleashes the power of web sites. In this video; Jamie Campbell demonstrates the overview of JavaScript.
-
Introduction to Linked Lists
In C#; you can use LinkedList to create data structures and modify them. In this video; Jamie Campbell demonstrates how to use LinkedList in C#.
-
Introduction to Lists
Programmers use data structures to create lists of items that can be referenced and modified. In this video; Jamie Campbell demonstrates how use lists in C#.
-
Introduction to Namespaces
In C#; you can use namespaces when you need to distinguish between two different classifications of the same type of items. In this video; Jamie Campbell explains how to use namespaces.
-
Introduction to Polymorphism
Once you master polymorphism; you can give derived classes the ability to share functionality with their base classes. In this video; Jamie Campbell demonstrates how to use polymorphism.
-
Introduction to Randomization
In C#; you can use randomization which is important for application development so that you can provide different results to the user each time. In this video; Jamie Campbell demonstrates how to use random number to generate results in C#.
-
Introduction to Sorting Algorithms
After mastering software development fundamentals; you can develop applications for a variety of platforms. In this video; Jamie Campbell discusses types of sort algorithm.
-
Introduction to Stacks
In C#; you can use stacks to arrange the items or objects in order in last-in first-out basis. In this video; Jamie Campbell demonstrates how to use stacks.
-
Introduction to Static Members
In C#; you can use the static keyword to declare members that don't belong to different objects; but to the class itself. In this video; Jamie Campbell explains how to use static members with examples.
-
Introduction to Structs
In C#; you can use structs to create references of variables containing values. In this video; Jamie Campbell demonstrates how to use structs in C#.
-
JavaScript Rules
Using JavaScript; you can create applications in your web sites using some really simple basic rules of coding. In this video; Jamie Campbell demonstrates the basic rules of JavaScript.
-
Modifying HTML Elements
JavaScript can change items and change the contents of items on the fly. In this video; Jamie Campbell demonstrates how to modify HTML elements.
-
Object Properties
Software development using C# allows you to use properties and access objects. In this video; Jamie Campbell explains how to use object properties in a C# program.
-
Referencing HTML Elements
In HTML; you can grab information of the objects by using the different property values. In this video; Jamie Campbell demonstrates how to reference HTML elements.
-
The quickSort Algorithm
During software development; the quickSort algorithm helps you sort all the numbers quickly. In this video; Jamie Campbell explains the quickSort algorithm.
-
Using is and as
Once you master a common set of concepts and methodologies used to create programs; you can develop feature-rich applications for a variety of platforms. In this video; Jamie Campbell demonstrates how to use is and as keywords.
-
Using Override and New
After knowing about software development fundamentals; you can develop feature-rich applications for a variety of platforms. In this video; Jamie Campbell demonstrates how to use override and new in C#.
-
Working with Style Sheets
During software development; you can either put style sheets inside your document or use them as external documents. In this video; Jamie Campbell demonstrates how to work with style sheets.
-
Working with Web Pages
After learning about the fundamentals of software development; you can develop feature-rich applications for a variety of platforms. In this video; Jamie Campbell discusses working with HTML5 to create web pages.
-
Converting Strings to Numbers
In C#; you can add strings to store numerical information and extract its value using one of the various method to use them in mathematical functions. In this video; Jamie Campbell demonstrates how to convert strings to numbers.
-
Creating a Windows Application
You can create a calculator by using the Windows form application and program it using C#. In this video; Jamie Campbell explains how to create a Windows forms application.
-
Creating Tabbed Pages
In Visual Studio; you can use tabbed pages to create multi-document interfaces. In this video; Jamie Campbell demonstrates how to create tabbed pages in Visual Studio.
-
Finishing a Windows Application
When developing software; you need to finish an application before you can package and distribute it to the users. In this video; Jamie Campbell demonstrates how to complete a Windows forms application.
-
How to Create a C# Program
Once you master the software development fundamentals for one language; you can apply the same principles across a variety of platforms and create feature-rich applications. In this video; Jamie Campbell demonstrates how to create and run a basic C# program.
-
How to Create a Drop-Down Menu
When developing software; you need to create drop-down menus for easy layouts and faster data entry. In this video; Jamie Campbell demonstrates how to create drop-down menus in Windows form applications.
-
How to Create a Toolbar
You can create Toolbar for your Windows form application using C#. In this video; Jamie Campbell explains how to create a Toolbar.
-
How to Create a Web Browser
You can create a customized web browser for your Windows form application using C#. In this video; Jamie Campbell explains how to create a web browser.
-
Introduction to C# Strings
String operations are an important part of any programmer's toolkit. In C#; you can use strings to create algorithms. In this video; Jamie Campbell demonstrates how to use string in C# with few examples of basic string operations.
-
Introduction to Conditional Operators
Conditional operators are essential elements of any programming language. In this video; Jamie Campbell explains the different conditional operators in C#.
-
Using Char and Strings
In C#; you can assign index value to the string characters by using the char keyword. In this video; Jamie Campbell demonstrates how to use char keyword with strings in C#.
-
Oriented Programming
During software development; you can use inheritance to draw functionalities from other classes that are already defined. In this video; Jamie Campbell discusses inheritance in object-oriented programming.
-
Catch-Finally Statements
In software development; you can handle exceptions easily with C#. In this video; Jamie Campbell discusses try; catch; and finally statements.
-
JavaScript Functions
In Software Development Fundamentals; you can use JavaScript functions; variables; and attributes. In this video; Jamie Campbell demonstrates how to use JavaScript functions.
-
Layers
The CQRS pattern supports a multi-tier architecture in which related components are grouped into layers that communicate with each other to provide a flexible and reusable application. In this video; Chuck Easttom demonstrates the concept of layers and the functionality of the presentation; business; and data layers within a database application.
-
Services
Services are an integral part of software implementing the CQRS pattern; providing the functionality found in the data access and business layers that allow users to interact with your application. In this video; Chuck Easttom demonstrates the concept of services and how they form part of a larger system by exposing public functions and properties though the different layers.
-
Introduction to Event Handlers
In software development; you can use event handlers to handle an event. In this video; Jamie Campbell discusses event handlers in C#.
-
Queries
In CQRS; queries are built as objects that contain multiple functions for getting different pieces of data. In this video; Chuck Easttom demonstrates how to use queries in CQRS; and provides additional information about query types and best practices.
-
Inline Styles
During software development; Cascading Style Sheets allow you to assign several properties to tags on your HTML pages. In this video; Jamie Campbell demonstrates how to use inline CSS.
-
Queries
The CQRS pattern makes it easy to maintain and optimize queries by returning results without changing the state of an object. In this video; Chuck Easttom discusses the separation between queries and commands; before using a diagram to demonstrate the process of querying a data store and returning results to the user interface with a four-tier CQRS model.
-
When to Use
CQRS can be used in different situations to tackle a range of different problems. In this video; Chuck Easttom discusses how CQRS can be used effectively on collaborative domains.
-
Events
Events are an important part of Command Query Responsibility Segregation (CQRS). In this video; Chuck Easttom demonstrates how CQRS events are ways for a system to respond to a given command; let the user or user application know what happened; and how it happened.
-
Design Considerations
After watching this video; you will be able to identify issues that your design should address.
-
Introduction to Arrays
Understanding the basic programming concepts of software development such as arrays will help you create feature-rich applications across a variety of platforms. In this video; Jamie Campbell explains the concept of Arrays in C#.
-
Commands
Command Query Responsibility Segregation (CQRS) separates commands and queries and implements them in separate structures. In this video; Chuck Easttom demonstrates how CQRS commands are similar in function to a typical architecture; although there are differences. For example; CQRS commands focus on behavior and their reads and queries are separated out.
-
Domain-driven Design: Context Maps
After watching this video, you’ll be able to describe context maps.
-
Domain-driven Design: Core Domain
After watching this video, you’ll be able to describe the purpose of the core domain.
-
Domain-driven Design: Generic Subdomains
After watching this video, you’ll be able to describe the purpose of generic subdomains.
-
Domain-driven Design: Subdomains
After watching this video, you’ll be able to describe subdomains and their purpose.
-
Domain-driven Design: Bounded Contexts
After watching this video, you’ll be able to describe bounded contexts.
-
Domain-driven Design: Knowledge-rich Design
After watching this video, you’ll be able to describe the key aspects of knowledge-rich design.
-
Domain-driven Design: Documents and Diagrams
After watching this video, you’ll be able to describe the uses of documents and diagrams in DDD.
-
Domain-driven Design: Domain Modeling
After watching this video, you’ll be able to describe the key aspects of the domain model in DDD.
-
Domain-driven Design: Domain Experts
After watching this video, you’ll be able to describe the key role of domain experts in DDD.
-
Domain-driven Design: Continuous Learning
After watching this video, you’ll be able to describe the key aspects of continuous learning.
-
Domain-driven Design: Unique Identity
After watching this video, you will be able to define the unique identity attribute.
-
Domain-driven Design: Entity Modeling Best Practices
After watching this video, you will be able to describe best practices for entity modeling.
-
Domain-driven Design: Defining Value Objects
After watching this video, you will be able to describe value objects and characteristics.
-
Domain-driven Design: Implementing Value Objects
After watching this video, you will be able to explain how to implement value objects.
-
Domain-driven Design: Event-driven Architecture
After watching this video, you will be able to describe event-driven architecture.
-
Domain-driven Design: REST
After watching this video, you will be able to describe aspects of representational state transfer and why it's used.
-
Domain-driven Design: CQRS Model
After watching this video, you will be able to describe the CQRS model.
-
Domain-driven Design: Entities in DDD
After watching this video, you will be able to describe entities in DDD.
-
Domain-driven Design: DDD Fundamentals and Components
After watching this video, you’ll be able to recognize the various building blocks and architectures of DDD.
-
Domain-driven Design: DDD Layers
After watching this video, you will be able to recognize the concept of layered architecture in DDD.
-
Domain-driven Design: The DDD Approach
After watching this video, you will be able to describe the DDD approach.
-
Domain-driven Design: DDD Concepts
After watching this video, you will be able to describe DDD, including domains and contexts.
-
Domain-driven Design: DDD Components Defined
After watching this video, you will be able to describe the various components of DDD.
-
Domain-driven Design: Introduction to DDD
After watching this video, you will be able to describe the basic concept of DDD.
-
Domain-driven Design: Knowledge Crunching – Developers
After watching this video, you will be able to describe knowledge crunching from the developer perspective.
-
Domain-driven Design: Knowledge Crunching - Domain Experts
After watching this video, you will be able to describe knowledge crunching from the domain expert’s perspective.
-
Domain-driven Design: Drawbacks of DDD
After watching this video, you will be able to describe the drawbacks of DDD.
-
Domain-driven Design: What DDD Is Not
After watching this video, you will be able to describe the misconceptions of DDD.
-
Domain-driven Design: DDD Knowledge Crunching
After watching this video, you will be able to describe the need for knowledge crunching.
-
Domain-driven Design: Knowledge Crunching Best Practices
After watching this video, you will be able to describe best practices for conducting domain expert interviews.
-
Domain-driven Design: The Domain Model
After watching this video, you will be able to describe the domain model in DDD.
-
Domain-driven Design: Model-driven Design Map
After watching this video, you will be able to describe the model-driven design map.
-
Domain-driven Design: The Benefits of DDD
After watching this video, you will be able to describe the benefits of DDD.
-
Domain-driven Design: The Business Value of DDD
After watching this video, you will be able to describe the business value of DDD.
-
Domain-driven Design: Introduction to Repositories
After watching this video, you will be able to explain repositories and their uses.
-
Domain-driven Design: Introduction to DDD Factories
After watching this video, you will be able to describe factories and how they’re used in DDD.
-
Domain-driven Design: Benefits of Factories
After watching this video, you will be able to describe the benefits of factories.
-
Domain-driven Design: Factory Interface
After watching this video, you will be able to describe the interface of factories.
-
Domain-driven Design: Choosing Factories
After watching this video, you will be able to explain the rationale for choosing factories.
-
Domain-driven Design: Ubiquitous Language
After watching this video, you will be able to describe the use of ubiquitous language in DDD.
-
Domain-driven Design: Communication Best Practices
After watching this video, you will be able to describe best practices for communication in DDD.
-
Domain-driven Design: Modeling and Communication
After watching this video, you will be able to describe the benefits of modeling and communication in DDD.
-
Domain-driven Design: Documenting Communication
After watching this video, you will be able to explain best practices for documenting communication in DDD.
-
Domain-driven Design: Defining Boundaries
After watching this video, you will be able to recognize the domain model boundaries and the effects.
-
Domain-driven Design: The Discovery Process
After watching this video, you will be able to explain the purpose of the discovery process in DDD.
-
Domain-driven Design: Introduction to Behavior-driven Development
After watching this video, you will be able to explain the linkages between Behavior-driven Development and Domain-driven Development.
-
Domain-driven Design: Event Storming
After watching this video, you will be able to describe the use of event storming.
-
Domain-driven Design: Transaction Scripting vs. DDD
After watching this video, you will be able to describe the purposes of transaction scripting vs. DDD.
-
Domain-driven Design: Introduction to Refactoring
After watching this video, you will be able to describe the concept of refactoring.
-
Domain-driven Design: Levels of Refactoring
After watching this video, you will be able to explain the uses and levels of refactoring in DDD.
-
Domain-driven Design: Deep Models
After watching this video, you will be able to explain the concept of deep models in DDD.
-
Domain-driven Design: Supple Design
After watching this video, you will be able to explain the concept of supple design in DDD.
-
Domain-driven Design: Benefits of Repositories
After watching this video, you will be able to explain the benefits of repositories.
-
Domain-driven Design: Relational Databases
After watching this video, you will be able to explain the considerations for using relational databases.
-
Domain-driven Design: Working with Modules
After watching this video, you will be able to recognize the purposes and practices of using modules in DDD.
-
Domain-driven Design: Agile Modules
After watching this video, you will be able to describe the purpose of agile models in DDD.
-
Domain-driven Design: Introduction to Model-driven Design
After watching this video, you will be able to describe the role of model-driven design.
-
Domain-driven Design: Introduction to Domain Events
After watching this video, you will be able to describe domain events and when and why to use them.
-
Domain-driven Design: Domain Events Core Concepts
After watching this video, you will be able to recognize the various core concepts of domain events.
-
Domain-driven Design: Domain Event Handling
After watching this video, you will be able to describe domain event handling.
-
Domain-driven Design: Introduction to Modules
After watching this video, you will be able to describe the role of modules in DDD.
-
Domain-driven Design: Domain Services Introduction
After watching this video, you will be able to define domain services.
-
Domain-driven Design: Using Domain Services
After watching this video, you will be able to explain the domain service within application layer.
-
Domain-driven Design: Services in the Domain Layer
After watching this video, you will be able to explain services in the domain layer.
-
Domain-driven Design: DDD Service Layers
After watching this video, you will be able to describe the use of service layers of DDD.
-
Domain-driven Design: Domain Experts vs. Stakeholders
After watching this video, you will be able to describe the differences between domain experts and stakeholders.
-
Domain-driven Design: Implementing Aggregates
After watching this video, you will be able to demonstrate creating a root entity with aggregates.
-
Domain-driven Design: DDD Concepts and Implementation Models
After watching this video, you will be able to recognize the components of DDD.
-
Domain-driven Design: The Roles of Layers
After watching this video, you will be able to recognize the roles of various layers in the DDD architecture.
-
Domain-driven Design: DDD Layered Architecture
After watching this video, you will be able to recognize the purpose of layered architecture in DDD.
-
Domain-driven Design: Domain-driven vs. Model-driven Design
After watching this video, you will be able to describe the differences and similarities between domain-driven and model-driven design.
-
Domain-driven Design: Introduction to Aggregates
After watching this video, you will be able to describe the role of aggregates.
-
Domain-driven Design: The Benefits of Aggregates
After watching this video, you will be able to describe the benefits of aggregates.
-
Domain-driven Design: Guidelines for Using Aggregates
After watching this video, you will be able to recognize the various guidelines when using aggregates.
-
Domain-driven Design: DDD Design Patterns
After watching this video, you will be able to recognize the concepts of various design patterns in DDD.
