Agile Architecture Questions
Agile architecture means how enterprise architects, system architects and software architects apply architectural practice in agile software development.
An agile architect should handle a regular set of questions for each application he is working on.
Each digital product encounters similar requirements and shall provide good solutions for the most acute restrictions.
The goal is to define an evolvable minimal architecture. New functional and non-functional requirements shall be realized with minimal changes in the design.
Do not try to solve all the problems you can think about.
Solve stated requested features with the simplest approach you can think about. Remember, simple solutions can be very elegant and extensible.
|
The system you are building as probably hundreds of siblings in the world. Study the available solutions to understand the tradeoffs of these systems. Open source permeates the software industry. You shall be able to read public source code and build the solution locally. Identify weaknesses and improvement areas. Now you have the first draft of your architecture. |
Internationalization, Localization and Accessibility Themes
- What user interface should we define?
-
Acknowledge that a software developer is missing the formal education to create good user interfaces. You need a user interface and usability trained professional to create and refine stunning user interfaces. Select technological solutions compatible with your technology stack [1].
- How do we implement accessibility laws and requirements?
-
Your usability expert should have the tools to implement the legal requirements. I strongly recommend that each architect attend minimal training in internationalization, localization and accessibility matters. internationalization i18n, localization l16n, accessibility" a11y regulations and good practices.
- How should we translate user interface data?
-
Your organization shall implement a translation process for all involved artifacts. Translation activities are often outsourced to specialized companies. You should integrate their processes in your toolchain.
Scalability Themes
- How do the system components communicate with each other?
-
Model with asynchronous communication and idempotent commands. The Actor Model is key to simplicity and performance. Use topics when you have multiple receivers or senders.
Avoid multi-threading synchronization headaches with locks, mutexes, or semaphores as long as possible.
- How can we scale the solution?
-
Select a framework providing horizontal scaling. The preferred abstraction model is the Actor Model. A web server library such as Jetty supports unlimited parallel user sessions without writing one line of code. A robotic framework such as ROS-2 delivers concurrency on node level for free.
- Should we prepare for sharding, geolocation, vertical scaling?
-
Try to design business logic and data persistence along with natural slicing rules. It should be easy to deploy an instance of your solution per country. For Europe, you would get a scaling factor of thirty for free.
- How do we ensure the requested response times?
-
Fitness functions and monitoring are the current good practices.
Consider architecting your digital solution using domain driven design approach [1, 2, 3]. The method heavily emphasizes the partitioning along bounded domains to create independent components.
The solution naturally scales horizontally. If necessary, the final application can be deployed as a set of distributed services footnote:[The approach is promoted in multiple technical stacks such as Java Spring framework Modulith.
Security Themes
- How should we log activities and why?
-
Each bounded domain shall implement their own log record repository. The structure of the records should be standardized to ease the effort of understanding the behavior of the whole application. The various repositories must be aggregated and have a total ordering. Either your system has a global time with the required resolution, often in the area of a few microseconds. Or you write all your log to an asynchronous aggregator. The order of arrival provides the implicit ordering of the log records.
- How should we audit activities and why?
-
Review your internal documented solution
- How is security implemented?
-
Review your internal documented solution
- How do we authenticate and authorize?
-
JWT and OAuth are regular approach for webservers.
Persistent Data Themes
- How should we persist data?
-
Review your internal documented solution.
Start simple. Eclipse Store persists Java objects in a file or a database without any changes in your domain model. The persistence code is around twenty lines of code. - How do we journal operations performed in the program?
-
Review your internal documented solution.
Know your logging frameworks. - How is reporting provided?
-
Review your internal documented solution.
- How do we import data into the system?
-
Review your internal documented solution.
|
Try to archive data in a format that is straightforward to read and understand. I strongly recommend a TSV and JSON format. Please provide the corresponding JSON schema for the JSON data. Group data on a per-tenant basis. The approach simplifies recovery and migration of data for a specific tenant. You can much better security and confidentially of the data almost for free. |
Release and Migration Themes
- How do we release a version of the product?
-
Review your internal documented solution.
- Do we support backward compatibility?
-
Review your internal documented solution.
- How do we implement backward compatibility?
-
Review your internal documented solution.
- How do we migrate data to a new release?
-
Review your internal documented solution.
- How do we archive data?
-
Review your internal documented solution.
Tips
You are a talented software architect. You are in charge to define the blueprint of your digital solution. Use your training and talent to create a good solution that is straightforward to understand and maintain.
The LeSS movement has described how agile architecture could be performed [4] [5]. Create a workable blueprint. Invest in the evolution and improvement of the solution.
There is no single development in either technology or management technique, which by itself promises even one order of magnitude [tenfold] improvement within a decade in productivity, in reliability, in simplicity.
— Freds Brooks
No Silver Bullet
No Silver Bullet
You shall create a similar architecture checklist to the above one. Document your preferred approaches for each question. Remember to consult seminal literature, good practices [2] and design patterns.
You will be able to solve almost all the design challenges you will be confronted with. A good approach is to start with a modular monolith [1]. Domain-Driven Design is a proven good practice for designing the domain model and partitioning your solution.
Links
-
[1] Modular Monoliths are the new Graal Marcel Baumann. 2022.
-
[2] Software Developer Assumptions. Marcel Baumann. 2023.
-
[3] Behavior Driven Design. Marcel Baumann. 2022.
-
[4] Agile Design Modeling. Marcel Baumann. 2021.
-
[5] Agile Architecture Principles Marcel Baumann. 2019.
-
[6] Actor Model Marcel Baumann, 2024.
References
[1] E. Evans, Domain-driven design. Addison-Wesley, 2004 [Online]. Available: https://www.amazon.com/dp/0321125215
[2] V. Vernon, Implementing Domain driven Design. Addison-Wesley Professional, 2012 [Online]. Available: https://www.amazon.com/dp/B00BCLEBN8
[3] V. Vernon, Domain-Driven Design Distilled. Addison-Wesley Professional, 2016 [Online]. Available: https://www.amazon.com/dp/B01JJSGE5S/
[4] V. Vernon, Reactive Messaging Patterns with the Actor Model : Applications and Integration in Scala and Akka. Addison-Wesley Professional, 2015 [Online]. Available: https://www.amazon.com/dp/B011S8YC5G
[5] D. Betts, J. Dominguez, G. Melnik, F. Simonazzi, and M. Subramanian, Exploring CQRS and Event Sourcing: A journey into high scalability, availability, and maintainability with Windows Azure (Microsoft patterns & practices). Microsoft patterns & practices [Online]. Available: https://www.amazon.com/dp/1621140164
[6] N. Ford, R. Parsons, and P. Kua, Building Evolutionary Architectures: Automated Software Governance, Second. O’Reilly Media, 2023 [Online]. Available: https://www.amazon.com/dp/B0BN4T1P27
[7] N. Ford, Software architecture, First edition. Cambridge, Massachusetts: The MIT Press, 2021 [Online]. Available: https://www.amazon.com//dp/1492086894
[8] A. Scott and P. J. Sadalage, Refactoring Databases. Addison-Wesley Professional, 2006 [Online]. Available: https://www.amazon.com/dp/B001QAP36E
1. Beware that browser-based JavaScript solutions require major rework of the solution at least every eighteen months. The pace of change in frameworks such as Angular, React, Vue, jQuery is stunning. Supported standards in browsers are evolving.