Introduction to (n)CQRS

Jan 7, 2011Download as PPTX, PDF0 likes314 views

Wprowadzenie do CQRSBecause things need to be

CQRS (Command Query Responsibility Segregation) é uma abordagem para construir software altamente eficiente, escalável e de fácil manutenção. No entanto, os primeiros passos neste conceito não são fáceis. DDD, Event Sourcing, Cache, Eventual Consistency ou Service Bus são apenas alguns exemplos de conceitos que nos são sugeridos sempre que pesquisamos sobre CQRS. Toda esta avalanche de informação contribui para que seja difícil adotar este conceito. Mas CQRS será realmente tudo isto? É preciso dominar todos estes conceitos para o implementar? Esta sessão vai ajudar-te a encontrar uma resposta para estas perguntas, a ter uma noção mais clara de quando se aplica e de como podes dar os primeiros passos para implementar este principio.

The Power Of SPA - ISCTEMonica Rodrigues

��

The document discusses single page applications (SPAs) and their advantages over traditional multi-page applications. It notes that SPAs allow users to view and interact with content without page reloads, improving the user experience. SPAs separate client and server responsibilities, can be made to work offline, and are responsive across devices. Popular JavaScript frameworks that can be used to build SPAs are presented, along with examples and demos.

Como tudo começouMonica Rodrigues

��

Este documento conta a história da autora desde que terminou o ensino secundário até à sua carreira atual como engenheira de software. Ela começou por gostar de matemática e foi estudar engenharia informática, tendo dificuldades no primeiro semestre mas acabando por se apaixonar pela programação. Após terminar o curso, trabalhou em várias empresas onde foi ganhando experiência em novas tecnologias como Flex, PHP, ASP.NET e Angular. Atualmente trabalha como consultora e aconselha os leitores a

Relax, it's spa timeMonica Rodrigues

��

Solid principlesMonica Rodrigues

��

This document discusses the SOLID principles of object-oriented design: - The Single Responsibility Principle states that a class should have one, and only one, reason to change. - The Open/Closed Principle specifies that software entities should be open for extension but closed for modification. - The Liskov Substitution Principle dictates that subclasses should behave in the same way as their parent classes. - The Interface Segregation Principle indicates that client classes should not depend on interfaces they do not use. - The Dependency Inversion Principle asserts that high-level modules should not depend on low-level modules, but both should depend on abstractions. The presentation provides examples of

Modelos Mentais em 10 minutosMonica Rodrigues

��

Actor ModelPieter Joost van de Sande

��

This document provides an overview of the actor model for concurrency. It discusses some key concepts like messages, actors that can send messages, create other actors, and change behavior. It describes issues with shared state concurrency and how the actor model addresses this by avoiding shared state. Actors communicate asynchronously by message passing and have location transparency. The document uses examples of money transfers between bank accounts to illustrate how this can be done safely and efficiently with the actor model compared to traditional shared state approaches. It also discusses capabilities like supervisor hierarchies and managed references in actor systems.

MicroservicesPieter Joost van de Sande

��

This document discusses microservices architecture and principles. It notes that a monolithic design leads to tight coupling that prevents independent scaling of modules. Microservices architecture aims to allow individual parts of a system to scale independently through looser coupling, autonomous services, and clear separation of concerns. Key principles for microservices include that they should be independently deployable, communicate through events and APIs, and that each service handle a specific task rather than representing an entire business entity.

MicroservicesPieter Joost van de Sande

��

This document discusses microservices architecture. It begins by outlining challenges with monolithic systems, such as everything failing if one part fails and inability to scale the database. The goals of microservices are then presented as scaling individual parts, reducing hardware costs, eliminating expensive support contracts, and allowing quick evaluation of new ideas. Several inspirations for microservices are cited from the 1960s onward. Key principles discussed include having independent, loosely coupled services that communicate through clean interfaces. The document also covers event storming, autonomous components, and other microservices patterns and best practices.

Werckers path to GoPieter Joost van de Sande

��

The document discusses Wercker's experience with adopting the Go programming language. It describes how Wercker was initially excited by Go's design goals for building mission critical systems at scale. Go was easy to set up and had built-in support for testing. However, Wercker also encountered challenges with Go's package management and its unfriendliness to code forking. Overall though, Wercker found that Go was a good fit despite some downsides.

Lessons for developers - long editionPieter Joost van de Sande

��

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.

Introduction to CQRSPieter Joost van de Sande

��

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.

Lessons for developersPieter Joost van de Sande

��

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.

Rethink your architecture with CQRSPieter Joost van de Sande

��

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.

Domain Driven Design fundamentalsPieter Joost van de Sande

��

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.

Introduction to Spec#Pieter Joost van de Sande

��

This document provides an overview of Spec#, a programming language extension developed by Microsoft Research that allows developers to add formal specifications and contracts to .NET programs. Some key points: - Spec# adds preconditions, postconditions, and object invariants that define contracts between method implementations and callers. These specifications can be checked to find errors. - It supports Visual Studio and emits checks to downstream tools like Boogie to perform formal verification of Spec# programs. - Spec# aims to eliminate null reference errors by distinguishing non-null (!) and possibly null (?) reference types and enforcing these properties. - Examples are provided showing how method specifications, modifiers, and object invariants are defined in Spec#

C#, What Is Next?Pieter Joost van de Sande

��

XNA presentationPieter Joost van de Sande

��

Domain Driven Design In C#3.0Pieter Joost van de Sande

��

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.