Directory¶
This directory provides a comprehensive, searchable inventory of all 77 evaluated technologies, patterns, platforms, and utilities tracked on our Technology Radar. Each entry includes its assigned maturity ring, domain tags, architectural rationale, and direct links to engineering guidelines.
For the visual interactive map, see the Interactive Technology Radar. For governance rules and ring criteria, see Overview & Methodology.
Radar Distribution Summary¶
| Quadrant | Adopt | Trial | Assess | Hold | Total |
|---|---|---|---|---|---|
| Languages & Frameworks | 11 | 0 | 2 | 0 | 13 |
| Platforms & Operations | 6 | 0 | 1 | 0 | 7 |
| Methods & Patterns | 35 | 0 | 11 | 1 | 47 |
| Tools & Utilities | 7 | 1 | 2 | 0 | 10 |
| Total | 59 | 1 | 16 | 1 | 77 |
Distribution of technologies across quadrants and maturity rings.
Languages & Frameworks¶
Dedicated quadrant deep-dive: Languages & Frameworks
| # | Technology | Ring | Tags | Description & Rationale | Reference |
|---|---|---|---|---|---|
| 8 | C | ADOPT | systems-programming, embedded-systems, performance |
C is a general-purpose, procedural programming language that has been a cornerstone of software development since its creation in the early 1970s. Known for its efficiency and control over system resources, C is particularly useful for system programming, such as operating systems, device drivers, and embedded systems. Its syntax and structure have influenced many other languages, making it a foundational language for software engineers. | C Coding Standards (GU-009) |
| 6 | C# | ADOPT | object-oriented, cross-platform, microsoft-ecosystem |
C# is a modern, object-oriented programming language developed by Microsoft as part of its .NET initiative. It is designed for building a wide range of applications, from web and mobile apps to enterprise software and cloud-based solutions. C# is known for its ease of use, safety, and versatility, making it a popular choice among developers. | — |
| 7 | C++ | ADOPT | object-oriented, performance-critical, systems-programming |
C++ is a general-purpose programming language known for its high performance and efficiency. It supports object-oriented, procedural, and generic programming, making it versatile for a wide range of applications. C++ is particularly useful for systems programming, game development, and applications requiring real-time processing or resource-constrained environments, such as embedded systems. Its ability to directly manipulate hardware resources, coupled with extensive libraries and frameworks, makes it an essential language in areas where performance is critical. | C Coding Standards (GU-009) |
| 32 | Go (golang) | ADOPT | concurrency, performance, simplicity |
Go, also known as golang, is a statically typed, compiled programming language designed by Google. It is renowned for its simplicity, efficiency, and strong support for concurrent programming, making it a popular choice for developing scalable and high-performance applications. Go’s syntax is clean and concise, which reduces the complexity associated with managing large codebases. Its garbage collection, strict dependency management, and built-in testing capabilities enhance developer productivity and code reliability. | — |
| 34 | GraphQL | ADOPT | api-design, data-fetching, flexibility |
GraphQL is a query language for your APIs and a runtime for executing those queries by using a type system you define for your data. It provides an alternative to REST, enabling clients to request exactly the data they need, in the shape they need it. This approach reduces over-fetching and under-fetching of data, a common problem with traditional REST APIs. | — |
| 37 | JSON | ADOPT | data-interchange, lightweight-format |
JSON (JavaScript Object Notation) is a lightweight data interchange format that is easy for humans to read and write and easy for machines to parse and generate. It is language-independent but uses conventions that are familiar to programmers of the C family of languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many others. JSON is widely adopted due to its simplicity and flexibility in representing data structures, making it a staple in web development and various APIs. | — |
| 42 | Markdown | ADOPT | documentation, markup-language |
Markdown is a lightweight markup language that allows users to format plain text using a simple syntax. It is widely used for creating formatted text using a plain text editor, making it a popular choice for documentation, readme files, blog posts, and more. Its simplicity and ease of use make it accessible to users who may not have extensive technical knowledge, while still being powerful enough for more complex formatting needs. | — |
| 56 | Python | ADOPT | programming-language, high-level, versatile |
Python is a high-level, interpreted programming language known for its simplicity and readability, making it an excellent choice for beginners and experienced developers alike. Its extensive standard library and vibrant ecosystem of third-party packages enable rapid development in various domains, including web development, data analysis, artificial intelligence, and scientific computing. | Python Standards (GU-016) |
| 60 | Rust | ADOPT | systems-programming, memory-safety, concurrency |
Rust is a systems programming language that aims to provide memory safety without sacrificing performance. It is designed to compete with traditional languages like C and C++ by offering powerful abstractions while ensuring safety through its unique ownership model. Rust is particularly useful in contexts requiring high performance and safety, such as embedded systems, operating systems, and game engines. Its rich type system and emphasis on concurrency make it an excellent choice for developing robust and efficient applications. | — |
| 75 | YAML | ADOPT | data-serialization, configuration |
YAML, which stands for “YAML Ain’t Markup Language,” is a human-readable data serialization standard that is commonly used for configuration files and data interchange between programming languages. Its concise and easy-to-read syntax makes it an excellent choice for configuration files and data serialization, particularly in environments where developers and system administrators need to work closely together, such as in DevOps practices. | — |
| 55 | protobuf | ADOPT | serialization, cross-platform, performance |
Protocol Buffers (protobuf) is a language-neutral, platform-neutral, extensible mechanism for serializing structured data. Developed by Google, it is widely adopted for its efficiency in data serialization, especially in scenarios where performance and portability are crucial. Protobuf offers a compact binary format, which reduces the size of the payload and improves the speed of data transmission compared to traditional text-based formats like JSON or XML. | Constrained Binary Payloads Standard (GU-027) |
| 11 | CertC | ASSESS | safety-critical, embedded-systems |
CertC is a programming language extension and a set of guidelines designed to enhance the safety and reliability of C code, particularly in safety-critical and embedded system environments. Its main purpose is to address common pitfalls in C programming, such as buffer overflows and undefined behaviors, which can lead to catastrophic failures in critical systems. By providing stricter rules and additional checks, CertC helps developers write more robust and predictable code. | — |
| 46 | MISRA C++ | ASSESS | safety-critical, coding-guidelines |
MISRA C++ is a set of guidelines designed to facilitate the safe and secure use of the C++ programming language in critical systems. Originally developed for the automotive industry, it has been widely adopted in other sectors, such as aerospace and industrial automation, where software reliability is paramount. MISRA C++ provides a collection of best practices that help developers avoid common pitfalls and undefined behaviors in C++ programming, which are crucial in environments where software failure can have severe consequences. | MISRA C Guidelines (GU-012) |
Complete directory of Languages & Frameworks blips.
Platforms & Operations¶
Dedicated quadrant deep-dive: Platforms & Operations
| # | Technology | Ring | Tags | Description & Rationale | Reference |
|---|---|---|---|---|---|
| 17 | Docker | ADOPT | containerization, devops, microservices |
Docker is a platform that allows developers to automate the deployment of applications inside lightweight, portable containers. These containers include everything needed to run an application, which ensures consistency across different development and production environments. Docker is particularly useful for streamlining development workflows and simplifying operations by providing a consistent environment for running applications. | — |
| 30 | FreeRTOS | ADOPT | real-time-operating-system, embedded-systems, IoT |
FreeRTOS is a real-time operating system kernel designed for embedded devices and microcontrollers. It provides a lightweight and robust platform that supports a wide range of hardware architectures, making it ideal for resource-constrained environments common in IoT (Internet of Things) applications. FreeRTOS enables developers to create reliable, real-time applications with features like task management, inter-task communication, and memory management, all while maintaining a small footprint. | Architecture Handbook: IoT & Embedded (GD-002) |
| 33 | Google Cloud Platform | ADOPT | cloud |
GCP provides scalable cloud solutions for modern architectures. | Architecture Handbook: Cloud (GD-002) |
| 49 | MQTT | ADOPT | IoT, messaging-protocol |
MQTT (Message Queuing Telemetry Transport) is a lightweight, publish-subscribe network protocol commonly used for machine-to-machine (M2M) communication and is a cornerstone in the Internet of Things (IoT) ecosystems. It is designed for connections with remote locations where a small code footprint is required, or the network bandwidth is limited. MQTT is particularly useful for its simplicity and efficiency in constrained environments, making it ideal for IoT applications where devices need to communicate reliably over potentially unreliable networks. | IoT Fleet Operations Handbook (GD-006) |
| 64 | Serverless | ADOPT | cloud-computing, scalability, cost-efficiency |
Serverless computing is a cloud-computing execution model where the cloud provider dynamically manages the allocation and provisioning of servers. By allowing developers to run code in response to events without the complexity of managing infrastructure, serverless abstracts away the server management, enabling teams to focus more on writing code and less on server maintenance. This approach can lead to significant cost savings, as it inherently scales with demand and charges are based only on the compute time consumed. | — |
| 76 | Yocto Project | ADOPT | linux |
Yocto Project helps build custom Linux-based systems for embedded applications. | Architecture Handbook: IoT & Embedded (GD-002) |
| 13 | CloudEvents | ASSESS | event-driven, interoperability |
CloudEvents is a specification for describing event data in a common way, aiming to simplify event-driven systems and improve interoperability between different services and platforms. By standardizing the structure and metadata of events, CloudEvents enables easier integration and processing across diverse environments, reducing the complexity of event-driven architectures. | — |
Complete directory of Platforms & Operations blips.
Methods & Patterns¶
Dedicated quadrant deep-dive: Methods & Patterns
| # | Technology | Ring | Tags | Description & Rationale | Reference |
|---|---|---|---|---|---|
| 1 | ADRs | ADOPT | documentation, decision-making |
Architectural Decision Records (ADRs) are a proven method for capturing important architectural decisions made during a project. By documenting these decisions, teams can ensure that the rationale behind key architectural choices is recorded for future reference. This practice enhances communication among team members and stakeholders, providing a clear historical context that aids in understanding the evolution of a system’s architecture. | ADR Authoring Guide (GU-005) |
| 2 | Agile | ADOPT | software-development, project-management |
Agile is a set of principles and practices for software development that emphasizes flexibility, collaboration, and customer satisfaction. It involves iterative development, where requirements and solutions evolve through the collaborative efforts of cross-functional teams. Agile methodologies, such as Scrum and Kanban, focus on delivering small, incremental changes quickly, allowing for frequent reassessment and adjustment. This approach enhances the ability to respond to change effectively, making it a valuable method in dynamic and complex environments. In the methods-and-patterns quadrant, Agile is placed in the adopt ring due to its widespread acceptance and proven success in improving project outcomes and fostering innovation across various industries. | Agile Requirements & User Stories (GU-024) |
| 4 | AsyncAPI | ADOPT | event-driven-architecture, api-specification |
AsyncAPI is an open-source initiative that provides a specification for defining event-driven architectures. Similar to how OpenAPI specifies RESTful APIs, AsyncAPI focuses on asynchronous APIs, allowing developers to standardise the communication between microservices and other components in distributed systems. It is highly useful for creating a clear, machine-readable contract for services that utilise messaging systems such as Kafka, MQTT, or RabbitMQ. | — |
| 5 | Barr Group Coding Guidelines | ADOPT | embedded-systems, safety-critical |
The Barr Group Coding Guidelines are a set of coding standards specifically designed for the development of embedded system software. These guidelines emphasize the importance of writing clear, maintainable, and reliable code to ensure the safety and efficiency of embedded systems, which are often used in critical applications like automotive, medical devices, and industrial control systems. | — |
| 10 | C4 | ADOPT | software-architecture, documentation, modeling |
The C4 model is a framework for visualizing the architecture of software systems. It provides a set of hierarchical diagrams, namely Context, Container, Component, and Code, that help teams understand and communicate the structure and design of their software. By using these diagrams, teams can ensure that everyone—from developers to stakeholders—has a clear and consistent understanding of how the system is structured and how its components interact. | C4 Architecture Modelling Guide (GD-001) |
| 9 | C4 Model | ADOPT | architecture |
C4 Model provides a simple, hierarchical way to visualize architecture. | C4 Architecture Modelling Guide (GD-001) |
| 12 | CICD | ADOPT | automation, devops, software-development |
Continuous Integration and Continuous Deployment (CICD) is a set of practices aimed at improving the software development lifecycle by automating the process of integrating code changes and deploying them to production. It is particularly useful for ensuring that software is consistently built, tested, and deployed, reducing the risk of human error and speeding up the delivery of new features and bug fixes. | — |
| 22 | DRY (Don’t Repeat Yourself) | ADOPT | software-design-principle, code-quality |
DRY (Don’t Repeat Yourself) is a fundamental software design principle aimed at reducing the repetition of code and logic within a system. By emphasizing the elimination of redundancy, DRY encourages developers to create more maintainable, scalable, and efficient codebases. It is particularly useful in preventing the proliferation of bugs, as updates and changes only need to be made in a single location rather than multiple places. This principle is especially relevant in the “methods-and-patterns” quadrant, as it pertains to the overall approach to structuring and organizing code. Being in the “adopt” ring highlights its established importance and widespread acceptance in modern software development practices. DRY’s emphasis on clean and maintainable code aligns with best practices for improving code quality and long-term sustainability of software projects. | Fundamental Software Architecture Principles (GU-019) |
| 16 | Diátaxis | ADOPT | documentation, knowledge-management |
Diátaxis is a systematic framework for organizing and writing technical documentation, aimed at improving the clarity and usability of documentation by categorizing content into four distinct types: tutorials, how-to guides, technical references, and explanations. This method helps writers and developers create comprehensive and user-friendly documentation, ensuring that users can find the right information at the right time. | — |
| 19 | DoD | ADOPT | software-development, agile |
The Definition of Done (DoD) is a key concept in Agile methodologies that refers to a shared understanding among the team about what it means for a piece of work to be considered complete. It is useful because it ensures that everyone has clarity on the quality criteria and the necessary steps to achieve that quality, which helps in delivering consistent and predictable outcomes. In the methods-and-patterns quadrant, DoD is crucial as it provides a framework to guide the development process, ensuring alignment and reducing ambiguity. By adopting DoD, teams can improve their collaboration, enhance the quality of deliverables, and increase stakeholder satisfaction. | Definition of Done (DoD) Guide (GU-003) |
| 18 | Docs as code | ADOPT | documentation, collaboration, version-control |
Docs as code is a methodology that applies software development practices to documentation. This approach involves using tools such as version control systems (e.g., Git) to manage and collaborate on documentation in the same way developers work on code. It encourages the use of plain text formats, such as Markdown or reStructuredText, which can be easily tracked, reviewed, and modified. | Docs-as-Code Guide (GU-010) |
| 20 | Domain-driven design | ADOPT | software-architecture, design-patterns |
Domain-driven design (DDD) is a strategic approach to software development that emphasizes collaboration between technical and domain experts to create a model that reflects the business domain. It focuses on understanding the core domain, creating a shared language (ubiquitous language), and structuring the codebase around the business concepts to improve alignment between software design and business needs. | — |
| 24 | ETSI EN 303 645 | ADOPT | IoT-security, cybersecurity-standards |
ETSI EN 303 645 is a cybersecurity standard developed by the European Telecommunications Standards Institute (ETSI) for consumer Internet of Things (IoT) devices. It establishes a set of baseline requirements to ensure devices are secure by design, addressing key areas such as data protection, software updates, and vulnerability reporting. This standard is useful as it provides manufacturers with a clear framework to mitigate security risks, enhancing consumer trust and protecting user data. In the methods-and-patterns quadrant, ETSI EN 303 645 is particularly relevant as it sets fundamental guidelines for developing secure IoT devices, emphasizing the need for security considerations during the design phase. The adoption of this standard is encouraged due to the increasing prevalence of IoT devices and the associated security challenges, making it crucial for organizations involved in IoT development to prioritize security best practices. | Architecture Handbook: Security & Standards (GD-002) |
| 23 | Edge Architectures for IoT | ADOPT | edge-computing, IoT, distributed-systems |
Edge Architectures for IoT involve deploying computational resources closer to the data source in IoT ecosystems, rather than relying solely on centralized cloud data centers. This approach aims to reduce latency, improve bandwidth efficiency, and enhance data privacy by processing data locally or at the edge of the network. As IoT devices proliferate, generating vast amounts of data, edge architectures become crucial for real-time analytics and decision-making. By adopting edge architectures, organizations can ensure more responsive and reliable IoT systems, making it a vital method and pattern in the modern technological landscape. The adoption ring signifies its growing importance and maturity in the industry, as businesses increasingly look to optimise their IoT deployments for performance and cost-effectiveness. | IoT Endpoint & Gateway Architecture Handbook (GD-005) |
| 26 | Event Driven | ADOPT | asynchronous, scalability, reactive-programming |
Event Driven architecture is a design paradigm that emphasizes the production, detection, consumption, and reaction to events. An event can be defined as a significant change in the state of a system, and this approach is particularly useful for building scalable and decoupled systems. By adopting an Event Driven approach, systems can achieve greater responsiveness and flexibility, as components can operate independently and asynchronously, reacting to changes as they occur. | — |
| 29 | Event Streaming | ADOPT | real-time-data, scalability, distributed-systems |
Event Streaming is a data processing paradigm that treats data as a continuous stream of events, allowing for real-time data processing and analysis. This approach is particularly useful for applications that require immediate insights from data, such as fraud detection, real-time analytics, and monitoring systems. By adopting event streaming, organizations can build scalable and responsive systems that react to data changes in real-time, rather than processing data in batches. | — |
| 28 | Event storming | ADOPT | collaborative-design, domain-driven-design |
Event storming is a workshop-based method used to quickly explore complex business domains by focusing on domain events. It is particularly useful for building a shared understanding among cross-functional teams, including developers, domain experts, and stakeholders. By identifying key events that occur within a system, teams can collaboratively map out processes and uncover insights that lead to better software design and implementation. | — |
| 25 | Event-Driven Architecture (EDA) | ADOPT | scalability, real-time-processing |
Event-Driven Architecture (EDA) is a design paradigm in which decoupled systems communicate through the production and consumption of events. It is particularly useful for building scalable and responsive systems, as it allows for real-time data processing and asynchronous communication. EDA is increasingly relevant in the methods-and-patterns quadrant due to its ability to handle high volumes of data and its fit with modern distributed systems. By adopting EDA, organizations can create systems that are more agile and responsive to changes, facilitating innovation and improving user experiences. Its relevance in the “adopt” ring suggests that it is a well-established and effective approach that is recommended for widespread use across various industries. | Architecture Handbook: Patterns (GD-002) |
| 39 | KISS (Keep It Simple, Stupid) | ADOPT | simplicity, efficiency, design-principle |
KISS, an acronym for “Keep It Simple, Stupid,” is a design principle that emphasizes simplicity in design and implementation. It advocates for avoiding unnecessary complexity, suggesting that systems function best if they are kept simple rather than made complicated. This principle is applicable across various fields, including software development, engineering, and user interface design. | Fundamental Software Architecture Principles (GU-019) |
| 38 | Kanban | ADOPT | agile, project-management, workflow-optimization |
Kanban is a popular workflow management method designed to help visualize work, maximise efficiency, and improve continuously. It is widely adopted in various industries, especially in software development, as part of Agile methodologies. Kanban uses visual cues—typically through a board divided into columns that represent different stages of a process—to track work items as they progress. This visualization allows teams to manage work by balancing demands with available capacity and identifying bottlenecks in the workflow. | — |
| 40 | Layered Architecture | ADOPT | architecture-pattern, software-design |
Layered Architecture is a widely used architectural pattern in software design that organizes the system into a series of layers, each with a distinct responsibility. This pattern typically includes layers such as presentation, business logic, and data access. The primary advantage of Layered Architecture is its ability to separate concerns, making systems more modular, maintainable, and scalable. Each layer can be developed, tested, and maintained independently, allowing teams to work on different parts of the system simultaneously without significant interference. | — |
| 41 | Lightweight Architecture Evaluations | ADOPT | architecture, evaluation, agile |
Lightweight Architecture Evaluations refer to a streamlined approach to assessing and reviewing software architecture. Unlike traditional, exhaustive architectural reviews, this method focuses on agility, enabling teams to quickly evaluate architectural decisions without extensive documentation or formal processes. This approach is especially useful in agile and fast-paced development environments, where time and resources for detailed analysis may be limited. In the “methods-and-patterns” quadrant, Lightweight Architecture Evaluations help teams stay responsive to change and ensure that architectural decisions align with evolving project needs. The “adopt” ring suggests that this practice has proven benefits and should be considered a standard approach for teams seeking to maintain agility while ensuring sound architectural principles. | — |
| 47 | MISRA C | ADOPT | safety-critical, coding-standard |
MISRA C is a set of software development guidelines for the C programming language, developed by the Motor Industry Software Reliability Association (MISRA). It is widely adopted in industries where safety and reliability are paramount, such as automotive, aerospace, and medical devices. The guidelines aim to facilitate code safety, portability, and reliability in the embedded systems environment by imposing restrictions on the use of certain C language features that can lead to unsafe or unpredictable behaviour. | MISRA C Guidelines (GU-012) |
| 45 | Microservices | ADOPT | architecture, scalability, resilience |
Microservices is an architectural style that structures an application as a collection of loosely coupled services, each of which implements a business capability. This approach enhances flexibility and scalability, allowing for the independent deployment of services, which can be developed, tested, and deployed independently by different teams. | Architecture Handbook: Patterns (GD-002) |
| 48 | Modular Monolith | ADOPT | architecture, software-design, scalability |
The Modular Monolith is a software architecture pattern that emphasizes structuring a monolithic application into distinct modules, each encapsulating a specific domain or functionality. Unlike traditional monoliths, where all components are intertwined, a Modular Monolith promotes a high degree of modularity within a single deployable unit. This approach allows for clearer boundaries, easier maintenance, and the possibility of gradually transitioning to a microservices architecture if needed. | Architecture Handbook: Patterns (GD-002) |
| 52 | OWASP | ADOPT | security, best-practices |
The Open Web Application Security Project (OWASP) is an essential resource in the field of web application security. It is a non-profit foundation that works to improve the security of software through community-driven open-source software projects, hundreds of local chapters worldwide, tens of thousands of members, and leading educational and training conferences. OWASP is renowned for its comprehensive resources such as the OWASP Top Ten, a regularly updated list of the most critical security risks to web applications. | — |
| 53 | PEP 8 | ADOPT | coding-standards, python |
PEP 8 is the style guide for Python code, providing conventions on how to format Python code for maximum readability. It is widely adopted in the Python community, ensuring consistency across diverse codebases. PEP 8 covers various aspects, including indentation, naming conventions, and best practices for writing clear and maintainable code. | — |
| 57 | REST | ADOPT | web-architecture, api-design |
REST (Representational State Transfer) is an architectural style that is widely used for designing networked applications. It leverages standard HTTP methods, such as GET, POST, PUT, and DELETE, to facilitate communication between clients and servers. RESTful services are stateless and typically return data in formats like JSON or XML, making them highly interoperable and scalable. | — |
| 61 | Scrum | ADOPT | agile, project-management, team-collaboration |
Scrum is an agile framework for managing complex projects, primarily focused on software development. It facilitates a flexible, iterative approach where work is broken down into sprints, typically lasting two to four weeks. Scrum emphasizes collaboration, accountability, and continuous improvement, making it an essential tool for teams aiming to deliver high-quality software efficiently. The framework includes defined roles (such as Scrum Master and Product Owner), events (such as daily stand-ups and sprint reviews), and artifacts (like product backlogs) to ensure transparency and enhance productivity. | — |
| 68 | TOGAF | ADOPT | enterprise-architecture, best-practices |
TOGAF, which stands for The Open Group Architecture Framework, is a comprehensive framework used for developing and managing enterprise architecture. It is widely adopted by organizations to improve business efficiency and ensure that IT aligns with business objectives. As a key player in the methods-and-patterns quadrant, TOGAF provides a structured approach for organizing and governing information technology infrastructure. | — |
| 69 | UML Modelling | ADOPT | design |
Unified Modelling Language (UML) is a standard way to visualize software architecture. | — |
| 74 | YAGNI (You Aren’t Gonna Need It) | ADOPT | software-development, agile-practices |
YAGNI (You Aren’t Gonna Need It) is a fundamental principle of agile software development that encourages developers to avoid adding functionality until it is necessary. By adhering to YAGNI, teams can maintain a lean codebase, reduce complexity, and focus on delivering features that provide immediate value to the user. This principle is particularly useful in iterative development environments where requirements can change rapidly, and maintaining flexibility is crucial. Within the methods-and-patterns quadrant, YAGNI is a foundational practice, promoting efficient workflow and resource use. It is recommended for adoption as it aligns with the modern emphasis on agility and responsiveness in software development. Implementing YAGNI can help organizations avoid over-engineering and concentrate efforts on current needs, ensuring that development remains focused and productive. | Fundamental Software Architecture Principles (GU-019) |
| 3 | arc42 | ADOPT | software-architecture, documentation |
arc42 is a template for documenting software and system architectures. It is designed to help architects efficiently communicate design decisions and structural concepts without being overly prescriptive. The template is structured to cover all relevant aspects of an architecture, including requirements, constraints, quality goals, and the rationale behind architectural decisions. | — |
| 35 | gRPC | ADOPT | remote-procedure-call, microservices |
gRPC is a high-performance, open-source universal remote procedure call (RPC) framework developed by Google. It uses HTTP/2 for transport, Protocol Buffers as the interface description language, and provides features such as authentication, load balancing, and more. gRPC is particularly useful in microservices architectures, where it enables efficient and language-agnostic communication between services. Its ability to support multiple languages makes it a versatile choice for distributed systems. | — |
| 50 | oauth2 | ADOPT | authentication, security |
OAuth2 is an open standard for access delegation commonly used to grant websites or applications limited access to user information on another website without exposing the user’s credentials. It is particularly significant in the realm of authentication and authorisation protocols, making it a pivotal method in securing web applications and APIs. By enabling secure token-based authentication, OAuth2 allows developers to build robust security layers, enhancing user privacy and data protection. | — |
| 15 | CQRS | ASSESS | architecture, design-pattern |
Command Query Responsibility Segregation (CQRS) is a design pattern that separates the read and write operations of a data store into distinct models. This separation is useful in systems that require scalability and have complex business logic, as it allows for optimized query performance and simplifies the management of complex domain logic. CQRS is particularly relevant in the methods-and-patterns quadrant because it provides a strategic approach to handling data operations in software architecture. It is placed in the assess ring, indicating that while it shows promise and can address specific architectural challenges, it should be evaluated carefully for suitability within the context of a project’s requirements. CQRS can be especially beneficial when combined with Event Sourcing to provide a complete history of changes to the system’s state. | — |
| 21 | DoR | ASSESS | agile, project-management |
The Definition of Ready (DoR) is a critical concept in agile project management that ensures a backlog item is prepared for execution by the development team. It sets a checklist of conditions that must be met before work can begin on a particular task, thereby reducing ambiguities and improving the chances of successful delivery. In the context of methods and patterns, DoR plays a significant role in enhancing workflow efficiency and team alignment. By assessing the DoR, teams can ensure that they have a clear understanding of the requirements, acceptance criteria, and necessary resources, ultimately leading to more predictable and manageable development cycles. This makes it an essential practice for teams striving to improve their agile processes and deliver high-quality software consistently. | Definition of Ready (DoR) Guide (GU-004) |
| 27 | Event Sourcing | ASSESS | data-management, system-architecture |
Event Sourcing is a method of capturing all changes to the state of an application as a sequence of events. Instead of storing just the current state, every change is recorded as an immutable event, which can be replayed to reconstruct past states or derive new information. This approach is useful for maintaining a clear audit trail, enabling system scalability, and supporting complex business logic by reconstructing states at any point in time. | — |
| 36 | ISO 30141 | ASSESS | IoT, architecture, standards |
ISO 30141 is an international standard that provides a reference architecture for the Internet of Things (IoT). It offers a framework to design IoT systems with a focus on interoperability, connectivity, and security. This standard is useful because it establishes a common understanding and approach to developing IoT solutions, which is crucial given the increasing complexity and scale of IoT deployments. | — |
| 58 | RFC9457 | ASSESS | networking, security, internet-standards |
RFC9457 is a significant document in the realm of Internet standards, focusing on improving security protocols within networking systems. It provides a comprehensive framework for enhancing secure communications across different platforms and operations. RFC9457 is essential for developers and network architects who need to ensure their systems are compliant with modern security standards, particularly in an era where cyber threats are increasingly sophisticated. | — |
| 62 | SEI ATAM | ASSESS | architecture-evaluation, software-quality |
The Software Engineering Institute’s Architecture Tradeoff Analysis Method (SEI ATAM) is a systematic approach used for evaluating software architectures. It is particularly useful in identifying architectural risks early in the development process and provides a framework for understanding how well an architecture meets its quality attribute requirements, such as performance, modifiability, and security. | — |
| 63 | SEI CBAM | ASSESS | architecture-evaluation, cost-benefit-analysis |
The SEI Cost Benefit Analysis Method (CBAM) is a structured approach designed to help software architects and decision-makers evaluate the trade-offs among various architectural decisions. By integrating economic considerations with architectural needs, CBAM allows teams to assess the potential costs and benefits associated with different design options. This method is especially relevant in the methods-and-patterns quadrant as it provides a systematic approach to evaluating and justifying architectural choices, ensuring that they align with business goals and constraints. | — |
| 65 | SOA | ASSESS | service-oriented-architecture, integration-patterns |
Service-Oriented Architecture (SOA) is a design pattern where distinct services are provided to other components by application components through a communication protocol over a network. SOA’s primary goal is to allow easy integration between different applications and to facilitate business processes by making these services reusable and interoperable. This architecture style is particularly useful for organizations aiming to create complex systems that are agile and can be modified or extended with minimal impact on existing services. | — |
| 70 | V-Model | ASSESS | software-development, testing, project-management |
The V-Model, also known as the Verification and Validation model, is a software development process that emphasizes the importance of testing at each stage of development. It extends the traditional waterfall model by associating a testing phase with each corresponding development stage. This ensures that validation and verification are integral parts of the development lifecycle, leading to early detection and correction of defects. | HIL & Automated Testing Guide (GD-007) |
| 77 | Zachman Framework | ASSESS | enterprise-architecture, framework |
The Zachman Framework is a comprehensive enterprise architecture framework for organizing and categorizing the various perspectives involved in enterprise architecture. It provides a structured way to view and define an enterprise’s architecture by considering different aspects like data, functionality, network, people, time, and motivation across multiple perspectives, such as business owner, architect, designer, builder, and user. | — |
| 59 | rRPC | ASSESS | remote-procedure-call, microservices |
rRPC, or Reactive Remote Procedure Call, is an emerging method that enhances the traditional RPC model by incorporating reactive programming principles. This approach is particularly useful in systems where responsiveness and scalability are critical, such as microservices architectures. By leveraging a non-blocking, event-driven paradigm, rRPC enables more efficient use of system resources and improves the overall performance of distributed applications. | — |
| 73 | Waterfall | HOLD | project-management, software-development |
Waterfall is a traditional software development methodology that follows a linear and sequential approach, akin to a cascading waterfall. Each phase—such as requirements gathering, design, implementation, testing, and maintenance—must be completed before the next one begins. This method is useful in projects where requirements are well-understood and unlikely to change, as it emphasizes thorough documentation and a clear project roadmap. | — |
Complete directory of Methods & Patterns blips.
Tools & Utilities¶
Dedicated quadrant deep-dive: Tools & Utilities
| # | Technology | Ring | Tags | Description & Rationale | Reference |
|---|---|---|---|---|---|
| 43 | Mermaid | ADOPT | diagramming, visualization, documentation |
Mermaid is a JavaScript-based diagramming and charting tool that enables developers and content creators to create complex diagrams from simple text definitions. It is particularly useful for generating flowcharts, sequence diagrams, Gantt charts, and more, using a straightforward syntax that integrates seamlessly into various documentation systems, such as Markdown and static site generators like Jekyll and Docusaurus. | — |
| 51 | OpenAPI | ADOPT | API-design, documentation |
OpenAPI is a specification for building APIs that provides a standard, language-agnostic interface describing RESTful APIs. It’s widely adopted in the industry due to its ability to streamline API development processes. By using OpenAPI, developers can automate the generation of API documentation, client libraries, and server stubs, which reduces the likelihood of errors and accelerates development timelines. | — |
| 54 | PlantUML | ADOPT | diagramming, visualization, documentation |
PlantUML is an open-source tool that allows users to create UML diagrams from a plain text language. It is widely appreciated for its simplicity and the ease with which complex diagrams can be generated without needing to use graphical editing tools. PlantUML supports a variety of UML diagrams, including sequence diagrams, use case diagrams, class diagrams, and more, making it a versatile choice for software architects and developers. | Diagrams-as-Code Tooling Guide (GD-001) |
| 66 | SQLite | ADOPT | embedded-database, lightweight-database |
SQLite is a C-language library that implements a small, fast, self-contained, high-reliability, full-featured, SQL database engine. It is the most widely deployed database engine in the world, embedded into all sorts of applications. Its simplicity and ease of use make it an ideal choice for embedded database needs, mobile apps, and small to medium-sized applications that do not require the overhead of a full-scale database server. | — |
| 72 | VS code | ADOPT | code-editor, IDE, developer-productivity |
Visual Studio Code (VS Code) is a widely-used, open-source code editor developed by Microsoft. It provides developers with an efficient, lightweight, and highly customizable environment to write and debug code across various programming languages. VS Code is particularly appreciated for its rich extension ecosystem, enabling users to enhance functionality with plugins for specific languages, integrations, and developer tools. | — |
| 71 | Visual Studio Code | ADOPT | editor |
VS Code is a popular editor for development with rich plugin support. | — |
| 31 | gcc | ADOPT | compiler, open-source, C, C++ |
The GNU Compiler Collection (gcc) is a comprehensive and widely-used set of compilers for various programming languages, most notably C, C++, and Fortran. As an open-source project under the GNU umbrella, gcc is highly valued for its robustness, performance, and cross-platform capabilities. It serves as a critical tool in software development, enabling the translation of high-level code into executable machine code across various architectures. In the tools quadrant and adopt ring, gcc is an essential part of the development toolchain for many organizations and projects due to its maturity, extensive community support, and continuous updates. Its relevance spans from education to enterprise applications, making it a staple in both learning environments and professional software engineering practices. | — |
| 44 | Mermaid Diagrams | TRIAL | visualization, documentation |
Mermaid is a JavaScript-based diagramming and charting tool that allows for dynamic, code-based visualizations. It’s particularly useful for architecture diagrams, flowcharts, and Gantt charts in technical documentation. Mermaid syntax integrates seamlessly into Markdown files for inline visualization. | — |
| 14 | Coverity | ASSESS | static-analysis, code-quality, security |
Coverity is a static analysis tool used for identifying defects in software codebases. It is particularly useful for detecting a wide range of issues such as security vulnerabilities, resource leaks, and concurrency defects before they manifest in production environments. Coverity is relevant in the “tools” quadrant because it provides developers and development teams with a robust mechanism to improve code quality and maintainability through automated code review processes. In the “assess” ring, it reflects its growing importance as organizations increasingly prioritize integrating security and quality assurance early in the software development lifecycle, aligning with practices like DevSecOps. As the landscape of software development continues to evolve, tools like Coverity are integral in ensuring software reliability and security compliance. | — |
| 67 | Structurizr | ASSESS | architecture-diagrams, software-design, cloud |
Structurizr is a tool designed for creating software architecture diagrams based on the C4 model, which emphasizes clarity and simplicity in visualizing software architecture. It is particularly useful for software architects and developers who need to communicate complex systems effectively. Structurizr allows users to define their architecture models using code, enabling version control and integration with existing development workflows. In the tools quadrant, Structurizr stands out as a modern approach to diagramming that aligns with agile methodologies and continuous integration practices. In the assess ring, it is recommended for evaluation as it can potentially enhance documentation and understanding of software systems within organizations, especially those adopting cloud-native technologies. | — |
Complete directory of Tools & Utilities blips.