Great technologies, programming languages and tools are used when building software. That is good and right. But unfortunately, it is often lost sight of the fact that the decisive factor is not the technology, but the *business domain*. If we do not map the domain language and the business processes in the software, then it will not help our users in their work. No technology in the world can protect us from this.
In this talk, I'll show you how you can identify problems in an existing legacy system that could be solved with Domain-Driven Design. We will see problems such as: large entities that are used all over the system, how we could divide them into smaller entities according to the business domain and how we should cut the source code into bounded contexts. All this will be done with many examples from analysis tools that help us to see the system on the level above the source code.
Fiddler is a free web debugging proxy that monitors and manipulates HTTP/HTTPS traffic between a computer and the Internet. It can inspect traffic, set breakpoints, and modify requests and responses. Fiddler functions as a reverse proxy by capturing and reconstructing messages passing through it. This allows developers to debug web applications, analyze performance issues, and test servers. It supports common protocols and can debug services running as Windows services. Fiddler is extensible through scripting and has use cases for traffic inspection, performance analysis, debugging, and testing.
- Properly using parallel DML (PDML) for ETL can improve performance by leveraging multiple CPUs/cores.
- To enable PDML, it must be enabled at the system, session, or statement level. Additional steps may be needed to ensure the optimizer chooses a parallel plan.
- Considerations for using PDML include available parallel servers, restrictions like triggers or foreign keys, and implications on transactions.
- Oracle has different methods for data loading in PDML like HWM, TSM, and HWMB that impact extent allocation and fragmentation.
- The PQ_DISTRIBUTE hint controls how rows are distributed among parallel servers during the load to optimize performance and scalability.
Modern Perl web development has evolved over the past 20 years. While Perl was once widely used for web development via CGI scripts, newer technologies emerged that were easier to maintain. The document discusses how Perl is still suitable for web development using modern tools like PSGI, Plack, Dancer2, and others. It demonstrates building a basic TODO application in Perl using these tools, including generating database classes from an existing database, retrieving and displaying data, and adding features with JavaScript and jQuery.
Fiddler is a free web debugging proxy that monitors and manipulates HTTP/HTTPS traffic between a computer and the Internet. It can inspect traffic, set breakpoints, and modify requests and responses. Fiddler functions as a reverse proxy by capturing and reconstructing messages passing through it. This allows developers to debug web applications, analyze performance issues, and test servers. It supports common protocols and can debug services running as Windows services. Fiddler is extensible through scripting and has use cases for traffic inspection, performance analysis, debugging, and testing.
- Properly using parallel DML (PDML) for ETL can improve performance by leveraging multiple CPUs/cores.
- To enable PDML, it must be enabled at the system, session, or statement level. Additional steps may be needed to ensure the optimizer chooses a parallel plan.
- Considerations for using PDML include available parallel servers, restrictions like triggers or foreign keys, and implications on transactions.
- Oracle has different methods for data loading in PDML like HWM, TSM, and HWMB that impact extent allocation and fragmentation.
- The PQ_DISTRIBUTE hint controls how rows are distributed among parallel servers during the load to optimize performance and scalability.
Modern Perl web development has evolved over the past 20 years. While Perl was once widely used for web development via CGI scripts, newer technologies emerged that were easier to maintain. The document discusses how Perl is still suitable for web development using modern tools like PSGI, Plack, Dancer2, and others. It demonstrates building a basic TODO application in Perl using these tools, including generating database classes from an existing database, retrieving and displaying data, and adding features with JavaScript and jQuery.
The document discusses monolithic architecture and different types of monoliths. It argues that a physical monolith is often the best initial approach and that problems typically arise from logical monoliths that lack clear boundaries. A modular monolith is proposed as an optimal architecture, with distinct modules but a shared codebase and deployment. The document also covers techniques for implementing modular monoliths, such as defining module boundaries, startup classes per module, and routing.
Reactive Microservice Architecture with Groovy and GrailsSteve Pember
Steve Pember gave a presentation on reactive oriented architecture with Grails and Groovy. He discussed some key points:
1. Monolithic applications will not scale well as they grow in complexity, which can negatively impact development and maintenance.
2. Service oriented architecture (SOA) and microservices can help break applications into independent components, but SOA implementations have issues like increased complexity from interconnected services.
3. Architecture choices are more important than any specific framework. Microservices aim to distill SOA principles by focusing each component on a single context to reduce complexity.
Do you have a monolith? If so, is it majestic? Or is it broken and preventing you from scaling your application and your business?
Monoliths have earned a bad reputation in software architecture design circles for being difficult to maintain and operating on silos of knowledge. However, they aren't all bad. The key is knowing when to use a monolith, and when it is time re-factor and scale up by going small.
Elastically scalable architectures with microservices. The end of the monolith?Javier Arias Losada
In the last years the microservices architecture style has been gaining traction with some companies such as Netflix, Yelp, Gilt, PayPal. Many of that companies abandoned their previous monolithic architecture and moved to a microservices approach.
Does that mean that monolithic architectures are a thing of the past?
In this talk we will review some key microservices concepts (and misconceptions), search for the essence of microservices architectures and discuss about different approaches to implement them from the industry.
What if the reason everyone seems so anti-LMS is that they are not structured correctly? LMS design, as one large single system, is setup to fail the OER community. MOOCs are at least a push in the right direction, but their frameworks are often closed, discouraging open development. If we had truly open, community driven platform for the creation of educational resources, we might see more truly OER materials being created.
This is the position ELMS Learning Network (ELMSLN) takes in its approach to edtech design. ELMSLN takes the major functionality of an LMS and spreads it out across a suite of open source tools. The experience is glued together by single-sign-on technologies like LTI to enable the best system selection for the job without sacrificing user experience.
These tools a built on a framework that includes other open systems such as Drupal and Piwik. Piwik allows for a Google analytics style framework but open source and data is hosted with whoever is utilizing it. This can used both for tracking and general data about students, or for statistical analysis of how effective OER are in reaching different global audiences.
Drupal 7, is a highly flexible yet complex CMS used to power high scale development projects. While Drupal is traditionally difficult to work with, ELMSLN packages it up in such a way that's easy both for code developers and content authors to understand. What it brings with it is a community of experts authoring functionality that can all be utilized to deliver courses and OER. The best part is that by aligning with this community, ELMSLN has access to the knowledge and expertise of thousands of contributed modules and highly trained developers who don't need to have any understanding of edtech in order to help improve it!
ELMSLN also comes packaged with support for LTI 1.0 provider capabilities for integration with current LMS offerings. This enables faculty at existing universities and colleges to keep their materials outside the LMS, yet still securely pass their traditional students through to their content seamlessly. ELMSLN's networked approach to edtech development, can allow OER material to reside in one toolset (out in the open) without fear of opening oneself up to PII or FERPA violations.
Part of the resistance to OER production is the technical and privacy barriers to participation, which are at the heart of how ELMSLN has been constructed. Attendees will walk away with a sense of the transformative nature of Drupal, who's using ELMSLN and how to get involved.
It's easy to say... Microservices! Reality is we need to learn and apply concepts coming from many disciplines like SOA, EDA and DDD just to name a few! Mix them with some ALM and technical processes around Packaging and Deploying... and maybe then you get a true Microservices solution.
This lecture discusses challenges in building enterprise applications and provides advice. It recommends starting simply and evolving designs over time. Complex systems designed from scratch never work, so layering, clear interfaces, and minimizing dependencies are important. Frameworks and design patterns help manage complexity but shouldn't dictate design. Practical considerations include avoiding unnecessary complexity and refactoring when needed.
This document discusses various heuristics and principles for architecture design. It provides guidelines for creating simplified, evolvable systems using small modular components. Some key points discussed include using open architectures, building in options, and designing structures that are resilient to stress. The document also advocates for pattern-oriented, minimalist designs and evolutionary systems that can adapt over time without disrupting existing information. Overall, the document presents best practices for handling complexity, enabling flexibility, and ensuring architectures can withstand failures.
Slides for my keynote at incontrodevops.it, where I talked about distributed architectures, microservices, kubernetes and cloud native environments. All to get to the question: are microservices worth it?
This document summarizes a guest lecture at UNSW about contemporary software challenges and solutions. It discusses how technology can provide a competitive advantage if developed properly. It presents case studies of legacy systems that were difficult to change and scale, as well as examples of systems that used newer architectures like microservices. The lecture promotes approaches like test-driven development, REST, and self-organizing teams to build independent, scalable services.
A Developer's Guide to CQRS Using .NET Core and MediatRBình Trọng Án
This document discusses implementing the CQRS pattern in .NET Core applications using MediatR for cleaner architecture. It begins with an overview of Clean Architecture principles like separating domains, applications, infrastructure and presentation layers. It then explains CQRS as separating commands and queries to improve maintainability and allow independent scaling. The document demonstrates CQRS in practice by having separate command and query classes and models rather than shared logic. It concludes that CQRS is an effective way to organize projects and prepare them for challenges like microservices.
Neil Perlin is an internationally recognized content consultant who helps clients create effective content across various mediums. The document discusses several predictions for the future of technical communication, including increased use of mobile-friendly responsive design, topic-based authoring, structured authoring using standardized styles, and analytics to track content usage. It also covers trends toward open web standards, cloud-based tools, and smaller chunks of reusable content.
Locotalk is a low-code application platform that aims to democratize business software by reducing friction in software development. It combines a semantic graph database called LocoDB with a JavaScript framework called LocoJS to allow building applications by composing reusable software blocks without needing to write code. Locotalk captures semantics at the data level to ensure integration between applications and avoid losing essential information during development. Its unique architecture aims to eliminate sources of friction like needing to remap data to different structures for the database, server and client sides of applications.
This document discusses structural design patterns from the Gang of Four (GoF) patterns book. It introduces proxies, decorators, adapters, façades, and composites patterns. Proxies provide a placeholder for another object to control access. Decorators dynamically add/remove responsibilities to objects. Adapters allow incompatible interfaces to work together. Façades provide a simplified interface to a subsystem. Composites represent part-whole hierarchies to access all parts uniformly. Bridge and flyweight patterns were not covered due to dependencies on other patterns. The document emphasizes introducing extra levels of indirection to solve problems and favoring composition over inheritance.
Presented at NDC London (5th December 2014)
How much should you rely on your IDE to govern your coding style? How many asserts should a test case have or not have? How much work should a constructor (not) do? How do you name your classes and other identifiers? How closed or open should your classes be? How do you lay out your code? These questions and others have standard answers based on received and repeated mantras, practices that are communicated in good faith to be passed on as habits. But how much reason supports these assertions? It turns out that the advice often fails, even for the novices they are intended to guide, or simply doesn't make sense.
This talk has little respect for ritual and tradition and takes no prisoners: What actually makes sense and what doesn't when it comes to matters of practice? What guidelines offer the greatest effect and the greatest learning?
This document provides an outline for an agile software architecture workshop. It begins by defining software architecture and describing key concepts like requirements, design principles, and architectural patterns. It emphasizes that architecture should enable agility by traveling light with just enough design. The document proposes techniques for agile architecture like architectural katas, risk analysis, and evolving the architecture over time with experiments. It concludes by providing an example architectural pitch for a restaurant ordering system that emphasizes high-level design, risks, and timelines.
its all about the domain, honey! Experiences from 15 years of Domain-Driven D...Carola Lilienthal
Great technologies, programming languages and tools are used when building software. That is good and right. But unfortunately, it is often lost sight of the fact that the decisive factor is not the technology, but the *business domain*. If we do not map the domain language and the business processes in the software, then it will not help our users in their work. No technology in the world can protect us from this.
In this talk, I'll show you how you can identify problems in an existing legacy system that could be solved with Domain-Driven Design. We will see problems such as: large entities that are used all over the system, how we could divide them into smaller entities according to the business domain and how we should cut the source code into bounded contexts. All this will be done with many examples from analysis tools that help us to see the system on the level above the source code.
Carola is managing the company WPS since 2014 where 120 developers and architects improve legacy systems all around the world. In this talk you will learn how to bring your old code base back to the path of virtue, step by step, so that maintenance is fun again.
More Related Content
Similar to its all about the domain honey! Experiences from 15 years of Domain-Driven Design with Text
The document discusses monolithic architecture and different types of monoliths. It argues that a physical monolith is often the best initial approach and that problems typically arise from logical monoliths that lack clear boundaries. A modular monolith is proposed as an optimal architecture, with distinct modules but a shared codebase and deployment. The document also covers techniques for implementing modular monoliths, such as defining module boundaries, startup classes per module, and routing.
Reactive Microservice Architecture with Groovy and GrailsSteve Pember
Steve Pember gave a presentation on reactive oriented architecture with Grails and Groovy. He discussed some key points:
1. Monolithic applications will not scale well as they grow in complexity, which can negatively impact development and maintenance.
2. Service oriented architecture (SOA) and microservices can help break applications into independent components, but SOA implementations have issues like increased complexity from interconnected services.
3. Architecture choices are more important than any specific framework. Microservices aim to distill SOA principles by focusing each component on a single context to reduce complexity.
Do you have a monolith? If so, is it majestic? Or is it broken and preventing you from scaling your application and your business?
Monoliths have earned a bad reputation in software architecture design circles for being difficult to maintain and operating on silos of knowledge. However, they aren't all bad. The key is knowing when to use a monolith, and when it is time re-factor and scale up by going small.
Elastically scalable architectures with microservices. The end of the monolith?Javier Arias Losada
In the last years the microservices architecture style has been gaining traction with some companies such as Netflix, Yelp, Gilt, PayPal. Many of that companies abandoned their previous monolithic architecture and moved to a microservices approach.
Does that mean that monolithic architectures are a thing of the past?
In this talk we will review some key microservices concepts (and misconceptions), search for the essence of microservices architectures and discuss about different approaches to implement them from the industry.
What if the reason everyone seems so anti-LMS is that they are not structured correctly? LMS design, as one large single system, is setup to fail the OER community. MOOCs are at least a push in the right direction, but their frameworks are often closed, discouraging open development. If we had truly open, community driven platform for the creation of educational resources, we might see more truly OER materials being created.
This is the position ELMS Learning Network (ELMSLN) takes in its approach to edtech design. ELMSLN takes the major functionality of an LMS and spreads it out across a suite of open source tools. The experience is glued together by single-sign-on technologies like LTI to enable the best system selection for the job without sacrificing user experience.
These tools a built on a framework that includes other open systems such as Drupal and Piwik. Piwik allows for a Google analytics style framework but open source and data is hosted with whoever is utilizing it. This can used both for tracking and general data about students, or for statistical analysis of how effective OER are in reaching different global audiences.
Drupal 7, is a highly flexible yet complex CMS used to power high scale development projects. While Drupal is traditionally difficult to work with, ELMSLN packages it up in such a way that's easy both for code developers and content authors to understand. What it brings with it is a community of experts authoring functionality that can all be utilized to deliver courses and OER. The best part is that by aligning with this community, ELMSLN has access to the knowledge and expertise of thousands of contributed modules and highly trained developers who don't need to have any understanding of edtech in order to help improve it!
ELMSLN also comes packaged with support for LTI 1.0 provider capabilities for integration with current LMS offerings. This enables faculty at existing universities and colleges to keep their materials outside the LMS, yet still securely pass their traditional students through to their content seamlessly. ELMSLN's networked approach to edtech development, can allow OER material to reside in one toolset (out in the open) without fear of opening oneself up to PII or FERPA violations.
Part of the resistance to OER production is the technical and privacy barriers to participation, which are at the heart of how ELMSLN has been constructed. Attendees will walk away with a sense of the transformative nature of Drupal, who's using ELMSLN and how to get involved.
It's easy to say... Microservices! Reality is we need to learn and apply concepts coming from many disciplines like SOA, EDA and DDD just to name a few! Mix them with some ALM and technical processes around Packaging and Deploying... and maybe then you get a true Microservices solution.
This lecture discusses challenges in building enterprise applications and provides advice. It recommends starting simply and evolving designs over time. Complex systems designed from scratch never work, so layering, clear interfaces, and minimizing dependencies are important. Frameworks and design patterns help manage complexity but shouldn't dictate design. Practical considerations include avoiding unnecessary complexity and refactoring when needed.
This document discusses various heuristics and principles for architecture design. It provides guidelines for creating simplified, evolvable systems using small modular components. Some key points discussed include using open architectures, building in options, and designing structures that are resilient to stress. The document also advocates for pattern-oriented, minimalist designs and evolutionary systems that can adapt over time without disrupting existing information. Overall, the document presents best practices for handling complexity, enabling flexibility, and ensuring architectures can withstand failures.
Slides for my keynote at incontrodevops.it, where I talked about distributed architectures, microservices, kubernetes and cloud native environments. All to get to the question: are microservices worth it?
This document summarizes a guest lecture at UNSW about contemporary software challenges and solutions. It discusses how technology can provide a competitive advantage if developed properly. It presents case studies of legacy systems that were difficult to change and scale, as well as examples of systems that used newer architectures like microservices. The lecture promotes approaches like test-driven development, REST, and self-organizing teams to build independent, scalable services.
A Developer's Guide to CQRS Using .NET Core and MediatRBình Trọng Án
This document discusses implementing the CQRS pattern in .NET Core applications using MediatR for cleaner architecture. It begins with an overview of Clean Architecture principles like separating domains, applications, infrastructure and presentation layers. It then explains CQRS as separating commands and queries to improve maintainability and allow independent scaling. The document demonstrates CQRS in practice by having separate command and query classes and models rather than shared logic. It concludes that CQRS is an effective way to organize projects and prepare them for challenges like microservices.
Neil Perlin is an internationally recognized content consultant who helps clients create effective content across various mediums. The document discusses several predictions for the future of technical communication, including increased use of mobile-friendly responsive design, topic-based authoring, structured authoring using standardized styles, and analytics to track content usage. It also covers trends toward open web standards, cloud-based tools, and smaller chunks of reusable content.
Locotalk is a low-code application platform that aims to democratize business software by reducing friction in software development. It combines a semantic graph database called LocoDB with a JavaScript framework called LocoJS to allow building applications by composing reusable software blocks without needing to write code. Locotalk captures semantics at the data level to ensure integration between applications and avoid losing essential information during development. Its unique architecture aims to eliminate sources of friction like needing to remap data to different structures for the database, server and client sides of applications.
This document discusses structural design patterns from the Gang of Four (GoF) patterns book. It introduces proxies, decorators, adapters, façades, and composites patterns. Proxies provide a placeholder for another object to control access. Decorators dynamically add/remove responsibilities to objects. Adapters allow incompatible interfaces to work together. Façades provide a simplified interface to a subsystem. Composites represent part-whole hierarchies to access all parts uniformly. Bridge and flyweight patterns were not covered due to dependencies on other patterns. The document emphasizes introducing extra levels of indirection to solve problems and favoring composition over inheritance.
Presented at NDC London (5th December 2014)
How much should you rely on your IDE to govern your coding style? How many asserts should a test case have or not have? How much work should a constructor (not) do? How do you name your classes and other identifiers? How closed or open should your classes be? How do you lay out your code? These questions and others have standard answers based on received and repeated mantras, practices that are communicated in good faith to be passed on as habits. But how much reason supports these assertions? It turns out that the advice often fails, even for the novices they are intended to guide, or simply doesn't make sense.
This talk has little respect for ritual and tradition and takes no prisoners: What actually makes sense and what doesn't when it comes to matters of practice? What guidelines offer the greatest effect and the greatest learning?
This document provides an outline for an agile software architecture workshop. It begins by defining software architecture and describing key concepts like requirements, design principles, and architectural patterns. It emphasizes that architecture should enable agility by traveling light with just enough design. The document proposes techniques for agile architecture like architectural katas, risk analysis, and evolving the architecture over time with experiments. It concludes by providing an example architectural pitch for a restaurant ordering system that emphasizes high-level design, risks, and timelines.
Similar to its all about the domain honey! Experiences from 15 years of Domain-Driven Design with Text (20)
its all about the domain, honey! Experiences from 15 years of Domain-Driven D...Carola Lilienthal
Great technologies, programming languages and tools are used when building software. That is good and right. But unfortunately, it is often lost sight of the fact that the decisive factor is not the technology, but the *business domain*. If we do not map the domain language and the business processes in the software, then it will not help our users in their work. No technology in the world can protect us from this.
In this talk, I'll show you how you can identify problems in an existing legacy system that could be solved with Domain-Driven Design. We will see problems such as: large entities that are used all over the system, how we could divide them into smaller entities according to the business domain and how we should cut the source code into bounded contexts. All this will be done with many examples from analysis tools that help us to see the system on the level above the source code.
Carola is managing the company WPS since 2014 where 120 developers and architects improve legacy systems all around the world. In this talk you will learn how to bring your old code base back to the path of virtue, step by step, so that maintenance is fun again.
Today programmers do not develop applications from scratch, but they spend their time fixing, extending, modifying and enhancing existing applications. The biggest problem in their daily work is that with time maintenance mutates from structured programming to defensive programming: The code becomes too complex to be maintained. We put in code we know is stupid from an architectural point of view but it is the only solution that will hopefully work. Maintenance is more and more difficult and expensive. Our software accumulates technical debts.
In this talk, you will see how you should improve your architecture and source code to prevent technical debt growing unrestricted. With the proper knowledge about well-structured architecture, refactorings for tangled code can quickly be found. Complex code can be eliminated, and maintenance costs will be reduced.
Today programmers do not develop applications from scratch, but they spend their time fixing, extending, modifying and enhancing existing applications. These old systems are often a large tangled mess, where changes become harder and harder. DDD can help us to improve this situation and to meltdown the big ball of mud.
Fast jedes Softwaresystem wird mit guten Vorsätzen aber unter schwierigen Bedingungen entwickelt: Knappe Zeitvorgaben zwingen uns, schnelle Lösungen – Hacks – zu programmieren. Unterschiedliche Qualifikationen im Entwicklungsteam führen zu Code in ebenso unterschiedlicher Güte. Alter Code, den keiner mehr kennt, muss angepasst werden und vieles mehr. All das führt zu schlechtem, verknäultem Code, dem sogenannten Monolithen, der die Entwicklungskosten in Zukunft in die Höhe treibt und den Entwicklungsteams schlaflose Nächte bereitet. Mit Domain-Driven Design haben wir ein Werkzeug an der Hand, um solche Monolithen Schritt für Schritt zu zerlegen und wieder in den Bereich der beherrschbaren Wartungskosten zu bringen.
Softwareentwicklung ist Modell-Bildung. Wir bauen einen Teil der Wirklichkeit als Programm nach und verbessern sie so. Ein traditioneller Ansatz ist, die Domäne als Ganzes möglichst detailgenau nachzubilden. Aber ist das eigentlich der Zweck von Modellen? Wenn wir genau hinschauen, bemerken wir, dass ein Modell eigentlich genau das Gegenteil ist. Ein Modell ist nämlich eine Abstraktion der Wirklichkeit, in die nur das Wesentliche übertragen und das Unwesentliche weggelassen wird. Was wesentlich und was unwesentlich ist, ergibt sich aus dem Kontext. Ein einfaches Modell ist leichter zu verstehen als ein kompliziertes. Deshalb ist es eine gute Idee, von einer komplizierten Wirklichkeit mehrere einfache (und einfach verständliche) Modelle zu bilden. Genau diesen Effekt machen sich Microservices und DDD mit seinem Strategisches Design zu nutze. Hier werden statt dem einen großen unternehmensweiten Modell, mehrere kleine gut verständliche Modelle gebildet. In diesem Talk betrachten wir, welche Mittel uns zur Verfügung stehen, um gute Modelle zu bauen und die Domäne so aufzuteilen, dass wir auch mit mehreren sinnvoll und unabhängig arbeiten können.
Since Microservices have appeared as an architectural style to solve organizational problems and improve scalability the ideas of Domain-Driven Design have experienced a strong revival. On the one hand the guidelines of strategic design (DDD in the large) help us to cut the domain into domain-related bounded contexts. These bounded contexts than correspond with microservices. Within the bounded contexts tactical design (DDD in the small) with the ubiquitous language and the building blocks entity, value object, aggregate, service etc. give us guidance how to implement and structure our design. In this workshop we will show you the essentials of DDD and report on our ten yours experience with DDD. Short lectures, discussions and exercises will alternate with one another.
Technische Schulden tun weh! Wie man sie erkennt und beseitigtCarola Lilienthal
Fast jedes Softwaresystem wird mit guten Vorsätzen aber unter schwierigen Bedingungen entwickelt. Deadlines, unterschiedliche Qualifikationen und Missverständnisse im Entwicklungsteam führen dazu, dass die Architektur des Systems erodiert und Schritt für Schritt technische Schulden aufgebaut werden. Bis das ganze System zu einem unordentlichen großen Knäul verwoben ist und jede Anpassung zu einer unkalkulierbaren Kostenschraube wird. Weder den Entwicklungsteam, noch dem Management macht ein System in einem solchen Zustand Freude.
In diesem Vortrag zeige ich Ihnen, wie Sie Ihren Sourcecode organisieren und weiterentwickeln können, um das Entstehen und Ansteigen von technischen Schulden zu verhindern. Dabei werden Sie sehen, welche Prinzipien helfen, technische Schulden zu vermeiden und wie sie durch geeignete Refactoring aus der Welt geschaffen werden können. Basis aller Empfehlungen werden Beispiele aus den nunmehr über 100 Analysen sein, die ich an unterschiedlichsten Softwaresystemen durchführen durfte.
Beim Bauen von Software werden tolle Technologien, Programmiersprachen und Tools eingesetzt. Das ist gut und richtig. Aber leider wird dabei oft aus den Augen verloren, dass das Entscheidende nicht die Technik, sondern die *Fachlichkeit* ist. Wenn wir in der Software nicht das fachliche Modell abbilden, dann wird sie unseren Anwendern nicht bei Ihrer Arbeit helfen. Davor schützt uns keine Technologie der Welt. Um das zu verhindern, zeigen wir in diesem Vortrag, wie man die Architektur so baut, dass sie die Fachlichkeit darstellt und wie Domain Driven Design (DDD) und Microservices uns dabei helfen können.
Was für Arten von Qualitätssicherung sind sinnvoll, wenn man eine sich ändernde Architektur in sich änderndem Kontext entwickelt? Wie kann man im Team die Architektur als Mob verbessern?
Almost every software system is created in difficult conditions and thus from the beginning burdened with quality problems. The most common difficulties are: deadlines forcing us to program hacks; divergent development skills in the team resulting in code of different quality; or old code, that is clumsy, tangled and without unit tests, putting a spoke in our wheel. All these bits and pieces of bad code will raise development costs in the futures that is why they are called technical debt.
In this talk you will see, which principles you should apply to your source code to prevent technical debt growing unrestricted. With the proper tool support refactorings for bad code can quickly be found and eliminated. I will present to you the tool Sotograph which allows us to inspect PHP code on a structural level and try out the effects of refactorings.
Beim Bauen von Software werden tolle Technologien, Programmiersprachen und Tools eingesetzt. Das ist gut und richtig. Aber leider wird dabei oft aus den Augen verloren, dass das Entscheidende nicht die Technik, sondern die *Fachlichkeit* ist. Wenn wir in der Software nicht das fachliche Modell abbilden, dann wird sie unseren Anwendern nicht bei Ihrer Arbeit helfen. Davor schützt uns keine Technologie der Welt. Um das zu verhindern, zeige ich in diesem Vortrag, wie man die Architektur von E-Commerce-Systemen so baut, dass sie die Fachlichkeit darstellt und wie Domain Driven Design (DDD) und Microservices uns dabei helfen können.
Technische Schulden in Architekturen erkennen und beseitigenCarola Lilienthal
Beim Entwurf der Softwarearchitektur zu Beginn eines Projekts bringen die Architekten i.d.R. all ihre Erfahrung und ihr Knowhow ein und stellen eine Architektur-Blaupause für die Entwicklung bereit. Aber während der Implementierung weichen die Entwickler ungewollt mehr und mehr von diesen Vorgaben ab: Einerseits macht der Projektdruck Abweichungen notwendig, andererseits entstehen die Abweichungen ungewollt und unbemerkt. Die Architektur des Systems erodiert und es werden Schritt für Schritt technische Schulden aufgebaut. Wartung und Erweiterung der Software werden immer teurer bis zu dem Punkt, an dem jede Änderung zu einer schmerzhaften Anstrengung wird.
In diesem Vortrag berichte ich von meinen Erfahrungen der letzten zehn Jahre mit der Analyse von Softwarearchitekturen in Java (60 Systeme), C# (10 Systeme), C++(6 Systeme): Die Zuhörer wissen nach meinem Vortrag, welche Fehler sie in ihren Softwareprojekten bei der Umsetzung der Architektur nicht machen sollten, welche Prinzipien Sie einhalten sollen, um technische Schulden nicht entstehen zu lassen, welche Tools helfen, technische Schulden aufzuspüren, und wie technische Schulden abgebaut werden können.
Mein Talk auf der OOP in München mit einer Kurzfassung aus meinem Buch "Langlebige Softwarearchitekturen - Technische Schulden beherrschen und abbauen"
Was sind die entscheidenden Zutaten für agile Projekte? Was muss man bei agilen Projekten unbedingt beachten, damit Agilität ihre beeindruckende Kraft entfalten kann.
Langlebige Softwarearchitekturen - Der Umgang mit technischen SchuldenCarola Lilienthal
Zu Beginn eines Projekts stellen die Architekten eine Architektur-Blaupause für die Entwicklung bereit. Während der Implementierung weichen die Entwickler ungewollt mehr und mehr von diesen Vorgaben ab: Einerseits macht der Projektdruck Abweichungen notwendig, andererseits entstehen die Abweichungen ungewollt und unbemerkt.
Die Architektur des Systems erodiert und weicht immer mehr von der geplanten Nutzung des Frameworks ab. Die Komplexität nimmt zu und es werden Schritt für Schritt technische Schulden aufgebaut.
In diesem Vortrag berichte ich von meinen Erfahrungen der letzten zehn Jahre: Die Zuhörer erfahren, welche Fehler sie in ihren Softwareprojekten bei der Umsetzung der Architektur nicht machen sollten, welche Prinzipien Sie einhalten sollen, um ein langlebige Architekturen zu entwerfen, welche Tools helfen, technische Schulden aufzuspüren, und wie technische Schulden abgebaut werden können.
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
When it is all about ERP solutions, companies typically meet their needs with common ERP solutions like SAP, Oracle, and Microsoft Dynamics. These big players have demonstrated that ERP systems can be either simple or highly comprehensive. This remains true today, but there are new factors to consider, including a promising new contender in the market that’s Odoo. This blog compares Odoo ERP with traditional ERP systems and explains why many companies now see Odoo ERP as the best choice.
What are ERP Systems?
An ERP, or Enterprise Resource Planning, system provides your company with valuable information to help you make better decisions and boost your ROI. You should choose an ERP system based on your company’s specific needs. For instance, if you run a manufacturing or retail business, you will need an ERP system that efficiently manages inventory. A consulting firm, on the other hand, would benefit from an ERP system that enhances daily operations. Similarly, eCommerce stores would select an ERP system tailored to their needs.
Because different businesses have different requirements, ERP system functionalities can vary. Among the various ERP systems available, Odoo ERP is considered one of the best in the ERp market with more than 12 million global users today.
Odoo is an open-source ERP system initially designed for small to medium-sized businesses but now suitable for a wide range of companies. Odoo offers a scalable and configurable point-of-sale management solution and allows you to create customised modules for specific industries. Odoo is gaining more popularity because it is built in a way that allows easy customisation, has a user-friendly interface, and is affordable. Here, you will cover the main differences and get to know why Odoo is gaining attention despite the many other ERP systems available in the market.
UI5con 2024 - Bring Your Own Design SystemPeter Muessig
How do you combine the OpenUI5/SAPUI5 programming model with a design system that makes its controls available as Web Components? Since OpenUI5/SAPUI5 1.120, the framework supports the integration of any Web Components. This makes it possible, for example, to natively embed own Web Components of your design system which are created with Stencil. The integration embeds the Web Components in a way that they can be used naturally in XMLViews, like with standard UI5 controls, and can be bound with data binding. Learn how you can also make use of the Web Components base class in OpenUI5/SAPUI5 to also integrate your Web Components and get inspired by the solution to generate a custom UI5 library providing the Web Components control wrappers for the native ones.
Artificia Intellicence and XPath Extension FunctionsOctavian Nadolu
The purpose of this presentation is to provide an overview of how you can use AI from XSLT, XQuery, Schematron, or XML Refactoring operations, the potential benefits of using AI, and some of the challenges we face.
How Can Hiring A Mobile App Development Company Help Your Business Grow?ToXSL Technologies
ToXSL Technologies is an award-winning Mobile App Development Company in Dubai that helps businesses reshape their digital possibilities with custom app services. As a top app development company in Dubai, we offer highly engaging iOS & Android app solutions. https://rb.gy/necdnt
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
SOCRadar's Aviation Industry Q1 Incident Report is out now!
The aviation industry has always been a prime target for cybercriminals due to its critical infrastructure and high stakes. In the first quarter of 2024, the sector faced an alarming surge in cybersecurity threats, revealing its vulnerabilities and the relentless sophistication of cyber attackers.
SOCRadar’s Aviation Industry, Quarterly Incident Report, provides an in-depth analysis of these threats, detected and examined through our extensive monitoring of hacker forums, Telegram channels, and dark web platforms.
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
Mobile app Development Services | Drona InfotechDrona Infotech
Drona Infotech is one of the Best Mobile App Development Company In Noida Maintenance and ongoing support. mobile app development Services can help you maintain and support your app after it has been launched. This includes fixing bugs, adding new features, and keeping your app up-to-date with the latest
Visit Us For :
Need for Speed: Removing speed bumps from your Symfony projects ⚡️Łukasz Chruściel
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
Hand Rolled Applicative User ValidationCode KataPhilip Schwarz
Could you use a simple piece of Scala validation code (granted, a very simplistic one too!) that you can rewrite, now and again, to refresh your basic understanding of Applicative operators <*>, <*, *>?
The goal is not to write perfect code showcasing validation, but rather, to provide a small, rough-and ready exercise to reinforce your muscle-memory.
Despite its grandiose-sounding title, this deck consists of just three slides showing the Scala 3 code to be rewritten whenever the details of the operators begin to fade away.
The code is my rough and ready translation of a Haskell user-validation program found in a book called Finding Success (and Failure) in Haskell - Fall in love with applicative functors.
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Drona Infotech is a premier mobile app development company in Noida, providing cutting-edge solutions for businesses.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
8 Best Automated Android App Testing Tool and Framework in 2024.pdfkalichargn70th171
Regarding mobile operating systems, two major players dominate our thoughts: Android and iPhone. With Android leading the market, software development companies are focused on delivering apps compatible with this OS. Ensuring an app's functionality across various Android devices, OS versions, and hardware specifications is critical, making Android app testing essential.
E-Invoicing Implementation: A Step-by-Step Guide for Saudi Arabian CompaniesQuickdice ERP
Explore the seamless transition to e-invoicing with this comprehensive guide tailored for Saudi Arabian businesses. Navigate the process effortlessly with step-by-step instructions designed to streamline implementation and enhance efficiency.
E-Invoicing Implementation: A Step-by-Step Guide for Saudi Arabian Companies
its all about the domain honey! Experiences from 15 years of Domain-Driven Design with Text
1. 1
WPS - Workplace Solutions GmbH //// Hans-Henny-Jahnn-Weg 29 //// 22085 HAMBURG
It’s all about the domain, honey !
Experiences from 15 years of Domain-Driven Design
Dr. Carola Lilienthal @cairolali cl@wps.de
Hi everybody! In this talk, I'll show you how to build systems in a way that makes
sense for the business and how Domain Driven Design (DDD) can help us do
that.
6. … at the university of hamburg and gained the diploma in 1995 I started to work as a
programmer and discovered my love for architecture. And in 2004
7. Someone showed me the book of Eric Evans and I knew: This is it! It is difficult to read,
but it‘s worth it. Please dont stop at page 100! Because the interesting part starts at
page 120
8
8. ARCHITECT
So I started to work as a programmer and architect and used DDD in all my projects. It is
great!
9
10. My homebase is the company WPS where we develop all our systems following DDD.
We started with 12 programmers in 2000 and today we are 140 programmers,
architects, ux-designers and requirement engineers. And we love good software that
lives a long time and comes from the domain.
11
12. @cairolali
WHAT IS THE GOAL?
Sustainable
Architecture
the sad norm…
Release cycle or time
Number
of
delivered
feature
per
release
What is sustainable architecture
13
13. @cairolali
10 42
81
165
120 15 Mio
5 Mio
1 Mio
500.000
100.000
Size in Lines of Code
During and after my PhD, we analyzed a great many systems of different ages, sizes, and
programming languages. On this slide here, you see sizes ranging from 100,000 to 15
million lines of code. The pie chart in the middle shows how many systems of which size
we have analyzed. 120 systems from a size up to 100,000 LOC, 150 systems from a size
up to half a million LOC and so on. Some were even up to 15 million loc.
Many of theses systems are developed in modern programming languages (Java, C#...),
but they frustrate their developers because they have accumulated technical debt and
complexity over the years. and unfortunately, some of them are microservice
architectures -
14
Dr. Carola Lilienthal, C1 WPS
14. @cairolali
NEW SOLUTION: MICROSERVICES!
the great new architectural style that was supposed to solve all our problems when we
were told about it around 2010.
It used to be that people would call me and say, “Carola, we have a legacy system, and
we need help! It's getting more expensive and slower to maintain. Can you help us break
the system into microservices." Today they call and say, “Carola, we have a microservice
architecture and maintenance is getting more expensive and slower. What are we doing
wrong?“
Yes, what is wrong? Well, with a lot of microservice architectures, people have made the
same mistakes they made with monoliths before.
15
15. @cairolali
NEW SOLUTION – SAME PROBLEM
Simon Brown
I stole this diagram from simon brown because it explaines so well what was forgotten.
The people forgot that a good architecture is about creating independent modules.
therefore the x axis is labeled with ”modularity”. A modular architecture - is the opposite
to a big ball of mud. In a modular architecture independence of moduls is a top priority.
If not, then you have a big ball of mud. No matter if you have a monolith or a greater
number of deployment units - what is shown on the y-axis. If you don't have
independent modules, you have a big ball of mud in your distributed system. and that is
much worse than a monolithic big ball of mud. If modularity is not your top priority your
system will look like this
16
16. @cairolali
▪ 15 years of development
▪ 3 Million LOC in Java
▪ 463 tangled classes from 10 modules
▪ This cycle contains 500.000 LOC
BIG BALL OF MUD ON CLASS LEVEL
The diagramm on the right shows a class clycle, a strongly conntected component, In
Lines of code this classclycle contains about 500.000 LOC and it spans 10 domain
modules each one with a different Color in the diagramm. The whole system has
3.000.000 LOC. which means that the cycle is a big part of the system. 30 developers
have been working on this system for 15 years. If you change one class in this cycle, you
have to check the whole cyclic structure to exclude possible side effects. This greatly
slows down maintenance and enhancements.
17
17. @cairolali
▪ 20 years of developement
▪ 10 Million Lines of Code in Java
▪ 90 Modules
▪ No dependency control!
BIG BALL OF MUD ON MODULE LEVEL
Another example – even bigger: 10 million lines of code developed in Java over the last
20 years. When they started, nobody told them about modularity, monolith and
microservices. These ideas did not exist at that time. The result is 90 modules strongly
connected – a real big ball of mud - and a whole lot extra work for maintenance and
enhencements. Nobody has reduced or controled the dependencies in theses complex
structures. What can we do, to prevent this in our microservice architectures?
18
18. @cairolali
▪ Within a module:
▪ high cohesion = strong coupling
▪ Single Responsibility Principle
▪ Separation of concern
▪ Outside a module:
▪ loose coupling = low coupling
▪ Information hiding
▪ Separation of concern
HIGH COHESION AND LOOSE COUPLING
Well we do have very old principles at hand to prevent the big ball of mud in our
architectures: high cohesion and loose coupling. Within a module, the classes or
packages should work together to fulfill one responsibility. This responsibility connects
them strongly together and creatrs high cohesion. Other resonsibilities should be
separated into their own module. Outside of the module we want loose coupling which
means low coupling – one module doesn‘t need much from another module. A module
should be complete from a domain point of view!
From outside of the module only relevant features should be visible and accessible.
Details of the implementation should remain hidden. A good modular architecture that
follows these principles would look like this:
19
19. @cairolali
HIGH COHERSION AND LOW COUPLING FOR MODUES
Loose coupling = As little coupling as possible!
Technical
Layering
Module B
Module A Module C
User Interface User Interface
User Interface
Domain
Application
Domain
Application
Domain
Application
we see three Modules here, each of which should have a responsibility and therefore
have high cohesion within. The key point is that we should build this architecture in such
a way that we have as little coupling as possible between modules. but this is only
possible if
20
20. @cairolali
THE NEED OF DOMAIN ARCHITECTURE
An architecture (with or without
microservices) only then has
high cohesion and low coupling
if it follows a
domain architecture!
there is an idea of a domain architecture. Domain driven design has given us the
knowlegde to create independent modules. One module for the sales context and
another one for the support context. This is such a wonderful idea and it works. It
creates modules that have high cohesion and low coupling which means dependency
control. But unfortunately not many systems have a domain architecture.
The other day a client called me and said: Carola, we need help. We are having a
microservice architecture (Yes! I thought) for our platform where customers can sell
their second-hand vehicles. We have 270 microservices. (oh, quite a lot…) and what is
the problem: Well if we want to change something in the database: we have to discuss
this with all teams. What?
21
21. @cairolali
ONE DOMAIN MODEL AND DATABASE FOR ALL
Module B
Module A Module C
User Interface User Interface
User Interface
Domain
Application Application Application
Well we looked at the thing and each microservice was using a library called model.jar. I
asked them what this is: Well that‘s the interface to the database. The one and onlys
database….When the second microservice was built they thought that they could reuse
the work of the first team on the domain model. So they took the model.jar. Enhanced it
for their purpose and ended up with an overall domain model.
22
22. @cairolali
ONE SHARED MODEL
Several domain use cases Models allocated to their use cases
I have an example for you with a simular problem where we tried to find a solution: a
company called us to look at their architecture and help them to divide it into
microservices. I asked: What kind of architecture do you have? They said: our
architecture follows use cases – a criterion from the domain! I thought, finally no
layered architecture! this will be exciting. What you see here is the architecture that we
put on the source code with a tool. for each use case we have created a rectangle and
written the name of the use case next to it <klick>: Mailing, Importexport, remove and
so on. The dependencies between the system parts are shown on the right side of the
diagram. the green arcs represent relationships from top to bottom. the red arcs
represent relationships from bottom to top. Mailing uses importexport via the green arc.
And remove uses importexport via the red arc. After collecting the use cases we came to
a part of the system called Model<klick>. You guessed it: the equivalent of model.jar.
This is not a good idea in a modular architecture, so we tried to distribute the classes
from model among the use cases. <klik< on the right side you can see the result. There
are much more dependencies between the use cases now. They appeared because we
moved classes from the model rectangle to the use cases rectangles. So many
dependencies hidden in the model! We see another big ball of mud.
23
23. @cairolali
Security Business
Bild 215
Account Managing
Account Credit
Customer
Credit Business
Presentation
Application
Presentation
Application
Presentation
Application
Security
A bank with three business areas: account managing, credit business and security
business. These three areas use the same classes Account, customer, Credit and Security
to fullfil their work.
24
24. @cairolali
Bild 216
Security Business
Credit Business
Account Managing
Account
Credit
Security
Credit
Customer
Presentation
Application
Presentation
Application
Presentation
Application
Customer
Credit
Account Securities
Account
Security
Customer
Credit
Security
If we want to break them down to the bottom of the domain model, we have to have
much more specific domain model classes: a credit customer and a credit account as
well as a security customer and a security account.
25
25. @cairolali
MODELS IN MICROSERVICES
➔ domains need to be divided into subdomains with smaller models
▪ Separate models
▪ Allow independent changes (separation of concern)
▪ have to represent a smaller
set of the requirements (high cohesion)
▪ Need a clear boarder (loose coupling)
➔ Each model and its subdomain should be small enough to be programmed by one team.
So please, if you are building or having a microservice architecture, try to <klick> divide
your domain into subdomains with small models
Try to <klick> create separated models. Because than you will allow <klick> independent
changes you will have <klick> high cohesion and <klick> loose coupling.
And your teams can work independently <klick> because each model and its subdomain
should be small enough to be programmed by one team.
Otherwise, your teams will feel <klick> like the chickens on the right side: the chickens
eat pieces of bread. Unfortunately some stupid children have tied those bread pieces
together. The chicken swallow them and are no longer <klick> independent. They might
even <klick> die together. Lets look at a solution:
26
26. that's exactly what ddd wants to help us with: The goal of software development is to
translate the domain knowledge into the software
27
27. @cairolali
STRATEGIC DESIGN
▪ Find the subdomains in the
domain and decompose your
software accordingly.
▪ Set explicit boundaries with
the bounded contexts for
▪ domain-oriented parts in
the software and
▪ in the team organization
▪ Goal: high cohesion
+ loose coupling
Domain Software System
Bounded
Context A
Bounded
Context B
Team A
Team B
Bounded
Context C
Team C
Subdomain
A
Subdomain
B
Subdomain
C
Our <klick> software system supports users in their work in a <klick> domain.
DDD tells us that in a domain above a certain size, there should be subdomains
<klick> that can help us divide our software into bounded contexts <klick>. Each
<klick> bounded context sets explicit boundaries for individual domain-oriented
parts in the software and in the <klick< team organization. Each bounded context
is handled by exactly one team. We do all this because our goal <klick> is high
cohesion and loose coupling for our bounded contexts.
let's go back to the process in the cinema and see what we can do there.
28
28. Event Storming https://www.eventstorming.com/
For an event storming session, we meet with the users and developers and model the
processes in the domain with sticky notes on the wall. Each sticky note represents a
domain event. All participants are invited to stick notes, which are then discussed and
sorted with the whole group afterwards. This way you get a quick overview of the
process without thinking about software.
Today, of course, we're doing Event Storming remotely on a Miroboard.
29
29. Domain Storytelling https://domainstorytelling.org/
In a session for domain storytelling, we also meet with the users and developers and
model the processes from the domain with actors who exchange domain objects and
concepts. Today, we also do this remotely with the open-source tool domainstory
modeler. Let's look at this with an example.
30
30. @cairolali
TICKET AGENT
CUSTOMER
WEEKLY SCHEDULE
<< work in progress>>
REQUESTED NUMBER
OF SEATS
AUDITORIUM PLAN
LIST OF AUDITORIUM
PLANS
SOLD SEATS
TICKETS
FILM SHOW
FOUND
SEATS
AUDITORIUM PLAN
WEEKLY SCHEDULE
<< finalized>>
FILM DISTRIBUTOR
CINEMA
MANAGER
AD
AGENCY ADVERTISMENT
BOOKING PLAN
PLAN FOR
FILM SHOWS
COUNTRYWIDE
NUMBER OF VISITORS
AVAILABILITY
OF FILMS
1
6
2
10
5
3
8
4
7
9
11
12
13
14
AUDITORIUM PLAN
15
STARTS
WORKING ON
CHECKS THE
NEGOTIATES
WITH
FINALIZES
THE
AND CREATES FOR
THE UPCOMMING
WEEK
MONEY TICKETS
TICKETS
ASKS FOR
FOR A
OPENS A
CLOSES THE
FROM THE
OFFERS
TO GIVES
TO
SEARCHES
ON
THE
ON
THE
MARKS
PRINTS
GIVES THE
TO
THE
This is a domain story for a small art house cinema. In this program cinema there is the
<klick> cinema manager and the <klick> ticket agent. Once a week in this cinema is
issued <click> a new weekly schedule for the next week. The <click> process starts in the
upper left corner when the advertising agency sends the plan for the advertising
bookings. Once the cinema manager has received this plan, he <click> starts working on
the Weekly schedule with his super great legacy system Cinesmall. The small yellow
flash on the icon of the weekly schedule indicates that the Cinesmall software is used
here.
Next, the cinema manger <klick> gets the plan for the possible film shows from the film
distributors and <klick> he looks at the nationwide number of visitors. He <klick>
negotiates with the film distibutor which films he can get and finally <klick> finalizes the
weekly schedule. Our legacy system Cinesmall then <klick> generates auditorium plans
and the ticket agent can start selling tickets for the now scheduled film shows. <klick>
The customer now comes to the cinema and <klick> asks for tickets for a certain film
show. <klick> The ticket agent checks the auditorium plan to see if he can find suitable
seats in the auditorium for the desired film show and <klick> sells the seats to the
Customer.
This is very domain specific! You don’t find any technical terms in this domain story this
is, because DDD asks us to
31
31. @cairolali
TICKET AGENT
WEEKLY SCHEDULE
<< work in progress>>
REQUESTED NUMBER
OF SEATS
AUDITORIUM PLAN
LIST OF AUDITORIUM
PLANS
SOLD SEATS
TICKETS
FILM SHOW
FOUND
SEATS
AUDITORIUM PLAN
WEEKLY SCHEDULE
<< finalized>>
FILM DISTRIBUTOR
CINEMA
MANAGER
AD
AGENCY ADVERTISMENT
BOOKING PLAN
PLAN FOR
FILM SHOWS
COUNTRYWIDE
NUMBER OF VISITORS
AVAILABILITY
OF FILMS
1
6
2
10
5
3
8
4
9
11
12
13
14
AUDITORIUM PLAN
15
STARTS
WORKING ON
CHECKS THE
NEGOTIATES
WITH
FINALIZES
THE
AND CREATES FOR
THE UPCOMMING
WEEK
MONEY TICKETS
TICKETS
ASKS FOR
FOR A
OPENS A
CLOSES THE
FROM THE
OFFERS
TO GIVES
TO
SEARCHES
ON
THE
ON
THE
MARKS
PRINTS
GIVES THE
TO
THE
Trigger
Trigger
CUSTOMER
7
If you look closely at the process, you can see there are two entries, that is, two triggers
that set different parts of the process in motion. this is an important indicator that there
could be two subdomains in the domain here.
32
32. @cairolali
TICKET AGENT
WEEKLY SCHEDULE
<< work in progress>>
REQUESTED NUMBER
OF SEATS
AUDITORIUM PLAN
LIST OF AUDITORIUM
PLANS
SOLD SEATS
TICKETS
FILM SHOW
FOUND
SEATS
AUDITORIUM PLAN
WEEKLY SCHEDULE
<< finalized>>
FILM DISTRIBUTOR
CINEMA
MANAGER
AD
AGENCY ADVERTISMENT
BOOKING PLAN
PLAN FOR
FILM SHOWS
COUNTRYWIDE
NUMBER OF VISITORS
AVAILABILITY
OF FILMS
1
6
2
10
5
3
8
4
9
11
12
13
14
AUDITORIUM PLAN
15
STARTS
WORKING ON
CHECKS THE
NEGOTIATES
WITH
FINALIZES
THE
AND CREATES FOR
THE UPCOMMING
WEEK
MONEY TICKETS
TICKETS
ASKS FOR
FOR A
OPENS A
CLOSES THE
FROM THE
OFFERS
TO GIVES
TO
SEARCHES
ON
THE
ON
THE
MARKS
PRINTS
GIVES THE
TO
THE
Trigger
Trigger
once a week
CUSTOMER
7
In addition, the two subprocesses are also decoupled in terms of time. The left one is
performed once a week and …….
33
33. @cairolali
TICKET AGENT
WEEKLY SCHEDULE
<< work in progress>>
REQUESTED NUMBER
OF SEATS
AUDITORIUM PLAN
LIST OF AUDITORIUM
PLANS
SOLD SEATS
TICKETS
FILM SHOW
FOUND
SEATS
AUDITORIUM PLAN
WEEKLY SCHEDULE
<< finalized>>
FILM DISTRIBUTOR
CINEMA
MANAGER
AD
AGENCY ADVERTISMENT
BOOKING PLAN
PLAN FOR
FILM SHOWS
COUNTRYWIDE
NUMBER OF VISITORS
AVAILABILITY
OF FILMS
1
6
2
10
5
3
8
4
9
11
12
13
14
AUDITORIUM PLAN
15
STARTS
WORKING ON
CHECKS THE
NEGOTIATES
WITH
FINALIZES
THE
AND CREATES FOR
THE UPCOMMING
WEEK
MONEY TICKETS
TICKETS
ASKS FOR
FOR A
OPENS A
CLOSES THE
FROM THE
OFFERS
TO GIVES
TO
SEARCHES
ON
THE
ON
THE
MARKS
PRINTS
GIVES THE
TO
THE
Trigger
Trigger
once a week
each time a
customer asks
for a ticket
CUSTOMER
7
the right one whenever the customer comes by.
34
34. @cairolali
TICKET AGENT
WEEKLY SCHEDULE
<< work in progress>>
REQUESTED NUMBER
OF SEATS
AUDITORIUM PLAN
LIST OF AUDITORIUM
PLANS
SOLD SEATS
TICKETS
FILM SHOW
FOUND
SEATS
AUDITORIUM PLAN
WEEKLY SCHEDULE
<< finalized>>
FILM DISTRIBUTOR
CINEMA
MANAGER
AD
AGENCY ADVERTISMENT
BOOKING PLAN
PLAN FOR
FILM SHOWS
COUNTRYWIDE
NUMBER OF VISITORS
AVAILABILITY
OF FILMS
1
6
2
10
5
3
8
4
9
11
12
13
14
AUDITORIUM PLAN
15
STARTS
WORKING ON
CHECKS THE
NEGOTIATES
WITH
FINALIZES
THE
AND CREATES FOR
THE UPCOMMING
WEEK
MONEY TICKETS
TICKETS
ASKS FOR
FOR A
OPENS A
CLOSES THE
FROM THE
OFFERS
TO GIVES
TO
SEARCHES
ON
THE
ON
THE
MARKS
PRINTS
GIVES THE
TO
THE
Trigger
Trigger
once a week
each time a
customer asks
for a ticket
Cinema management
Ticket sales
CUSTOMER
7
In large cinemas, there are often also departments for these two sub-processes: <lick>
cinema management and <klick> ticket sales.
35
35. @cairolali
TICKET AGENT
WEEKLY SCHEDULE
<< work in progress>>
REQUESTED NUMBER
OF SEATS
AUDITORIUM PLAN
LIST OF AUDITORIUM
PLANS
SOLD SEATS
TICKETS
FILM SHOW
FOUND
SEATS
AUDITORIUM PLAN
WEEKLY SCHEDULE
<< finalized>>
FILM DISTRIBUTOR
CINEMA
MANAGER
AD
AGENCY ADVERTISMENT
BOOKING PLAN
PLAN FOR
FILM SHOWS
COUNTRYWIDE
NUMBER OF VISITORS
AVAILABILITY
OF FILMS
1
6
2
10
5
3
8
4
9
11
12
13
14
AUDITORIUM PLAN
15
STARTS
WORKING ON
CHECKS THE
NEGOTIATES
WITH
FINALIZES
THE
AND CREATES FOR
THE UPCOMMING
WEEK
MONEY TICKETS
TICKETS
FOR A
OPENS A
CLOSES THE
FROM THE
OFFERS
TO GIVES
TO
SEARCHES
ON
THE
ON
THE
MARKS
PRINTS
GIVES THE
TO
THE
Trigger
Trigger
once a week
each time a
customer asks
for a ticket
Cinema management
Ticket sales
information flow
CUSTOMER
7
The next very important indicator is found in the middle. When the left sub-process is
over, there is a <klick> flow of information in one direction into the other sub-process
and it continues there with ticket sales. a way back is not possible. this is a very strong
indicator of a boundary between two subdomains. The work in one subdomain is done
and the result is passed to another subdomain. In the second subdomain, work is
continued on the result or with the result. Finally, you can use this example to make
another point from DDD clear.
36
36. @cairolali
TICKET AGENT
WEEKLY SCHEDULE
<< work in progress>>
REQUESTED NUMBER
OF SEATS
AUDITORIUM PLAN
LIST OF AUDITORIUM
PLANS
SOLD SEATS
TICKETS
FILM SHOW
FOUND
SEATS
AUDITORIUM PLAN
WEEKLY SCHEDULE
<< finalized>>
FILM DISTRIBUTOR
CINEMA
MANAGER
AD
AGENCY ADVERTISMENT
BOOKING PLAN
PLAN FOR
FILM SHOWS
COUNTRYWIDE
NUMBER OF VISITORS
AVAILABILITY
OF FILMS
1
6
2
10
5
3
8
4
9
11
12
13
14
AUDITORIUM PLAN
15
STARTS
WORKING ON
CHECKS THE
NEGOTIATES
WITH
FINALIZES
THE
AND CREATES FOR
THE UPCOMMING
WEEK
MONEY TICKETS
TICKETS
ASKS FOR
FOR A
OPENS A
CLOSES THE
FROM THE
OFFERS
TO GIVES
TO
SEARCHES
ON
THE
ON
THE
MARKS
PRINTS
GIVES THE
TO
THE
Trigger
Trigger
once a week
each time a
customer asks
for a ticket
Cinema management
Ticket sales
information flow
WEEKLY SCHEDULE
<< printed>>
CUSTOMER
7
DDD assumes that terms in different subdomains can mean different things. We can also
imagine that here for our cinema. The customer looks at a <klick> weekly schedule to
find out about the planned film shows. This weekly schedule is much less detailed than
the <klick> weekly schedule that the cinema manager is working on. He noted the
cleaning times of the cinema halls and the ice cream seller and much more.
37
37. @cairolali
WeeklyPlanningService
• PlanFilmInHall
• AdPlanningForFilm
• ExpectedNumVisitors
• GenerateFinalSchedule
TicketSaleService
• SearchTimeForFilm
• SearchSeatsInHall
• BookSeats
• SellPlaces
UI WeeklyPlanning UI TicketSales UI WeeklyPlanning UI TicketSales
WeeklyScheduleService
• SearchTimeForFilm
• PlanFilmInHall
• AdPlanningForFilm
• ExpectedNumVisitors
• GenerateFinalSchedule
AuditoriumPlanService
• SearchSeatsInHall
• BookSeats
• SellPlaces
• GeneratePlans
Bounded Context
Cinema Management
Bounded Context
TicketSales
Service Weekly Schedule Service Auditorium Plans
Service
Tickets
Division according to entities
with direct coupling
Bounded contexts according to business
processes with "asynchronous" coupling
WeeklySchedule WeeklySchedule
WeeklySchedule
WeeklySchedule
AuditoriumPlans AuditoriumPlans
AuditoriumPlans
AuditoriumPlans
Ticket
Ticket
In a good solution we would have two bounded contexts: <klick> Cinema Manager and
<klick> Ticket Sales. The bounded context Cinema Manager would provide a <klick>
UserInterface for scheduling the weekly schedule. This user interface works on <klick> a
service that allows you to schedule movies in theaters, schedule advertising for movies
and more. The service itself uses <klick> the weekly schedule and auditoriums plans to
do its work.
The bounded context Ticket Sales would provide a <klick> User interface for ticket sales.
It works on <klick> a Service that allows you to search for films and halls and book and
sell tickets. The service itself uses <klick> the wekly schedule, the autotorium plans and
the ticket.
To communicate with each other the tow bounded contexts exchange <klick> the
weekly schedule and the auditorium plans. But this <klick> processing between the two
bounded contexts is done asynchronously. They don’t depend on each other.
A bad solution would be to divide the <klick> domain according to the entities involved
in the processes. Here we will need direct coupling. In this solution we would have
<klick> a Service Weekly Schedule and a Service <klick> Auditorium Plans. One service
for each Entity. Both entities would be protected by <klick> Services at their interface
the methods that are necessary to process the respective entity. Because the methods
are now each assigned to the service for the entity, at least the <klick> Ticket Sales user
interface must work synchronously with both services. In addition, there must be <click>
another service for the tickets. Comparing these two solutions, we see loosely coupled
bounded contexts on the left green side and strongly coupled system parts on the right
red side. DDD recommends us to go the left green way. If you go the left green way, you
have to live with the fact that you have the same entities in different bounded contexts.
the Weekly Schedule is present in both contexts.
But what is with reuse!
38
38. @cairolali
HOW DO I CUT MY LEGACY TO FIT THE DOMAIN?
▪ According to boundaries in the business process described by the domain experts
▪ Information flow
▪ Process rhythms
▪ Process triggers
▪ According to differences in the
use/definition of key concepts in the domain
▪ By departments in the organization or
groups of domain experts
Let's summarize: we can cut the domain into subdomains<klick> according to
boundaries in the business process. Good indicators are: <klick> the Information flow,
<klick> the process rythmes or <klick> the process triggers. We can cut the domain
<klick> according to differences in the use or definition of key concepts in the domain or
<klick> by departments in the organization or groups of domain experts.
https://commons.wikimedia.org/wiki/File:Beef_(PSF).jpg
39
39. @cairolali
612.869 LOC
14.756.435 LOC
252.062 LOC
804.093 LOC
543.388 LOC
1.035.668 LOC
486.358 LOC
175.258 LOC
42.311 LOC
193.383 LOC
643.466 LOC
245.754 LOC
2.890.204 LOC
141.696 LOC
512.086 LOC
9.988.363 LOC
200.591 LOC
922.949 LOC
22.658 LOC
663.862 LOC
3.270.188 LOC
1.521.357 LOC
0
2
4
6
8
10
MODULARITY MATURITY INDEX (MMI)
If you want to know how modular your source code is whether it is microservices or
monolith, we can measure this with the modularity maturity index. if modularity is
poor<klick>, the system is rated 0 to 4. If the modularity is not good but not too bad as
well <klick>, we give 4-8 as grade. If the modularity is good <klick>, the system gets 8-
10. The x axes represents just the time.
<klick>now you see different circles, each of which stands for a system. 22 systems in
different programming languages.
<klick>This system was built in Java, has 14 Mio and is very modular, <klick> this one is
as well Java but very bad modularity and <klick> this one is also Java with some
modularity but not enough to arrive in the green area, But this one <kick> is C# and
<klick> this one too. You see, the programming language has little influence on
modularity unfortunately. Us, the developers and architects, have to take care of it
ourselves!
How do we get to these rating:
40
40. @cairolali
ANALYSING MODULARITY WITH TOOLS
Structure101
Sotograph
Lattix
TeamScale
Sonargraph
we meet with our clients and analyse their systems for modularity with tools. The result
is the MMI. Since March 2020 our meetings are virtual of course.
41