Adding content to 108-enterprise-patterns

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/100-dtos.md

@@ -1 +1,7 @@
-# Dtos
+# DTOs
+
+The Data Transfer Object Design Pattern is one of the enterprise application architecture patterns that calls for the use of objects that aggregate and encapsulate data for transfer. A Data Transfer Object is, essentially, like a data structure. It should not contain any business logic but should contain serialization and deserialization mechanisms.
+
+Learn more from the following links:
+
+- [Data Transfer Object pattern and Mappers](https://medium.com/@abdalrhmanalkraien/data-transfer-object-pattern-and-mapper-116508bc9df0)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/101-identity-maps.md

@@ -1 +1,8 @@
-# Identity maps
+# Identity Maps
+
+
+
+Learn more from the following links:
+
+- [Overview of Identity map pattern](https://en.wikipedia.org/wiki/Identity_map_pattern)
+- [Tutorial - Identity Map Design Pattern](youtube.com/watch?v=erDxkIyNudY)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/102-use-cases.md

@@ -1 +1,7 @@
-# Use cases
+# Use Cases
+
+
+
+Learn more from the following links:
+
+- [Use Case Patterns](https://caminao.blog/how-to-implement-symbolic-representations/patterns/functional-patterns/use-case-patterns/)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/103-repositories.md

@@ -1 +1,8 @@
-# Repositories
+# Repositories
+
+
+
+Learn more from the following links:
+
+- [Tutorial - Repository Design Pattern](https://www.youtube.com/watch?v=mb6bwnEaZ3U)
+- [Introduction to Repository Design Patterns](https://cubettech.com/resources/blog/introduction-to-repository-design-pattern/)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/104-mappers.md

@@ -1 +1,8 @@
-# Mappers
+# Mappers
+
+
+
+Learn more from the following links:
+
+- [Overview of Data Mapper Pattern](https://en.wikipedia.org/wiki/Data_mapper_pattern)
+- [Tutorial - Mappers](https://www.youtube.com/watch?v=7noMLStHcTE)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/105-transaction-script.md

@@ -1 +1,8 @@
-# Transaction script
+# Transaction Script
+
+Transaction Script is a pattern used in enterprise application development that organizes business logic into a single procedural script. It is often used for simple CRUD (create, read, update, delete) operations, where all of the logic for a specific transaction is contained in a single script or function. This pattern is simple to implement and easy to understand, but can become unwieldy as the complexity of the application increases. Alternative patterns such as Domain-Driven Design (DDD) and the Active Record pattern may be more appropriate for more complex applications.
+
+Learn more from the following links:
+
+- [Transaction Script Pattern](https://gunnarpeipman.com/transaction-script-pattern/)
+- [Tutorial - Transaction Script Design Pattern](https://www.youtube.com/watch?v=fnsU9cqcY3I)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/106-commands-queries.md

@@ -1 +1,9 @@
-# Commands queries
+# Commands Queries
+
+The Command and Query Responsibility Segregation (CQRS) pattern is a technique used in enterprise application development to separate the responsibilities of handling command (write) operations and query (read) operations for performing actions that change the state of the system, such as creating, updating, or deleting data. These operations are handled by Command Handlers, which are responsible for validating the data and executing the appropriate business logic.
+
+Queries are used for retrieving data from the system, such as reading data from a database or a cache. These operations are handled by Query Handlers, which are responsible for executing the appropriate query and returning the data to the caller.
+
+Learn more from the following links:
+
+- [Get Started with CQRS Pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/107-value-objects.md

@@ -1 +1,10 @@
-# Value objects
+# Value Objects
+
+Value Objects are a pattern used in enterprise application development to represent simple, immutable values that are used to model domain concepts. They are typically used to encapsulate data that is not an entity, but is important to the domain.
+
+A Value Object is defined by its value rather than its identity, meaning that two Value Objects with the same value are considered to be equal, regardless of their identity.
+
+Learn more from the following links:
+
+- [Overview - Implement Value Objects](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/implement-value-objects)
+- [Intro to Value object](https://en.wikipedia.org/wiki/Value_object)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/108-domain-models.md

@@ -1 +1,10 @@
-# Domain models
+# Domain Models
+
+Domain Models are a pattern used in enterprise application development to represent the business concepts and rules of a specific domain. They are typically used to model the problem domain, or the area of expertise of a specific business.
+
+A Domain Model is a collection of objects that represent the real-world concepts and entities of the domain. These objects are typically modeled as classes or types, and they encapsulate the data and behavior that is specific to the domain. They are responsible for representing the state and behavior of the business concepts they model, and for enforcing the rules and constraints of the domain.
+
+Learn more from the following links:
+
+- [Overview - Domain Models](https://sparxsystems.com/enterprise_architect_user_guide/14.0/model_domains/specialized_models.html)
+- [Tutorial - Domain Model Pattern](https://www.youtube.com/watch?v=75EGANiqADw)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/109-entities.md

@@ -1 +1,5 @@
-# Entities
+# Entities
+
+Entities are a pattern used in enterprise application development to represent the business concepts that have a unique identity and a lifetime. They are typically used to model real-world objects or concepts that have a distinct identity and a lifecycle, such as a customer, an order, or an account.
+
+An Entity is defined by its identity, meaning that two entities with the same identity are considered to be the same, regardless of their state. Entities usually have a unique identifier, such as a primary key, that is used to identify them. They also have an associated set of properties or attributes that describe their state.

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/110-orms.md

@@ -1 +1,9 @@
-# Orms
+# Orms
+
+ORM stands for Object-Relational Mapping, it is a technique used in enterprise application development to map between the object-oriented programming model and the relational database model. It allows developers to work with objects in their code, while the ORM tool takes care of translating those objects into the appropriate database operations.
+
+ORMs are designed to abstract away the complexity of working with a relational database and allow developers to interact with the database using a higher-level, object-oriented API. They provide a set of libraries and tools that map the objects in the code to the tables and rows in the database, and vice versa. This allows developers to work with the data using a familiar object-oriented paradigm, rather than having to write complex SQL queries.
+
+Learn more from the following links:
+
+- [Why do you need an ORM?](https://enterprisecraftsmanship.com/posts/do-you-need-an-orm/)

src/roadmaps/software-design-architecture/content/108-enterprise-patterns/index.md

@@ -1 +1,18 @@
-# Enterprise patterns
+# Enterprise Patterns
+
+Enterprise patterns are a set of design patterns that are commonly used in the development of enterprise software applications. These patterns provide a common vocabulary and a set of best practices for solving common problems that arise in the development of large, complex software systems. Some examples of enterprise patterns include:
+
+- Domain-Driven Design (DDD)
+- Model-View-Controller (MVC)
+- Service Oriented Architecture (SOA)
+- Command and Query Responsibility Segregation (CQRS)
+- Event Sourcing
+- Microservices
+- Event-Driven Architecture (EDA)
+
+These patterns can help to improve the maintainability and scalability of the software, by providing a clear separation of concerns and allowing for a more modular and flexible architecture.
+
+Learn more from the following links:
+
+- [Software Architecture Patterns in Enterprise Software](https://blog.devgenius.io/10-software-architecture-patterns-in-enterprise-software-development-fabacb5ed0c8)
+- [What are Enterprise Integration Patterns?](https://www.youtube.com/watch?v=WNm3QmJadNs)

src/roadmaps/software-design-architecture/content/index.md

@@ -1 +1,18 @@
-# 
+# Software Design Architecture
+
+Software design architecture is the process of defining the overall structure and organization of a software system. It involves determining the components, interfaces, and relationships between those components that are needed to meet the requirements of the system. The architecture of a software system sets the foundation for the design and implementation of the system, and it plays a crucial role in determining the quality and maintainability of the final product.
+
+There are several different architecture styles and patterns that can be used to design a software system, including:
+
+- Layered architecture
+- Microservices architecture
+- Event-driven architecture
+- Service-oriented architecture (SOA)
+- Domain-Driven Design (DDD)
+
+Each architecture pattern or style has its own set of advantages and disadvantages, and the choice of architecture will depend on the specific requirements of the system and the constraints of the project.
+
+Learn more from the following links:
+
+- [Software Architecture & Design Introduction](https://www.tutorialspoint.com/software_architecture_design/introduction.htm)
+- [Overview of Software architecture](https://en.wikipedia.org/wiki/Software_architecture)