The document discusses domain-driven design (DDD) and how it can be applied to building a solar system simulation using C# 3.0 features. It presents the problem of simulating a solar system with configurable planets and physics-based movement. It then outlines a domain model with entities like Universe, Gravity, and Planet. Finally, it shows how C# 3.0 features like lambda expressions, LINQ queries, extension methods, and events can be used to implement the domain and interface.
This document provides tips and lessons for developers, including stopping focusing on steps and starting pomodoro time blocking, reading email once per day, logging work, reading code, automating tasks, contributing to open source, investigating the past, learning new languages, understanding customers, communicating state, joining communities, and letting others experience your work. It also contains an inappropriate analogy about Java and anal sex.
The document provides 14 lessons for developers, including stopping focusing on steps, investigating the past, learning new languages, not accepting everything, prototyping, automating, understanding customers, reading, speaking the customer's language, backward chaining, modeling, communicating state, joining communities, letting others experience, and being a good audience. It also makes an inappropriate analogy about Java and anal sex.
PHP. Trends, implementations, frameworks and solutionsOleg Zinchenko
油
This document provides an overview of trends in PHP frameworks and implementations. It discusses the popularity of PHP and frameworks like Symfony. It also summarizes various PHP implementations like Zend Engine and HipHopVM. Finally, it briefly outlines several Symfony products and applications like Sylius, Vespolina and Akeneo.
This document discusses frontend validation in Symfony applications. It introduces the UberFrontendValidationBundle which adds validation constraints and error messages to form fields on the frontend. The bundle works by rendering additional HTML5 attributes on fields containing validation data. This allows validating fields on the frontend before form submission using JavaScript.
Keep It Simple Security (Symfony cafe 28-01-2016)Oleg Zinchenko
油
This document contains code snippets related to implementing WSSE authentication in Symfony. It includes code for a WSSE token, listener, authentication manager/provider, and factory class. The token holds user details extracted from the HTTP header. The listener extracts credentials from the header and passes them to the manager. The manager authenticates by validating the credentials against the user provider. The factory registers these classes with the security component. The document also mentions voters and ACL as other Symfony security topics.
You've seen Kris' open source libraries, but how does he tackle coding out an application? Walk through green fields with a Symfony expert as he takes his latest next big thing idea from the first line of code to a functional prototype. Learn design patterns and principles to guide your way in organizing your own code and take home some practical examples to kickstart your next project.
This document summarizes a talk about using Domain-Driven Design patterns and principles when developing applications with the Symfony framework. It discusses where to store business logic in an MVC application, avoiding anemic domain models by putting logic in entities. It provides examples of domain models, repositories, value objects, and strategies when building a Symfony application with DDD in mind. Finally, it outlines common DDD patterns and principles and recommends resources for further reading on the topic.
Unleash Your Domain With Greg Young @ DDD-DayDotNetMarche
油
The document discusses modeling domains and distributed systems. It recommends explicitly representing state transitions in domains. It also advocates separating commands from queries, using asynchronous context mapping, and storing events. Most queries and interactions between bounded contexts can tolerate relaxed consistency for improved scalability and availability. The domain model may differ from the client data model for screens. Getters and setters are considered an anti-pattern for domains.
The document discusses upcoming features in ECMAScript/JavaScript including ES6 features like arrow functions, classes, modules, and new data types. It also discusses potential future features like observable objects, SIMD intrinsics, and value objects to represent numeric types like int64 and decimal. The document proposes an approach to overloading operators for value objects using cacheable multimethods instead of double dispatch to avoid issues and maintain composability of types.
If you have used Facebook's React library, then you are familiar with the concept of application state. React components are, at their core (and as noted in the official documentation), simple state machines. This declarative approach to building a UI may take some adjusting to, but it ultimately simplifies kludgy imperative code into smaller, much more manageable pieces.
This pattern of manipulating state and responding to those changes can be implemented to great effect using the Symfony Event Dispatcher. This talk will step through this state-based approach to building an easily maintained and testable PHP application, tease out a few gotchas, and share real-world applications.
DDD on example of Symfony (Webcamp Odessa 2014)Oleg Zinchenko
油
This document discusses Domain-Driven Design (DDD) patterns and principles using PHP and the Symfony framework as examples. It introduces key DDD concepts like the domain model, repositories, value objects, and strategies. It also outlines common layer structures and provides references to additional DDD resources.
Applying Domain-Driven Design to APIs and Microservices - Austin API MeetupLaunchAny
油
This document discusses applying domain-driven design principles to API and microservices architecture. It recommends using an outside-in design approach where the data model is separate from the object model and resource model. Domain-driven design helps identify context boundaries, and microservices require renewed focus on system and API design. Modeling the domain entities, relations, states and events defines the resources exposed by each API. This modular design increases composability and the ability to replace services over time.
Enterprise PHP: mappers, models and servicesAaron Saray
油
One of the greatest failures PHP has is not that it is a bad language, but that it isn't marketed as a good language. Since it's so easy to do it bad, a lot of people do just that. However, there is hope. Businesses ARE using PHP for Enterprise! You just need to apply a solid foundation to the language to get to that Enterprise level.
With our mind on the Enterprise sphere, it's time to take PHP programming to a more advanced level. To get the most out of this talk, you should already be familiar with object oriented programming concepts in PHP. To begin with, I'll talk about the need for a service layer, data mappers, and business object models. Then I'll demonstrate examples of how to do it right. As an added bonus, I'm not going to just tell you why it's best practice and a "good idea" - I'm going to SHOW you. This might be the first time in your life that you realize that changes in architecture, supporting infrastructure, and business requirements don't have to be as painful as you once thought!
O documento discute Domain-Driven Design (DDD), abordando conceitos como linguagem ub鱈qua, modelagem orientada a dom鱈nio, blocos de constru巽達o como entidades e objetos de valor. Exemplifica como esses conceitos podem ser aplicados na pr叩tica ao modelar uma camada de dom鱈nio com classes como Product, Currency e Money.
This document discusses concepts related to domain-driven design including value objects, entities, identity, aggregate roots, validation, repositories, services, and domain-driven architecture. It provides examples of a student entity and domain model, discusses validatable vs invariant objects, and debates the pros and cons of including service layers. It also provides an overview of different approaches to domain-driven design bootstrapping including layering the domain, services, and data access.
This document provides an overview of design challenges and examples of designing in small domains. Some key points:
1. It discusses common reasons why design fails, such as lack of domain expertise, communication, or time for design up front.
2. It presents examples of designing value objects like GroupId and GroupName to encapsulate behavior and validation related to those concepts.
3. It shows how behaviors can be modeled through modules that handle commands and events related to a domain, like starting a private group.
4. Testing examples demonstrate state-based, event-driven, and scenario-based approaches using fixtures to generate random test data.
5. Overall it promotes designing domains with primitives/
The document discusses projections in event sourcing, including terminology, designing projections, authoring projections, and testing projections. Projections transform event data stored in an event log into read models optimized for querying. The document covers topics like defining projection handlers, dispatching events to handlers, and testing projections with sample events.
Domain-driven design is a collaborative process involving both domain experts and software practitioners. This high-level overview takes a look at the driving principles behind domain-driven design. It also explores domain-driven design's building block patterns, supple design, strategic design, and distillation of the core.
This document provides an introduction and overview of CQRS (Command Query Responsibility Segregation). It discusses typical N-layer architectures and how CQRS changes the architecture by separating read and write operations. The key points are that CQRS moves the system from an N-layer to separating read and write concerns, with commands handling changes, events capturing changes, and read models optimized for queries and kept in sync with events. The document outlines the full flow from commands to events to updating read models and queries against the read models.
The document discusses CQRS (Command Query Responsibility Segregation), an architectural pattern that separates read and write operations into different models. It outlines the benefits of CQRS such as encapsulating domain logic, optimized querying, and improved testability and auditing. The key aspects of CQRS covered include commands, events, read models, write models, and event sourcing. While CQRS has advantages, it also has learning challenges and overhead for simple applications. Food for thought questions are also raised about requirements, outsourcing, and database administration with this pattern.
Introduction to CQRS - command and query responsibility segregationAndrew Siemer
油
A high level introduction to CQRS (command and query responsibility segregation), CQS (command query separation), DDD (domain driven design), DDD-D ...with distributed, and how all those weave together.
Enterprise PHP Architecture through Design Patterns and Modularization (Midwe...Aaron Saray
油
Object Oriented Programming in enterprise level PHP is incredibly important. In this presentation, concepts like MVC architecture, data mappers, services, and domain and data models will be discussed. Simple demonstrations will be used to show patterns and best practices. In addition, using tools like Doctrine or integration with Salesforce or the AS/400 will also be discussed. There will be an emphasis on the practical application of these techniques as well - this isn't just a theoretical talk! This presentation is great for those just beginning to create enterprise applications as well as those who have had years of experience.
Cette pr辿sentation d辿crit un concept architecture qui n'est pas nouveau, la s辿paration des commande et des requ棚te et un autre les 辿v辿nements comme source d'information.
Ensemble ils forment un duo imbattable pour d辿velopper des application performantes et robustes.
This document discusses frontend validation in Symfony applications. It introduces the UberFrontendValidationBundle which adds validation constraints and error messages to form fields on the frontend. The bundle works by rendering additional HTML5 attributes on fields containing validation data. This allows validating fields on the frontend before form submission using JavaScript.
Keep It Simple Security (Symfony cafe 28-01-2016)Oleg Zinchenko
油
This document contains code snippets related to implementing WSSE authentication in Symfony. It includes code for a WSSE token, listener, authentication manager/provider, and factory class. The token holds user details extracted from the HTTP header. The listener extracts credentials from the header and passes them to the manager. The manager authenticates by validating the credentials against the user provider. The factory registers these classes with the security component. The document also mentions voters and ACL as other Symfony security topics.
You've seen Kris' open source libraries, but how does he tackle coding out an application? Walk through green fields with a Symfony expert as he takes his latest next big thing idea from the first line of code to a functional prototype. Learn design patterns and principles to guide your way in organizing your own code and take home some practical examples to kickstart your next project.
This document summarizes a talk about using Domain-Driven Design patterns and principles when developing applications with the Symfony framework. It discusses where to store business logic in an MVC application, avoiding anemic domain models by putting logic in entities. It provides examples of domain models, repositories, value objects, and strategies when building a Symfony application with DDD in mind. Finally, it outlines common DDD patterns and principles and recommends resources for further reading on the topic.
Unleash Your Domain With Greg Young @ DDD-DayDotNetMarche
油
The document discusses modeling domains and distributed systems. It recommends explicitly representing state transitions in domains. It also advocates separating commands from queries, using asynchronous context mapping, and storing events. Most queries and interactions between bounded contexts can tolerate relaxed consistency for improved scalability and availability. The domain model may differ from the client data model for screens. Getters and setters are considered an anti-pattern for domains.
The document discusses upcoming features in ECMAScript/JavaScript including ES6 features like arrow functions, classes, modules, and new data types. It also discusses potential future features like observable objects, SIMD intrinsics, and value objects to represent numeric types like int64 and decimal. The document proposes an approach to overloading operators for value objects using cacheable multimethods instead of double dispatch to avoid issues and maintain composability of types.
If you have used Facebook's React library, then you are familiar with the concept of application state. React components are, at their core (and as noted in the official documentation), simple state machines. This declarative approach to building a UI may take some adjusting to, but it ultimately simplifies kludgy imperative code into smaller, much more manageable pieces.
This pattern of manipulating state and responding to those changes can be implemented to great effect using the Symfony Event Dispatcher. This talk will step through this state-based approach to building an easily maintained and testable PHP application, tease out a few gotchas, and share real-world applications.
DDD on example of Symfony (Webcamp Odessa 2014)Oleg Zinchenko
油
This document discusses Domain-Driven Design (DDD) patterns and principles using PHP and the Symfony framework as examples. It introduces key DDD concepts like the domain model, repositories, value objects, and strategies. It also outlines common layer structures and provides references to additional DDD resources.
Applying Domain-Driven Design to APIs and Microservices - Austin API MeetupLaunchAny
油
This document discusses applying domain-driven design principles to API and microservices architecture. It recommends using an outside-in design approach where the data model is separate from the object model and resource model. Domain-driven design helps identify context boundaries, and microservices require renewed focus on system and API design. Modeling the domain entities, relations, states and events defines the resources exposed by each API. This modular design increases composability and the ability to replace services over time.
Enterprise PHP: mappers, models and servicesAaron Saray
油
One of the greatest failures PHP has is not that it is a bad language, but that it isn't marketed as a good language. Since it's so easy to do it bad, a lot of people do just that. However, there is hope. Businesses ARE using PHP for Enterprise! You just need to apply a solid foundation to the language to get to that Enterprise level.
With our mind on the Enterprise sphere, it's time to take PHP programming to a more advanced level. To get the most out of this talk, you should already be familiar with object oriented programming concepts in PHP. To begin with, I'll talk about the need for a service layer, data mappers, and business object models. Then I'll demonstrate examples of how to do it right. As an added bonus, I'm not going to just tell you why it's best practice and a "good idea" - I'm going to SHOW you. This might be the first time in your life that you realize that changes in architecture, supporting infrastructure, and business requirements don't have to be as painful as you once thought!
O documento discute Domain-Driven Design (DDD), abordando conceitos como linguagem ub鱈qua, modelagem orientada a dom鱈nio, blocos de constru巽達o como entidades e objetos de valor. Exemplifica como esses conceitos podem ser aplicados na pr叩tica ao modelar uma camada de dom鱈nio com classes como Product, Currency e Money.
This document discusses concepts related to domain-driven design including value objects, entities, identity, aggregate roots, validation, repositories, services, and domain-driven architecture. It provides examples of a student entity and domain model, discusses validatable vs invariant objects, and debates the pros and cons of including service layers. It also provides an overview of different approaches to domain-driven design bootstrapping including layering the domain, services, and data access.
This document provides an overview of design challenges and examples of designing in small domains. Some key points:
1. It discusses common reasons why design fails, such as lack of domain expertise, communication, or time for design up front.
2. It presents examples of designing value objects like GroupId and GroupName to encapsulate behavior and validation related to those concepts.
3. It shows how behaviors can be modeled through modules that handle commands and events related to a domain, like starting a private group.
4. Testing examples demonstrate state-based, event-driven, and scenario-based approaches using fixtures to generate random test data.
5. Overall it promotes designing domains with primitives/
The document discusses projections in event sourcing, including terminology, designing projections, authoring projections, and testing projections. Projections transform event data stored in an event log into read models optimized for querying. The document covers topics like defining projection handlers, dispatching events to handlers, and testing projections with sample events.
Domain-driven design is a collaborative process involving both domain experts and software practitioners. This high-level overview takes a look at the driving principles behind domain-driven design. It also explores domain-driven design's building block patterns, supple design, strategic design, and distillation of the core.
This document provides an introduction and overview of CQRS (Command Query Responsibility Segregation). It discusses typical N-layer architectures and how CQRS changes the architecture by separating read and write operations. The key points are that CQRS moves the system from an N-layer to separating read and write concerns, with commands handling changes, events capturing changes, and read models optimized for queries and kept in sync with events. The document outlines the full flow from commands to events to updating read models and queries against the read models.
The document discusses CQRS (Command Query Responsibility Segregation), an architectural pattern that separates read and write operations into different models. It outlines the benefits of CQRS such as encapsulating domain logic, optimized querying, and improved testability and auditing. The key aspects of CQRS covered include commands, events, read models, write models, and event sourcing. While CQRS has advantages, it also has learning challenges and overhead for simple applications. Food for thought questions are also raised about requirements, outsourcing, and database administration with this pattern.
Introduction to CQRS - command and query responsibility segregationAndrew Siemer
油
A high level introduction to CQRS (command and query responsibility segregation), CQS (command query separation), DDD (domain driven design), DDD-D ...with distributed, and how all those weave together.
Enterprise PHP Architecture through Design Patterns and Modularization (Midwe...Aaron Saray
油
Object Oriented Programming in enterprise level PHP is incredibly important. In this presentation, concepts like MVC architecture, data mappers, services, and domain and data models will be discussed. Simple demonstrations will be used to show patterns and best practices. In addition, using tools like Doctrine or integration with Salesforce or the AS/400 will also be discussed. There will be an emphasis on the practical application of these techniques as well - this isn't just a theoretical talk! This presentation is great for those just beginning to create enterprise applications as well as those who have had years of experience.
Cette pr辿sentation d辿crit un concept architecture qui n'est pas nouveau, la s辿paration des commande et des requ棚te et un autre les 辿v辿nements comme source d'information.
Ensemble ils forment un duo imbattable pour d辿velopper des application performantes et robustes.
Mobile Monday Kiev#1 - How to save time in Mobile Apps DevelopmentIntersog
油
Intersog acted as a general partner of relaunched Mobile Monday (MoMo) event in Ukraine that took place in Kyiv on June 25, 2015. See the top moments from Mobile Monday Kyiv #1!
MoMo is a global platform for IT knowledge sharing and professional networking that is currently being active in 140+ cities worldwide. MoMo offers different networking formats aimed to enhance public knowledge of the most trending mobility topics and innovation. Read more and join Mobile Monday: http://intersog.com/news/intersog-helps-relaunch-mobile-monday-ukraine/