- Ports and Adapters is an architecture pattern that decouples an application's domain model from its technical infrastructure and external interfaces to make it more testable. It defines relationships with the outside world through "ports" and isolates the domain model.
- The presentation discusses how to apply this pattern to avoid business logic infiltration over time by clearly separating layers and modules with single responsibilities. It emphasizes building testable code and detecting violations of architectural promises.
- Examples of Silex and Symfony implementations are provided, along with tips on using controllers to convert requests and dispatch commands without direct module coupling.
Adding Real-time Features to PHP ApplicationsRonny López
It's possible to introduce real-time features to PHP applications without deep modifications of the current codebase.
Using WAMP you can build distributed systems out of application components which are loosely coupled and communicate in (soft) real-time.
There is no need to learn a whole new language, with the implications it has.
It also opens the door to write reactive, event-based, distributed architectures and to achieve easier scalability by distributing messages to multiple systems.
An introduction to reactive programming concepts and basics. I aim here to show what's reactive programming, why it's used and show some frameworks and benchmarks that support it.
Adding Real-time Features to PHP ApplicationsRonny López
It's possible to introduce real-time features to PHP applications without deep modifications of the current codebase.
Using WAMP you can build distributed systems out of application components which are loosely coupled and communicate in (soft) real-time.
There is no need to learn a whole new language, with the implications it has.
It also opens the door to write reactive, event-based, distributed architectures and to achieve easier scalability by distributing messages to multiple systems.
An introduction to reactive programming concepts and basics. I aim here to show what's reactive programming, why it's used and show some frameworks and benchmarks that support it.
Operating a High Velocity Large Organization with Spring Cloud MicroservicesNoriaki Tatsumi
Noriaki Tatsumi prepares you to build a microservices architecture that's not only reliable, resilient, and scalable but also addresses the challenges large organizations typically face. He dives into the technical details on how Spring Cloud empowers developers to build the patterns and components of microservices foundation quickly.
This webinar lays the foundation for your PHP app. If you have at least one year of PHP experience, this webinar explains these key building blocks for creating and maintaining enterprise-class applications, mobile services, and third-party libraries. It covers: what makes mission-critical PHP different? (including cloud-based solutions); how to maintain your PHP stack; how to ensure code security; and what to do when your system goes down?
Declarative Concurrency with Reactive ProgrammingFlorian Stefan
”Everything is a stream“ - This often cited mantra indicates why Reactive Programming is such a powerful tool for handling data flows in almost every part of an application. Reactive Programming has experienced a significant growth in popularity in recent years. But its growing popularity also leads to a Babylonian confusion: the term ”Reactive“ has become overloaded and ”is now being associated with several different things to different people“ (Jonas Bonér, Viktor Klang). To understand what Reactive Programming is - and what it isn’t - this talk surveys the landscape sharpened by trends like Reactive Streams, Reactive Extensions and Reactive Systems. It then summarizes the basic principles of Reactive Programming by looking at the Reactor library and discusses examples, of how to use this library in a legacy system.
Reactive: Programming -> Systems -> ArchitectureAleksey Izmailov
A summary of Reactive topics.
Mostly based on whitepaper:
"Reactive Programming versus Reactive Systems
Landing on a set of simple Reactive design principles in a sea of constant confusion and overloaded expectations". (By Jonas Bonér and Viktor Klang, Lightbend Inc)
Learn what's coming from the developers building it.
Highlights include:
HTTPv2.0
This update of the current WebDAV HTTP protocol will boost performance while preserving the benefits of providing web access to Subversion.
SVNJ
A rich server-side JAVA API that leverages Subversion's established code base. SVNJ will enable the Subversion community to reach out to millions of JAVA developers to create the same rich functionality and extensibility on the server that's available on the client.
Obliterate
A new feature that cleanly removes obsolete files and other data from Subversion repositories. Obliterate will include comprehensive audit and recovery capabilities to guarantee that history is always available.
Working Copy
New features include centralized metadata storage and improved extensibility. These enhancements will lay the groundwork for offline commits and other capabilities normally associated with distributed version control systems.
Abstract
The idea of this talk is to help development teams to make correct architectural decisions.
Andrei will highlight the basic architectural principles and show ways to achieve architecture that is good enough to cover the project requirements and evolve in the future.
He will also present several cases from real projects, where wrong, missing, or over-sophisticated architecture decisions really hurt the development teams:
- Painful sharing: do shared modules increase reusability or will be the source of problems?
- Microservices are the solution to every problem!
- Non-extensible extensibility: too sophisticated configuration hurts
- Over fine-grained: incorrect splitting to Microservices can make life even harder as with monolith
- Convey horizontal split: how organizational driven split can jeopardise the architecture
- Model-driven: central responsibility blocks and limits the team
- Cargo cult: blindly following patterns and rule can produce an unmaintainable system
- Freestyle architecture: what happens if teams completely ignore architecture
- Improve with less intelligence: smart endpoint and dumb pipes
Abstract
The idea of this talk is to help development teams to make correct architectural decisions.
Andrei will highlight the basic architectural principles and show ways to achieve architecture that is good enough to cover the project requirements and evolve in the future.
He will also present several cases from real projects, where wrong, missing, or over-sophisticated architecture decisions really hurt the development teams:
- Painful sharing: do shared modules increase reusability or will be the source of problems?
- Microservices are the solution to every problem!
- Non-extensible extensibility: too sophisticated configuration hurts
- Over fine-grained: incorrect splitting to Microservices can make life even harder as with monolith
- Convey horizontal split: how organizational driven split can jeopardise the architecture
- Model-driven: central responsibility blocks and limits the team
- Cargo cult: blindly following patterns and rule can produce an unmaintainable system
- Freestyle architecture: what happens if teams completely ignore architecture
- Improve with less intelligence: smart endpoint and dumb pipes
Operating a High Velocity Large Organization with Spring Cloud MicroservicesNoriaki Tatsumi
Noriaki Tatsumi prepares you to build a microservices architecture that's not only reliable, resilient, and scalable but also addresses the challenges large organizations typically face. He dives into the technical details on how Spring Cloud empowers developers to build the patterns and components of microservices foundation quickly.
This webinar lays the foundation for your PHP app. If you have at least one year of PHP experience, this webinar explains these key building blocks for creating and maintaining enterprise-class applications, mobile services, and third-party libraries. It covers: what makes mission-critical PHP different? (including cloud-based solutions); how to maintain your PHP stack; how to ensure code security; and what to do when your system goes down?
Declarative Concurrency with Reactive ProgrammingFlorian Stefan
”Everything is a stream“ - This often cited mantra indicates why Reactive Programming is such a powerful tool for handling data flows in almost every part of an application. Reactive Programming has experienced a significant growth in popularity in recent years. But its growing popularity also leads to a Babylonian confusion: the term ”Reactive“ has become overloaded and ”is now being associated with several different things to different people“ (Jonas Bonér, Viktor Klang). To understand what Reactive Programming is - and what it isn’t - this talk surveys the landscape sharpened by trends like Reactive Streams, Reactive Extensions and Reactive Systems. It then summarizes the basic principles of Reactive Programming by looking at the Reactor library and discusses examples, of how to use this library in a legacy system.
Reactive: Programming -> Systems -> ArchitectureAleksey Izmailov
A summary of Reactive topics.
Mostly based on whitepaper:
"Reactive Programming versus Reactive Systems
Landing on a set of simple Reactive design principles in a sea of constant confusion and overloaded expectations". (By Jonas Bonér and Viktor Klang, Lightbend Inc)
Learn what's coming from the developers building it.
Highlights include:
HTTPv2.0
This update of the current WebDAV HTTP protocol will boost performance while preserving the benefits of providing web access to Subversion.
SVNJ
A rich server-side JAVA API that leverages Subversion's established code base. SVNJ will enable the Subversion community to reach out to millions of JAVA developers to create the same rich functionality and extensibility on the server that's available on the client.
Obliterate
A new feature that cleanly removes obsolete files and other data from Subversion repositories. Obliterate will include comprehensive audit and recovery capabilities to guarantee that history is always available.
Working Copy
New features include centralized metadata storage and improved extensibility. These enhancements will lay the groundwork for offline commits and other capabilities normally associated with distributed version control systems.
Abstract
The idea of this talk is to help development teams to make correct architectural decisions.
Andrei will highlight the basic architectural principles and show ways to achieve architecture that is good enough to cover the project requirements and evolve in the future.
He will also present several cases from real projects, where wrong, missing, or over-sophisticated architecture decisions really hurt the development teams:
- Painful sharing: do shared modules increase reusability or will be the source of problems?
- Microservices are the solution to every problem!
- Non-extensible extensibility: too sophisticated configuration hurts
- Over fine-grained: incorrect splitting to Microservices can make life even harder as with monolith
- Convey horizontal split: how organizational driven split can jeopardise the architecture
- Model-driven: central responsibility blocks and limits the team
- Cargo cult: blindly following patterns and rule can produce an unmaintainable system
- Freestyle architecture: what happens if teams completely ignore architecture
- Improve with less intelligence: smart endpoint and dumb pipes
Abstract
The idea of this talk is to help development teams to make correct architectural decisions.
Andrei will highlight the basic architectural principles and show ways to achieve architecture that is good enough to cover the project requirements and evolve in the future.
He will also present several cases from real projects, where wrong, missing, or over-sophisticated architecture decisions really hurt the development teams:
- Painful sharing: do shared modules increase reusability or will be the source of problems?
- Microservices are the solution to every problem!
- Non-extensible extensibility: too sophisticated configuration hurts
- Over fine-grained: incorrect splitting to Microservices can make life even harder as with monolith
- Convey horizontal split: how organizational driven split can jeopardise the architecture
- Model-driven: central responsibility blocks and limits the team
- Cargo cult: blindly following patterns and rule can produce an unmaintainable system
- Freestyle architecture: what happens if teams completely ignore architecture
- Improve with less intelligence: smart endpoint and dumb pipes
Kill Administrator: Fighting Back Against Admin RightsScriptLogic
We’re not talking about killing the Administrator. That would be you, and that would be wrong. Rather, it’s time we eliminated the role of Administrator from our Windows servers and desktops.
Administrator privileges are Windows’ necessary evil. Why? Standard Windows user rights just aren’t powerful enough to accomplish many needed tasks, so users demand elevated rights for everything. That’s the problem with Administrator: You either have it or you don’t.
With a new approach to delegating administrative privileges, you can granularly elevate privileges in applications and the operating system. Windows itself has such a solution in its built-in AppLocker functionality. AppLocker is a good tool to whitelist apps you’ve approved to run, but it isn’t without its shortfalls.
Join Concentrated Technology’s Greg Shields and ScriptLogic’s Nick Calavancia as they compare the AppLocker approach with ScriptLogic’s Privilege Authority product. You’ll find that finding the right balance requires the right set of tools.
In this webinar, we will cover:
1. Getting to least privilege – killing admin rights
2. Administrative granularity – balancing lockdown with productivity
3. Lockdown rules that work
DevOps Fest 2020. Kohsuke Kawaguchi. GitOps, Jenkins X & the Future of CI/CDDevOps_Fest
CI/CD process has been something your DevOps engineer purpose-built for your team. But with Kubernetes & cloud-native, that’s becoming “legacy.” The rising level of platform abstraction allows all the good practices that the industry has developed over time to be integrated, hidden, and simplified behind just one practice called “GitOps.” That simplified world is what Jenkins X enables.
We will discuss GitOps, Jenkins X, and how that combination drastically simplifies cloud-native web app development. You’ll understand why traditional DevOps is not suitable in a Kubernetes and cloud-native world, explore GitOps principles and discover how they facilitate high-velocity app development.
And finally, Kohsuke will make a fool of himself by talking about the future — now that Jenkins X simplifies the CD process, where is the next frontier?
Software Architecture and Architectors: useless VS valuableComsysto Reply GmbH
Abstract:
This talk introduces definitions of system architecture and proposes a way to achieve "good enough" architecture covers project requirements
Andrei will show several cases from real projects, where wrong, missing or over-sophisticated architecture decisions really hurt the development teams:
Painful sharing: do shared modules increase reusability or will be the source of problems?
Non-extensible extensibility: too sophisticated configuration hurts
Over fine-grained: incorrect splitting to microservices can make life even harder as with monolith
Cargo cult: blindly following patterns and rules can produce an unmaintainable system
Freestyle architecture: what happens if teams completely ignore architecture
Improve with less intelligence: smart endpoint and dumb pipes
We are looking forward to meet many of you in person and have great discussions around this topic!
https://www.meetup.com/de-DE/meetup-group-tfyvuydp/
XP teams try to keep systems fully integrated at all times, and shorten the feedback cycle to minutes and hours instead of weeks or months. The sooner you know, the sooner you can adapt.
Watch our record for the webinar "Continuous Integration" to explore how Azure DevOps helps us in achieving continuous feedback using continuous integration.
Writing software that does what it's supposed to is easy. Becoming successful at delivering software "as-a-Service" is a completely different beast and a significant shift for any organization. Not least because it's an act that spans across multiple disciplines which need to work together and rethink the way they operate.
Join this presentation for some lessons learned from our Cloud Transformation Journey and recommendations around the topics of Cloud Architecture, Operations, Security and Service Management
Build software like a bag of marbles, not a castle of LEGO®Hannes Lowette
If you have ever played with LEGO®, you will know that adding, removing or changing features of a completed castle isn’t as easy as it seems. You will have to deconstruct large parts to get to where you want to be, to build it all up again afterwards. Unfortunately, our software is often built the same way. Wouldn’t it be better if our software behaved like a bag of marbles? So you can just add, remove or replace them at will?
Most of us have taken different approaches to building software: a big monolith, a collection of services, a bus architecture, etc. But whatever your large scale architecture is, at the granular level (a single service or host), you will probably still end up with tightly couple code. Adding functionality means making changes to every layer, service or component involved. It gets even harder if you want to enable or disable features for certain deployments: you’ll need to wrap code in feature flags, write custom DB migration scripts, etc. There has to be a better way!
So what if you think of functionality as loose feature assemblies? We can construct our code in such a way that adding a feature is as simple as adding the assembly to your deployment, and removing it is done by just deleting the file. We would open the door for so many scenarios!
In this talk, I will explain how to tackle the following parts of your application to achieve this goal: WebAPI, Entity Framework, Onion Architecture, IoC and database migrations. And most of all, when you would want to do this. Because… ‘it depends’.
Capability Building for Cyber Defense: Software Walk through and Screening Maven Logix
Dr. Fahim Arif who is the Director R&D at MCS, principal investigator and GHQ authorized consultant for Nexsource Pak (Pvt) Ltd) discussed the capability of building cyber defense in the Data Protection and Cyber Security event that was hosted recently by Maven Logix. In his session he gave the audience valuable information about the life cycle of a cyber-threat discussing what and how to take measures by performing formal code reviews, code inspections. He discussed essential elements of code review, paired programming and alternatives to treat and tackle cyber-threat
Advanced dev ops governance with terraformJames Counts
DevOps project sprawl is real! Large organizations with many teams need to support a variety of configurations from infrastructure governance to domain-specific app deployments, all while enforcing good security practices like least privilege for each team. Maintaining these controls by hand leads to complexity, stagnation, and insecure shortcuts. In this session, you'll learn how Terraform can automate this configuration--using Terraform--and make doing the right thing easy!
Threat Modeling the CI/CD Pipeline to Improve Software Supply Chain Security ...Denim Group
The SolarWinds attack brought additional scrutiny software supply chain security, but concerns about organizations’ software supply chains have been discussed for a number of years. Development organizations’ shift to DevOps or DevSecOps has pushed teams to adopt new technologies in the build pipeline – often hosted by 3rd parties. This has resulted in build pipelines that expose a complicated and often uncharted attack surface. In addition, modern products also incorporate code from a variety of contributors – ranging from in-house developers, 3rd party development contractors, as well as an array open source contributors.
This talk looks at the challenge of developing secure build pipelines. This is done via the construction of a threat model for an example software build pipeline that walks through how the various systems and communications along the way can potentially be misused by malicious actors. Coverage of the major components of a build pipeline – source control, open source component management, software builds, automated testing, and packaging for distribution – is used to enumerate likely attack surface exposed via the build process and to highlight potential controls that can be put in place to harden the pipeline against attacks. The presentation is intended to be useful both for evaluating internal build processes as well as to support the evaluation of critical external vendors’ processes.
Whar are microservices and microservices architecture (MSA) How we reach them? Are they the same or SoA or not? When to use them? What are the key characteristics?
Slides of my talk given in #Gapand2017 in Andorra
Software Architecture for Agile DevelopmentHayim Makabee
Slides of a workshop given at Herzliya on June/2017, organized by ILTAM and IASA Israel. This workshop was dedicated to the topic of Software Architecture in the context of Agile Development. We answered the question: “How much Design Up Front should be done in an Agile project?” Hayim presented his approach of Adaptable Design Up Front (ADUF), describing its rationale, applications in practice and comparison to other approaches such as Emergent Design. He explained why adaptability is essential for the development of complex software systems using Agile methods. The concepts were illustrated through practical software architecture approaches such as micro-services and examples of real software systems that were developed in the past. The workshop also included an exercise on the definition and evolution of the design of an interesting system.
Similar to From silex to symfony and viceversa (20)
"Impact of front-end architecture on development cost", Viktor TurskyiFwdays
I have heard many times that architecture is not important for the front-end. Also, many times I have seen how developers implement features on the front-end just following the standard rules for a framework and think that this is enough to successfully launch the project, and then the project fails. How to prevent this and what approach to choose? I have launched dozens of complex projects and during the talk we will analyze which approaches have worked for me and which have not.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Let's dive deeper into the world of ODC! Ricardo Alves (OutSystems) will join us to tell all about the new Data Fabric. After that, Sezen de Bruijn (OutSystems) will get into the details on how to best design a sturdy architecture within ODC.
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
PHP Frameworks: I want to break free (IPC Berlin 2024)Ralf Eggert
In this presentation, we examine the challenges and limitations of relying too heavily on PHP frameworks in web development. We discuss the history of PHP and its frameworks to understand how this dependence has evolved. The focus will be on providing concrete tips and strategies to reduce reliance on these frameworks, based on real-world examples and practical considerations. The goal is to equip developers with the skills and knowledge to create more flexible and future-proof web applications. We'll explore the importance of maintaining autonomy in a rapidly changing tech landscape and how to make informed decisions in PHP development.
This talk is aimed at encouraging a more independent approach to using PHP frameworks, moving towards a more flexible and future-proof approach to PHP development.
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
4. We are all aspiring software
craftsmen
Aren’t we?
5. We want to build, not only
working software, but also
well-crafted software
6. The reality
• Lack of discipline
• Time pressures
• Long release cycles
• Short release cycles
• New features every day
• Bugs and hot fixes
7. Some of the implications…
• Infiltration of business logic into the delivery
mechanism (or the user interface)
• Untestable systems
• Bad written tests
• Delayed projects
13. • If we don’t have a mechanism to detect when a
violation of that promise occurs…
• Then… in a few development cycles, the new layer
is cluttered with business logic and the old problem
has reappeared
16. Ports and Adapters
• Makes the application domain model central to the
system
• Cleanly decouples and isolates the application
domain model from the system's technical
infrastructure
• Define its relationships with the outside world in
terms of application domain concepts ("ports")
26. –Vaughn Vernon. “Implementing Domain-Driven Design”
“Anything that can help us give
more emphasis to the Core Domain and less
to technology
will likely drive out
more value for the business
and help it achieve an even greater competitive
advantage.”
28. Let’s start
• By building something small
• By building something testable
• By building something easily interchangeable
• With hard boundaries
• With single responsibility everywhere
33. Acceptance Tests
• It is a validation activity – Did we build the right
thing?
• Can instantiate and exercise the domain model
without instantiating any of the technical plumbing
that connects it to the external resources in the real
system
• Can be described in plain English
34. Acceptance Tests
• Ports & Adapters makes it possible to run
acceptance tests directly against the application
domain model
36. An acceptance can instantiate and exercise the domain model
without instantiating any of the technical plumbing that connects it
to the external resources in the real system.
http://www.natpryce.com/articles/000786.html
37. The opposite: instantiate the adapters without the domain model
of the real application. Rather than connecting the adapter to an
object from the real domain model, the test connects it to a fake
implementation
http://www.natpryce.com/articles/000786.html
38. By building something easily
interchangeable
User
HTTP
Adapter
Acceptance
Tests
User
Fake
Analytics
39. With hard boundaries
User
In-App
Purchases
Feature Y
Feature X
Game
Analytics
Kernel
Unit Of Work
Event
Publisher
HTTP Adapter
Silex
Service
Locator
HTTP Adapter
Symfony
Container
Event
Dispatcher
Logger
Logger
Tracker
Container
44. • You shouldn't start a new project with
microservices, even if you're sure your application
will be big enough to make it worthwhile –
@martinfowler
• http://martinfowler.com/bliki/MonolithFirst.html
45. Ports and Adapters
• Ports and Adapters is a coarse-grain OO design
pattern
• It decouples the object model of a system's
application domain from the object models of its
technical domains
• Among other benefits, this lets you write
acceptance tests against the application domain
model directly
46. Ports and Adapters
• Says nothing about distribution between
processes, machines and/or organizations.
• It's concerned with how we structure our objects
within each process
49. Emerald
• Highly opinionated library following the
architectural principles described here
• Not open source yet, but we can see some code
later
50. Principles
• Broken down into independent modules
• Modules don’t interact with other modules
• Modules don’t share runtime services (by their self)
with other modules
• There is no access to global state, or a global
“container” of services
51. Principles
• Modules don’t know anything about the rest of the
world
• They don’t even know that they are running
together with other modules
• Modules don’t interact with other modules
• They have very limited knowledge of what’s going
on in the rest of the system
52. Interacting with the rest of
the world
• Modules either receive commands or queries from
the outside world (adapters)
• This promote CQRS
• Modules publish events, and could react to other
events in the system, but without coupling to other
modules
54. The big picture
User
In-App
Purchases
Feature Y
Feature X
Game
Analytics
Kernel
Command
Query
POST /alliance/123
AllianceCreateCmd
{
id :123,
name: “PHP”,
}
GET /alliance/123/
AllianceMembersQuery
{
id :123
56. Controllers
• POPOs, only have access to the application Kernel
and have only the following responsibilities:
• convert request in queries or commands
• dispatch control to the kernel
• convert back the response to a suitable
representation
57. Container, Event
Dispatcher, etc…
• We need clear separation between all the layer,
better to have them separated
• Application has it own service locator and event
publisher
58. Conclusions
• Do not let any (web) framework guide your
architecture
• Try to solve your problem first, then chose delivery
mechanisms, persistence, etc…
• This kind of architecture can be applied in any
programming language/stack
60. References
• Hexagonal architecture
http://alistair.cockburn.us/Hexagonal+architecture
• Growing Object-Oriented Software Guided by Tests
http://www.growing-object-oriented-software.com/
• Visualising Test Terminology
http://www.natpryce.com/articles/000772.html
• Ports and Adapters With No Domain Model
http://www.natpryce.com/articles/000786.html
• http://martinfowler.com/bliki/MonolithFirst.html
