docs: set v7 release date

radar/2023-11-01/adobe-creative-cloud.md

@@ -0,0 +1,8 @@
+---
+title:      "Adobe Creative Cloud"
+ring:       adopt
+quadrant:   tools
+tags:       [ux/ui]
+---
+
+[Adobe Creative Cloud](https://www.adobe.com/creativecloud.html) transcends traditional design boundaries by providing a comprehensive platform that fosters seamless collaboration and streamlines the design process. We use applications such as Adobe XD, Photoshop, Illustrator, InDesign, and more, each of which serves a unique purpose in the design workflow, including photo and video editing. The integration of these specialized tools allows us to work efficiently and effectively, thus maximizing our productivity.

radar/2023-11-01/akka.md

@@ -0,0 +1,6 @@
+---
+title:      "Akka"
+ring:       hold
+quadrant:   languages-and-frameworks
+tags:       [coding]
+---

radar/2023-11-01/alpakka.md

@@ -0,0 +1,7 @@
+---
+title:      "Alpakka"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding]
+featured:   false
+---

radar/2023-11-01/angular.md

@@ -0,0 +1,12 @@
+---
+title:      "Angular"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+[Angular](https://angular.io/), now in version 15, remains a robust and well-maintained front-end framework that continues to build new features on its solid foundation. Angular offers excellent tools for building large-scale applications.
+
+For instance, it includes built-in capabilities for setting up and managing a monorepo, simplifying the sharing of components across multiple projects. As a framework, Angular takes an opinionated approach to solving various problems, reducing the need for extensive decision-making while maintaining consistency, yet still providing flexibility where necessary. Angular 15 further stabilizes standalone components, a feature introduced in Angular 14, with the aim of simplifying Angular applications and reducing module complexity, addressing a common criticism of Angular.
+
+The ease of upgrading to new versions has improved significantly due to the framework's stability and the detailed migration guides provided by the maintainers.

radar/2023-11-01/ansible.md

@@ -0,0 +1,9 @@
+---
+title:      "Ansible"
+ring:       trial
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+featured:   false
+---
+
+We have observed a decrease in our usage of Ansible recently. Our current focus lies more on immutable infrastructure using cloud providers. Nonetheless, Ansible still offers great benefits for mutable infrastructure that require support and is an excellent tool for achieving [Infrastructure as Code](../platforms-and-aoe-services/infrastructure-as-code.html) in such cases.

radar/2023-11-01/artifactory.md

@@ -0,0 +1,8 @@
+---
+title:      "Artifactory"
+ring:       hold
+quadrant:   platforms-and-aoe-services
+featured:   false
+---
+
+We no longer use Artifactory; instead, we rely on the integrated artifact management of SCM platforms like [GitLab](https://gitlab.org).

radar/2023-11-01/assisted-ai.md

@@ -0,0 +1,52 @@
+---
+title:      "AI Assisted Programming"
+ring:       assess
+quadrant:   "methods-and-patterns"
+tags:       [coding, architecture]
+---
+
+In recent years, the field of Artificial Intelligence (AI) has made monumental strides, and AI has demonstrated its ability to augment human capabilities and enhance user experiences. One noteworthy facet of this evolution is Assisted AI—a paradigm that holds great promise for software development companies.
+
+Assisted AI combines human and machine intelligence to enhance productivity. It leverages AI's computational capabilities while preserving human critical thinking.
+
+### Advantages and Opportunities
+
+Developers should consider using generative artificial intelligence (AI) for a multitude of reasons:
+
+- **Code Enhancement**: Assisted AI offers intelligent code suggestions, optimizing and refactoring. It helps save time and boost quality and developer satisfaction.
+- **Automated Testing**: It accelerates testing, identifies bugs, and generates test cases for more robust, reliable software.
+- **NLP-powered Documentation**: Assisted AI assists in writing precise, comprehensive documentation.
+- **Security**: Assisted AI can help identify vulnerabilities.
+
+### Providers and Solutions
+
+- [ChatGPT](https://chat.openai.com/)
+  - Powered by OpenAI's advanced GPT-3/4 technology.
+  - Delivers human-like conversation experiences.
+  - Can also interpret and generate visual content, providing a multifaceted interaction experience.
+- [GitHub Copilot](https://copilot.github.com/)
+  - Transforms natural language prompts into relevant code suggestions.
+  - Offers seamless integration with numerous IDEs for an enhanced developer experience.
+  - Empowered by training on billions of lines of code.
+- [Amazon CodeWhisperer](https://aws.amazon.com/codewhisperer/)
+  - Completely free to use for individual developers.
+  - Advanced features to trace the origin of code snippets.
+  - Integrated with AWS, providing robust and scalable solutions.
+- [FauxPilot](https://github.com/fauxpilot/fauxpilot)
+  - A credible open-source counterpart to GitHub Copilot server.
+  - Prioritizes user privacy and data sovereignty.
+  - Continuously updated by a vibrant community of developers.
+
+### Challenges and Considerations
+
+Ethical, privacy, and bias concerns need careful attention, especially data protection concerns while working with cloud-based solutions, which are important to consider.
+
+### Future Outlook
+
+Assisted AI is a pivotal development. Embracing this shift promises improved efficiency and better products.
+
+We are currently establishing the following aspects:
+
+- Maintaining a risk assessment and working on mitigations regularly.
+- Setting up usage guidelines and providing training.
+- Establishing a regular "learning group" as an exchange between teams to share best practices and learnings.

radar/2023-11-01/axure.md

@@ -0,0 +1,7 @@
+---
+title:      "Axure"
+ring:       trial
+quadrant:   tools
+tags:       [ux/ui]
+featured:   false
+---

radar/2023-11-01/azure_container_instances.md

@@ -0,0 +1,14 @@
+---
+title:      "Azure Container Instances"
+ring:       hold
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+---
+
+We've previously used [AWS Fargate](../platforms-and-aoe-services/aws_fargate.html) when we didn't require full container orchestration and aimed for simplicity without managing the OS ourselves. When dealing with Azure projects, we searched for a similar solution. After exploring the somewhat opaque list of options for running Docker images on Azure, we decided on [Azure Container Instances](https://azure.microsoft.com/products/container-instances), as they appeared to align most closely with AWS Fargate in terms of simplicity.
+
+However, while it's easy to get a container up and running with Azure Container Instances, it seems that this service is still in its early stages of maturity. Some notable limitations include the inability to automatically register containers in internal networks with Azure Application Gateway, a lack of support for internal DNS, occasional issues where containers need to be deleted and recreated instead of being smoothly replaced, and unexpected container restarts during the night without clear prior announcements or post-incident explanations.
+
+Another limitation is that volumes can only be stored on Azure File Shares and not on regular Azure Disks, which can pose challenges when running certain applications. Surprisingly, when compared to running the same Docker container on a virtual machine, Azure Container Instances may not even be more cost-effective.
+
+Given these limitations and experiences, we do not recommend migrating critical workloads to Azure Container Instances.

radar/2023-11-01/css-in-js.md

@@ -0,0 +1,16 @@
+---
+title:      "CSS-in-JS"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [coding, frontend]
+---
+
+Since the release of React 18, many CSS-in-JS libraries like styled-components, emotion, and stitches have encountered a significant challenge. They generate CSS only at runtime, making them incompatible with streaming and [React Server Components](../methods-and-patterns/react-server-components.html). React developers have addressed this issue in an [article](https://github.com/reactwg/react-18/discussions/110), where they explicitly advise against using CSS-in-JS libraries that generate CSS at runtime.
+
+This has created substantial uncertainty among developers and the communities of these affected libraries. The question arises: Is it possible to refactor these runtime libraries into buildtime libraries? To date, none of the libraries have announced any such plans, and, unfortunately, one of the most popular new libraries, stitches, is [no longer being maintained](https://github.com/stitchesjs/stitches/discussions/1149#discussioncomment-6223090).
+
+Fortunately, there has been a growing number of CSS-in-JS solutions that generate CSS at buildtime. Libraries like [Vanilla Extract](https://vanilla-extract.style/), [panda](https://panda-css.com/), and [Kuma UI](https://www.kuma-ui.com/) maintain an excellent developer experience, overcome performance disadvantages, and are compatible with React 18.
+
+Unfortunately, these libraries are not yet widely adopted, and it's challenging to predict how they will develop in the future. Therefore, at AOE, we continue to use established solutions as long as the new React features are not mandatory.
+
+Moreover, we are gaining experience with these new libraries because we see significant potential in them.

radar/2023-11-01/deno.md

@@ -0,0 +1,17 @@
+---
+title:      "Deno"
+ring:       assess
+quadrant:   languages-and-frameworks
+tags:       [coding]
+---
+
+```ts
+> 'node'.split('').sort().join('')
+> 'deno'
+```
+
+[Deno](https://deno.com/runtime) is a secure, modern JavaScript and TypeScript runtime built on the V8 JavaScript engine. It was developed as a more secure and developer-friendly alternative to Node.js by Ryan Dahl, the core author of Node.js.
+
+Deno prioritizes security by default, enforcing strict permissions for file system access, network access, and environment variable usage. It also offers improved performance, thanks to its utilization of the latest JavaScript features and optimizations. Deno supports TypeScript out of the box, allowing developers to take advantage of static type checking and other TypeScript features. It incorporates a built-in module system, reducing dependency conflicts and simplifying module management.
+
+With its streamlined developer experience, which includes a standard library and support for modern language features, Deno offers a compelling option for JavaScript and TypeScript developers.

radar/2023-11-01/design-system.md

@@ -0,0 +1,8 @@
+---
+title:      "Design System"
+ring:       adopt
+quadrant:   "methods-and-patterns"
+tags:       [ux/ui, frontend, coding, architecture, documentation]
+---
+
+Through the implementation of design systems, we have demonstrated that this approach aligns with many of the mentioned benefits and recommend its use in future projects.

radar/2023-11-01/devops-practices.md

@@ -0,0 +1,7 @@
+---
+title:      "DevOps Practices"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [devops]
+featured:   false
+---

radar/2023-11-01/diagrams-as-code.md

@@ -0,0 +1,15 @@
+---
+title:      "Diagrams as Code"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [architecture, quality assurance, documentation]
+---
+
+Documenting concepts and software architecture as diagrams using code offers significant benefits over heavier solutions. Treating documentation and diagrams as code and checking them into version control increases transparency, collaboration, and productivity. The textual representation of diagrams is easy to write and read, and generating graphical representations as SVG or PNG images is also straightforward with the associated tools.
+
+We extensively use [PlantUML](/tools/plant-uml.html) in combination with [Asciidoc](/tools/asciidoc.html) and tools like [AsciiDoctor Diagram](https://asciidoctor.org/docs/asciidoctor-diagram/) to include and inline PlantUML diagrams in our documentation. The latter allows for a variety of other diagram formats, which can be easily mixed and matched.
+
+Other tools worth mentioning include:
+- [Mermaid](https://mermaid.js.org/), a JavaScript-based diagramming tool natively supported by many common tools (e.g., GitHub, GitLab, Gitea, Notion, etc.).
+- [D2](https://d2lang.com/), a diagram scripting language that focuses on readability and provides a CLI and a Go library for programmatically creating diagrams.
+- [Structurizr](https://structurizr.com/), which brings its own DSL for creating software architecture models based on the [C4 model](https://c4model.com/) and a CLI for exporting to formats like PlantUML, Mermaid, D2, and others.

radar/2023-11-01/dora-metrics.md

@@ -0,0 +1,28 @@
+---
+title:      "DORA Metrics for DevOps"
+ring:       trial
+quadrant:   methods-and-patterns
+tags:       [devops, documentation, agile]
+---
+
+A primary goal of software development organizations is to enhance the performance of software delivery and operations.
+
+There are numerous best practices and differing opinions on how to approach "DevOps the right way." We've learned that IT organizations and software delivery are complex issues, which means that most of the time there are no "easy" answers. Instead, continuous improvement within a contextual framework is a critical element.
+
+To introduce more objectivity and a measure of verifiability, we like to use the four key metrics suggested by "The State of DevOps" and "DORA." These four key metrics are:
+
+**To evaluate velocity:**
+- Deployment Frequency (How often a team successfully deploys to production, e.g., daily, weekly, monthly, yearly)
+- Lead time for changes (the average time it takes to deploy a commit to production)
+
+**To evaluate stability:**
+- Time to Restore Services (For a failure, the median time between the deployment that caused the failure and the remediation)
+- Change Failure Rate (The number of failures per number of deployments)
+
+### About DORA
+The DevOps Research and Assessment (DORA) is the largest and longest-running research program of its kind, aiming to understand the capabilities driving software delivery and operations performance. Their report, "The State of DevOps," regularly provides insights, observations, and insights into high-performing IT organizations.
+
+### Additional Information
+- [DORA Website](https://dora.dev/)
+- [DORA's Journey: An Exploration](https://medium.com/@jezhumble/doras-journey-an-exploration-4c6bfc41e667)
+- [DORA GitHub Repository](https://github.com/dora-team/fourkeys)

radar/2023-11-01/fluentd.md

@@ -0,0 +1,10 @@
+---
+title:      "Fluentd"
+ring:       hold
+quadrant:   tools
+tags:       [devops]
+---
+
+[Fluentd](https://www.fluentd.org) remains a great tool for collecting logs, transforming them into any required format, and distributing them to various logging backends. However, in recent years, we have often transitioned to [Grafana Loki and Promtail](/platforms-and-aoe-services/loki.html) for several reasons.
+
+We've also learned that extensive upfront log parsing carries a risk of losing logs and requires significant effort. This doesn't fit well with most projects.

radar/2023-11-01/flux.md

@@ -0,0 +1,13 @@
+---
+title:      "Flux"
+ring:       hold
+quadrant:   methods-and-patterns
+tags:       [frontend]
+featured:   false
+---
+
+In the early days of [React](/languages-and-frameworks/react.html), [Flux](https://github.com/facebookarchive/flux) was introduced by Facebook as an architectural pattern for managing global state. Later, it evolved into a library, with contributions from the community.
+
+Today, there are numerous libraries that offer the Flux pattern or similar approaches to state management. These include framework-agnostic solutions like [Redux](/languages-and-frameworks/redux.html) or [MobX](https://mobx.js.org/README.html), as well as framework-specific options like [Pinia](https://pinia.vuejs.org/) for Vue and [Zustand](https://docs.pmnd.rs/zustand) for React, among many others.
+
+One of the most popular solutions to date is Redux, which is why we use it in several projects.

radar/2023-11-01/gitlab.md

@@ -0,0 +1,7 @@
+---
+title:      "GitLab"
+ring:       adopt
+quadrant:   tools
+tags:       [ci/cd, coding]
+featured:   false
+---

radar/2023-11-01/gradle.md

@@ -0,0 +1,8 @@
+---
+title:      "Gradle"
+ring:       adopt
+quadrant:   tools
+tags:       [ci/cd, coding]
+featured:   false
+---
+

radar/2023-11-01/green-it.md

@@ -0,0 +1,35 @@
+---
+title:      "Green IT"
+ring:       assess
+quadrant:   methods-and-patterns
+tags:       [architecture, coding]
+---
+
+In an age of ever-increasing digitalization, the energy consumption of data centers and the Internet continues to rise, raising concerns about the environmental impact of our digital activities. In response, the concept of "Green IT" has emerged, emphasizing the need for eco-friendly software development and operational practices. By highlighting key architectural patterns, development practices, and operational strategies for reducing the carbon footprint of IT applications, it challenges software vendors and developers to explore how they can contribute to greater sustainability.
+
+### Sustainable Software Development Practices
+Well-architected software plays a pivotal role in reducing the environmental impact of digital systems. Sustainability in software development involves the consideration of various factors throughout the entire lifecycle:
+- **Agile and Modular Development**: Develop software iteratively, focusing on essential functionality and creating modular, reusable components.
+- **Programming Language Choice**: Opt for compiled languages such as [Rust](/languages-and-frameworks/rust.html) or [Go](/languages-and-frameworks/go-lang.html) that have lower energy consumption during execution.
+- **Automation and Infrastructure-as-Code**: Automate resource management and shut down unused infrastructure during idle periods to decrease energy consumption.
+- **Demand Shaping**: Schedule energy-intensive workloads to align with the availability of renewable energy sources.
+- **Green Power**: Source electricity from sustainable and renewable sources.
+- **Optimized Hardware and Software Lifespan**: Extend the life of hardware and software through thoughtful design and maintenance.
+
+### Metrics and Measurement
+Software applications, especially those hosted in data centers, have a substantial environmental footprint as they require significant amounts of energy to operate. In addition, their development and use often necessitate the production of hardware devices such as servers, laptops, and smartphones.
+
+Assessing the carbon emissions throughout an application's lifecycle enables developers and enterprises to make informed decisions that reduce emissions, lower costs, and ensure compliance with environmental regulations. Measuring energy consumption highlights areas where software can be optimized for improved efficiency. Environmental metrics support sustainability reporting, showcasing an organization's commitment to eco-friendly practices.
+
+### Beware the Rebound Effect
+Efficiency improvements often lead to time and cost savings, which can paradoxically lead to more workload and less energy savings - a rebound effect. Finding a balance between efficiency gains and sustainable growth is critical to sustainable software development.
+
+### Digitalization's Environmental Impact
+The environmental impact of digitalization is a nuanced interplay between its potential for energy consumption and its ability to promote sustainability.
+
+Blockchain technology utilizing energy-intensive mining processes of proof-of-work consensus mechanisms demands immense computational power, resulting in substantial carbon emissions. Machine learning, a cornerstone of AI, requires vast amounts of data and computational resources.
+
+However, digitalization also emerges as a champion of environmental stewardship in several areas: Demand-driven production optimizes inventory, reduces waste, and curtails unnecessary production, ultimately minimizing energy consumption and emissions. The digital product passport introduces traceability and transparency throughout a product's lifecycle, promoting sustainability and empowering consumers to make eco-conscious choices.
+
+### A Greener Future for IT
+Sustainable software development is not only an ethical imperative but also a competitive advantage. However, achieving comprehensive sustainability is a complex task. More than just minimizing energy consumption, Green IT compels us to make conscientious choices at every stage of the software development lifecycle. By adopting architectural patterns that prioritize sustainability, optimizing code, and embracing best practices in operations, we can contribute to a more eco-friendly digital future.

radar/2023-11-01/harbor.md

@@ -0,0 +1,11 @@
+---
+title:      "Harbor"
+ring:       trial
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+---
+
+We continue to utilize [Harbor](https://goharbor.io) in our projects. Since the last iteration of the AOE Technology Radar, we have discovered both existing and new features that we find useful:
+
+- An official [Terraform provider](https://registry.terraform.io/providers/goharbor/harbor/latest) for provisioning Harbor resources through Infrastructure as Code (IaC).
+- The introduction of [Proxy Cache](https://goharbor.io/docs/latest/administration/configure-proxy-cache/) projects, which serve as pull-through caches for public container registries. These can, among other benefits, help reduce external network traffic.

radar/2023-11-01/infrastructure-as-code.md

@@ -0,0 +1,7 @@
+---
+title:      "Infrastructure as Code"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+tags:       [devops, ci/cd]
+featured:   false
+---

radar/2023-11-01/jest.md

@@ -0,0 +1,7 @@
+---
+title:      "Jest"
+ring:       adopt
+quadrant:   tools
+tags:       [frontend, quality assurance]
+featured:   false
+---

radar/2023-11-01/kubernetes-operators.md

@@ -0,0 +1,9 @@
+---
+title:      "Kubernetes Operators"
+ring:       trial
+quadrant:   methods-and-patterns
+tags:       [devops]
+featured:   false
+---
+
+We've faded out Kubernetes Operators as a standalone recommendation because they are such a central part of [Kubernetes](../platforms-and-aoe-services/kubernetes.html) that their use appears self-evident.

radar/2023-11-01/ldap-login.md

@@ -0,0 +1,7 @@
+---
+title:      "LDAP Login"
+ring:       hold
+quadrant:   platforms-and-aoe-services
+tags:       [devops, security]
+featured:   false
+---

radar/2023-11-01/loki.md

@@ -0,0 +1,13 @@
+---
+title:      "Loki"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+tags:       [ devops ]
+---
+
+After having very positive experiences, we decided to replace our ELK stacks with Loki, primarily for the following reasons:
+
+- Loki is significantly more cost-effective than the storage requirements of Elasticsearch used in the ELK stack.
+- The PromQL-like query language, familiar to users of Prometheus, makes it easier for DevOps and SRE teams who already use Prometheus for monitoring to work with logs.
+- Loki's native integration with Kubernetes simplifies the setup and configuration process.
+- Loki typically requires less maintenance and overhead compared to ELK.

radar/2023-11-01/micro-frontends.md

@@ -0,0 +1,20 @@
+---
+title:      "Micro Frontends"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [architecture, frontend]
+---
+
+While Micro Frontends have gained significant attention as a software architectural approach that mirrors the principles of microservices at the frontend level, it's crucial to recognize that they are not a universal remedy for all frontend development challenges. The decision to implement Micro Frontends should be made thoughtfully, taking into account the project's specific requirements.
+
+### Pros:
+- **Modularity:** Breaking down the frontend into smaller, manageable pieces allows for easier development, testing, and maintenance. Teams can work on individual modules autonomously, leading to faster development cycles.
+- **Technology Agnosticism:** Enabling the use of different frameworks and technologies for different parts of the application. Teams can choose the best technology stack for each component, promoting flexibility and fostering innovation.
+- **Resilience:** In monolithic applications, a single bug can potentially affect the entire system. Isolation of components mitigates this risk and simplifies maintenance and debugging.
+
+### Cons:
+- **Complexity:** Managing multiple codebases, handling cross-cutting concerns such as authentication, routing, and state management, and ensuring a consistent user experience throughout the application can introduce a level of complexity that may not be justified for all projects.
+- **Performance Overhead:** Increased JavaScript bundle sizes and additional HTTP requests, as each module may be loaded separately, can impact page load times, especially in low-bandwidth environments. Careful optimization and caching strategies are required to mitigate this issue.
+- **Versioning and Compatibility:** Maintaining compatibility between evolving technologies and frameworks is a substantial challenge. Compatibility issues may arise, requiring additional development and testing efforts.
+
+Ultimately, the decision of whether to choose Micro Frontends or other architectural approaches should align with the project's goals, team expertise, and scalability requirements. Individual teams working on well-defined, independently deployable features of a large application may benefit from using Micro Frontends. However, for smaller applications or teams with limited resources, a traditional monolithic approach might be more efficient.

radar/2023-11-01/microservices.md

@@ -0,0 +1,7 @@
+---
+title:      "Microservices"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [architecture]
+featured:   false
+---

radar/2023-11-01/mlops.md

@@ -0,0 +1,7 @@
+---
+title:      "MLOps"
+ring:       assess
+quadrant:   methods-and-patterns
+tags:       [devops]
+featured:   false
+---

radar/2023-11-01/monorepo.md

@@ -0,0 +1,29 @@
+---
+title:      "Monorepo"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [coding]
+---
+
+Adopting a monorepo approach for our React and Next.js-based projects offers several benefits, _although it may not be
+the best fit for every project._
+
+1. More efficient code sharing and reusability.
+2. Consistent development environment.
+3. Easier cross-project refactoring.
+4. Improved collaboration.
+5. **Simplified Dependency Management**: In our monorepo, we can manage dependencies at the repository level, simplifying
+   the process of keeping everything up to date and avoiding version conflicts.
+6. **Streamlined CI/CD Pipeline**: A single CI/CD pipeline that can build and test all our projects simultaneously.
+   This, of course, comes with the drawback of a more complicated CI/CD setup and potentially longer running pipelines.
+7. **Better Code Ownership**: It's easier to determine who is responsible for each part of the codebase, which can
+   improve code ownership and accountability.
+8. **Simplified Testing**: We can set up end-to-end tests and integration tests that cover the entire application more
+   easily in a monorepo, ensuring that changes in one part of the codebase don't break other parts.
+9. **Codebase Navigation**: Developers can easily navigate through different parts of the codebase without having to
+   switch between multiple repositories or projects.
+
+**However, it is important to note that monorepos are not a one-size-fits-all solution.** They can introduce complexity,
+especially in very large projects, and may not be suitable for all team sizes or development workflows. The decision to
+adopt a monorepo should be based on a careful consideration of your project's specific requirements, team size, and
+development practices.

radar/2023-11-01/nats.md

@@ -0,0 +1,7 @@
+---
+title:      "NATS"
+ring:       assess
+quadrant:   tools
+tags:       [architecture, devops]
+featured:   false
+---

radar/2023-11-01/next-js.md

@@ -0,0 +1,12 @@
+---
+title:      "Next.js"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+We are convinced that Next.js is one of the go-to frameworks for React, and we're excited about the features that version 13 has brought with it. During the Next.js Conf 2022, the team announced some exciting adaptations in this release, but the most interesting one is the new "app" router. In collaboration with the React team, this new routing architecture brings some of the newest and most promising features of React 18 to life.
+
+When using the app router, every component, by default, becomes a [React Server Component](/methods-and-patterns/react-server-components.html), making it one of the first real integrations of this pattern in a framework. The goal is to build complex interfaces while minimizing the amount of JavaScript shipped to the client. Another exciting feature is Streaming, which allows incremental transfer of parts of the UI to the client as they become ready. For example, immediately showing some fallback UI until an asynchronous action is completed, and then streaming the final UI to the client. With the app router, it's also possible to easily create shared layouts that preserve state during navigation and remain interactive.
+
+The good thing is that this new architecture can coexist alongside the old page router, giving us the flexibility to incrementally adapt to the new features in existing projects.

radar/2023-11-01/nx.md

@@ -0,0 +1,7 @@
+---
+title:      "NX"
+ring:       adopt
+quadrant:   tools
+tags:       [coding, ci/cd]
+featured:   false
+---

radar/2023-11-01/open-policy-agent.md

@@ -0,0 +1,9 @@
+---
+title:      "Open Policy Agent"
+ring:       assess
+quadrant:   tools
+tags:       [security, architecture]
+featured:   false
+---
+
+We have been transitioning away from using Open Policy Agent at AOE. For alternative solutions, please refer to [Policy as Code](../methods-and-patterns/policy-as-code.html).

radar/2023-11-01/pipeline-as-code.md

@@ -0,0 +1,7 @@
+---
+title:      "Pipeline as Code"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [devops]
+featured:   false
+---

radar/2023-11-01/playwright.md

@@ -0,0 +1,18 @@
+---
+title:      "Playwright"
+ring:       adopt
+quadrant:   tools
+tags:       [coding, frontend, quality assurance]
+---
+
+[Playwright](https://playwright.dev) is a versatile tool for creating reliable end-to-end tests across different browsers, platforms, and languages. It's easy to get started with and comes with a wide range of built-in features. Playwright works on Windows, macOS, and Linux and seamlessly integrates with popular testing frameworks like Jest, Mocha, and Jasmine.
+
+Playwright's configuration offers valuable options, including native mobile emulation for Chrome on Android and Safari on iOS. It can also be extended using BDD tools like Cucumber or SpecFlow, allowing non-technical contributors to collaborate.
+
+Playwright tests are robust, as they wait for elements before taking actions to eliminate timeouts, a common cause of unreliable tests.
+
+In contrast to Cypress, Playwright excels at interacting with different origins and multiple tabs in tests. You can create scenarios with distinct contexts to handle various users within a test, saving authentication states for reuse in other tests, thus eliminating repetitive log-in operations.
+
+Developed and maintained by Microsoft, Playwright benefits from extensions for Visual Studio Code, streamlining test development, execution, and debugging.
+
+In summary, Playwright is a versatile testing tool offering compatibility, integration with testing frameworks, and advanced features like multi-origin interactions. Its robustness, ability to handle diverse scenarios, and close ties with Visual Studio Code make it an exceptional choice for end-to-end testing.

radar/2023-11-01/pnpm.md

@@ -0,0 +1,7 @@
+---
+title:      "pnpm"
+ring:       adopt
+quadrant:   tools
+tags:       [coding, frontend]
+featured:   false
+---

radar/2023-11-01/pulumi.md

@@ -0,0 +1,9 @@
+---
+title:      "Pulumi"
+ring:       assess
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+featured:   false
+---
+
+We stuck with Terraform for most projects.

radar/2023-11-01/react-native.md

@@ -0,0 +1,10 @@
+---
+title:      "React Native"
+ring:       assess
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+[React Native](https://reactnative.dev/) is an open-source UI software framework used to build applications for Android, Android TV, iOS, macOS, tvOS, Web, Windows, and UWP. It enables developers to utilize the React framework alongside native platform features.
+
+Developing applications with a single codebase can help ensure consistent user experiences across platforms, while also delivering the performance advantages of native code.

radar/2023-11-01/react-server-components.md

@@ -0,0 +1,16 @@
+---
+title:      "React Server Components"
+ring:       assess
+quadrant:   methods-and-patterns
+tags:       [frontend, coding]
+---
+
+Shortly after releasing React 17 in October 2020, the team introduced React Server Components (RSC) as a working draft in December 2020. RSCs represent a new application architecture paradigm within React designed to reduce the amount of JavaScript sent to the client. The ultimate goal is to enhance performance, user experience, and maintainability.
+
+This new feature enables the creation of components that exclusively run on the server. As a result, there is no impact on the bundle size downloaded by the client. For instance, libraries used in server components are not shipped to the client. RSCs also have the capability to access server-side resources, such as databases and the file system, directly.
+
+In addition to server components, there are client components, which are essentially the classic components everyone is familiar with. The only distinction is that client components need to be explicitly declared using a directive. Determining which components should be client or server can be one of the more challenging aspects, especially when the goal is to migrate existing applications.
+
+RSCs appear to be most effective when used with Server Side Rendering, although it is possible to use them without it. RSCs and Server Side Rendering complement each other well, as server components are only rendered once on the server and do not need to be sent to the client. Client components are still rendered on the server and then hydrated on the client side. However, with a well-structured application that minimizes client-side code and in combination with React 18's [Suspense and Selective Hydration](https://github.com/reactwg/react-18/discussions/37) features, a performance boost is expected. To test this hypothesis, the React team has collaborated with Vercel, the maintainer of [NextJS](/languages-and-frameworks/next-js.html), to integrate RSCs into a suitable environment early.
+
+Overall, we recognize the potential of this new approach, even though there are several steps to take, particularly for meta-frameworks to achieve production readiness. It appears to be only a matter of time before adoption of React Server Components becomes widespread. This is why we have placed it in the assess ring, keeping a watchful eye on this evolving technology.

radar/2023-11-01/react.md

@@ -0,0 +1,21 @@
+---
+title:      "React.js"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+React today is the most widely used frontend library within our company, employed in various forms. Whether it's integrated into frameworks like [NextJS](/languages-and-frameworks/next-js.html) and [Remix](/languages-and-frameworks/remix.html) or utilized for client-side-only applications, React plays a significant role in many of our ongoing projects. Over time, a community of experts has emerged within the company.
+
+We firmly believe that React 18, with its range of new features, will further enhance its popularity within our company and the broader community.
+
+### Suspense
+While not an entirely new feature, Suspense was initially introduced in a basic version back in 2018. However, it had certain limitations. Its first official use case was code splitting with `React.lazy`, but this feature was only available on the client side, not during server rendering. The primary goal has always been to enhance the loading experience both on the client and server. With React 18, Suspense now enables Streaming server rendering, a new feature that allows React to send the HTML of the loading fallback first and then, after loading completes, send the actual HTML content to the client. The React team continues to work on improving Suspense, particularly to enable data fetching libraries to use it. They are collaborating with authors of some of the most prominent libraries like TanStack Query, SWR, and Apollo.
+
+### Server Components
+Server Components represent a new paradigm in React application architecture with the goal of minimizing the amount of JavaScript sent to the client. This approach introduces a new type of component that operates exclusively on the server. It shows great promise, which is why we have given [React Server Components](/methods-and-patterns/react-server-components.html) a dedicated entry on our Tech Radar.
+
+### Concurrency
+This is a fundamental update to React's rendering model, primarily occurring under the hood. It introduces the ability to create multiple versions of a user interface concurrently. With concurrent React, rendering can be interrupted, abandoned, and resumed, allowing the application to respond to user interactions immediately, even if it's currently in the middle of rendering.
+
+The React team is collaborating closely with some of the major players in the React ecosystem to stabilize and enhance the library. They are also experimenting with new features, ensuring that React remains as exciting as ever.

radar/2023-11-01/sbom.md

@@ -0,0 +1,24 @@
+---
+title:      "Software Bill of Materials (SBOM)"
+ring:       assess
+quadrant:   platforms-and-aoe-services
+tags:       [devops, security]
+---
+
+A Software Bill of Materials (SBOM) is an artifact that consolidates information about the dependencies of a software.
+
+Several standards exist that define the contents and format of SBOMs. The most prominent open-source formats include:
+
+- [CycloneDX](https://cyclonedx.org/) (OWASP): designed in 2017 with the goal of identifying vulnerabilities in the software supply chain.
+- [SPDX](https://spdx.dev/) (Linux Foundation): primarily focused on license compliance in the context of open source software. Support for tracking security vulnerabilities was added in 2016 with SPDX 2.1.
+
+While the goals of these SBOM formats vary, they both support:
+
+- Automated generation of SBOMs from source code.
+- Machine-readable output to enable automated processing of SBOMs.
+
+We see the potential for SBOMs to enhance software supply chain security by:
+
+- Providing transparency regarding direct and transitive software dependencies.
+- Automating the detection of software dependencies with known vulnerabilities.
+- Promoting interoperability of security tools that support the same SBOM standards.

radar/2023-11-01/serverless.md

@@ -0,0 +1,32 @@
+---
+title:      "Serverless"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [devops]
+---
+
+The serverless pattern, also referred to as Function as a Service (FaaS), represents a paradigm shift in cloud computing. It enables developers to focus solely on writing code, which is executed in response to events without having to manage the underlying servers or infrastructure. Serverless applications are composed of multiple individual functions or microservices that automatically scale in response to demand.
+
+At AOE, we encourage our development teams to adopt the serverless pattern for its increased scalability, reduced operational overhead, and cost-effectiveness.
+
+### Common Tools for Developing and Deploying Serverless Applications
+- **[AWS SAM (Serverless Application Model)](https://aws.amazon.com/serverless/sam/):** An AWS-native tool that simplifies the deployment of serverless applications on Amazon Web Services (AWS) and supports multiple programming languages.
+- **[Azure Functions Core Tools](https://github.com/Azure/azure-functions-core-tools/):** Provide seamless development, debugging, and deployment of serverless functions on Microsoft Azure. These tools integrate with Visual Studio Code.
+- **[Google Cloud Functions Framework](https://cloud.google.com/functions/docs/functions-framework/):** Offer a local development environment, debugging capabilities, and a framework that integrates with other Google Cloud services. It supports multiple programming languages, including Node.js, Python, Go, and others.
+- **[OpenFaaS](https://www.openfaas.com/):** Allow building and deploying serverless functions using Docker containers on Kubernetes. They provide flexibility in containerization and language choice.
+
+### Popular FaaS Providers
+- **[AWS Lambda](https://aws.amazon.com/lambda/):** Amazon Web Services' serverless compute service with extensive language support and deep integration with AWS services.
+- **[Azure Functions](https://azure.microsoft.com/services/functions/):** Microsoft Azure's serverless platform supporting multiple programming languages and seamless Azure service integration.
+- **[Google Cloud Functions](https://cloud.google.com/functions):** Google Cloud's serverless platform optimized for event-driven applications and simplified serverless development.
+- **[IBM Cloud Functions](https://www.ibm.com/cloud/functions):** IBM's serverless computing platform based on the open-source Apache OpenWhisk project, offering flexibility and hybrid cloud capabilities.
+- **[Firebase Functions](https://firebase.google.com/docs/functions):** Google's serverless solution for mobile and web app development, tightly integrated with Firebase services like the real-time database and hosting.
+
+### When to Apply the Serverless Pattern
+
+Embracing the Serverless pattern can significantly enhance development speed, scalability, and cost-effectiveness in modern software architectures. For example:
+- **Event-Driven Workloads:** Serverless is ideal for applications with sporadic or unpredictable workloads driven by events like user actions, sensor data, or file uploads.
+- **Scaling Microservices:** Adopt serverless for specific microservices within a larger architecture to simplify deployment and scale.
+- **Cost Optimization:** Use serverless to optimize costs by paying only for the resources consumed during execution.
+- **Prototyping and MVPs:** Quickly build and test minimum viable products (MVPs) and prototypes without extensive infrastructure setup.
+- **Short-Lived Compute:** For tasks that require short bursts of compute power, such as data processing or image resizing.

radar/2023-11-01/service-mesh.md

@@ -0,0 +1,8 @@
+---
+title:      "Service Mesh"
+ring:       trial
+quadrant:   platforms-and-aoe-services
+tags:       [architecture, devops, security]
+---
+
+We have implemented Service Meshes in multiple projects. In particular, mTLS is a valuable feature that we believe almost all projects can benefit from.

radar/2023-11-01/sigstore.md

@@ -0,0 +1,12 @@
+---
+title:      "Sigstore"
+ring:       trial
+quadrant:   platforms-and-aoe-services
+tags:       [devops, security]
+---
+
+[Sigstore](https://www.sigstore.dev) is a project by The Linux Foundation® aimed at developing a standard for signing and verifying container images.
+
+While its primary benefit is signing and verifying public images, it can also be used for internal images. Its central tool, `cosign`, allows the signing of container artifacts using a private key within a CI pipeline. This approach enables us to track which job built a specific image and identify the associated codebase. Furthermore, it prevents any malicious entity from tampering with an image or building an image from an unknown source outside the CI pipeline.
+
+With support and funding from The Linux Foundation and its relatively low integration effort, we believe this project has the potential to become the standard for signing container images in open-source projects. [Kubernetes has already begun signing their release artifacts](https://github.com/kubernetes/enhancements/issues/3031) with cosign, and we anticipate that other entities will also adopt it. Therefore, in the future, this ecosystem could serve as a reliable means of verifying the authenticity of public images.

radar/2023-11-01/sketch.md

@@ -0,0 +1,9 @@
+---
+title:      "Sketch"
+ring:       adopt
+quadrant:   tools
+tags:       [ux/ui]
+featured:   false
+---
+
+Sketch is no longer used by Team XD as we have moved to [Figma](/tools/figma.html) and just finished the last project done in Sketch.

radar/2023-11-01/sonarqube.md

@@ -0,0 +1,9 @@
+---
+title:      "SonarQube"
+ring:       adopt
+quadrant:   tools
+tags:       [ci/cd, quality assurance]
+featured:   false
+---
+
+SonarQube remains a good choice for checking your code quality. However, when using GitLab pipelines, it can be replaced with the built-in functionality provided by [GitLab](https://docs.gitlab.com/ee/ci/testing/code_quality.html).

radar/2023-11-01/specflow.md

@@ -0,0 +1,7 @@
+---
+title:      "SpecFlow"
+ring:       assess
+quadrant:   "languages-and-frameworks"
+tags:       [coding, quality assurance]
+featured:   false
+---

radar/2023-11-01/spock_geb.md

@@ -0,0 +1,9 @@
+---
+title:      "Spock + Geb"
+ring:       hold
+quadrant:   languages-and-frameworks
+tags:       [coding, quality assurance]
+featured:   false
+---
+
+Most projects at AOE have transitioned away from Groovy, and other testing frameworks for JVM languages are more advanced and user-friendly. Consequently, mentioning Spock no longer seems relevant.

radar/2023-11-01/state-management-pattern.md

@@ -0,0 +1,14 @@
+---
+title:      "State Management Pattern"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [architecture, coding]
+---
+
+State Management is a design pattern with the goal of efficiently sharing state data across components while separating domain representation from state management. This pattern is widely used in many popular web frameworks such as [Vuex](/languages-and-frameworks/vuex.html) or [Redux](/languages-and-frameworks/redux.html).
+
+Especially in [reactive](/methods-and-patterns/reactive-programming.html) systems, this pattern helps in maintaining decoupled, stateless components with immutable data. The implementation of state management varies and depends on the specific requirements of the application at hand.
+
+For distributed backend systems, one might consider utilizing [Akka's](/languages-and-frameworks/akka.html) cluster sharding module to elastically manage domain object states.
+
+We employ various state management patterns across most [Vue](/languages-and-frameworks/vue.html) and [React](/languages-and-frameworks/react.html) projects that require them.

radar/2023-11-01/stitches.md

@@ -0,0 +1,8 @@
+---
+title:      "Stitches"
+ring:       hold
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+Stitches is [no longer actively maintained](https://github.com/stitchesjs/stitches/discussions/1149#discussioncomment-6223090) due to compatibility issues with CSS-in-JS runtime injection and React 18 Server Components. Therefore, we do not recommend using it for new projects.

radar/2023-11-01/svelte.md

@@ -0,0 +1,12 @@
+---
+title:      "Svelte"
+ring:       trial
+quadrant:   "languages-and-frameworks"
+tags:       [coding, frontend]
+---
+
+We have some smaller [Svelte](https://svelte.dev/) projects at AOE, and there are some features we would like to further explore, such as:
+
+- Compatibility with other libraries or frameworks
+- Server-side rendering by default
+- Exceptional performance

radar/2023-11-01/team-start-page.md

@@ -0,0 +1,7 @@
+---
+title:      "Team Start Page"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [quality assurance, documentation]
+featured:   false
+---

radar/2023-11-01/typescript.md

@@ -0,0 +1,12 @@
+---
+title:      "TypeScript"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+TypeScript has become more widely used and is now considered the industry standard for most JavaScript projects and provides the means to prevent errors during development, refactor code, scale projects, and enhance code collaboration.
+
+Its widespread adoption and the support of a large community contribute to further improving and documenting the language.
+
+TypeScript is our language of choice for both existing and future projects, allowing us to write robust and clean JavaScript code.

radar/2023-11-01/vite.md

@@ -0,0 +1,14 @@
+---
+title:      "Vite"
+ring:       adopt
+quadrant:   tools
+tags:       [frontend, coding]
+---
+
+As modern browsers now support the native usage of [ES Modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), it's possible to use them to enhance frontend development, which is the goal of [Vite](https://vitejs.dev/guide/why.html).
+
+Since its announcement in 2020, Vite has garnered significant attention and has grown a large community that provides pluggable features. Vite offers two key components: a native ESM-based development server and a bundler for production builds.
+
+The development server boasts improved performance during development, as modules are loaded and transpiled only on demand. This leads to faster cold-start times and quicker Hot Module Replacement (HMR) support.
+
+We consider Vite to be a stable and production-ready tool, and we would recommend it for upcoming projects.

radar/2023-11-01/vue.md

@@ -0,0 +1,12 @@
+---
+title:      "Vue.js"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+[Vue](https://vuejs.org/guide/introduction.html) is a progressive and incrementally adoptable framework for building user interfaces, renowned for its simplicity and flexibility. The core library focuses on views, making it easy to integrate with other libraries and existing projects. It excels in powering single-page applications when combined with supporting libraries like [Pinia](https://pinia.vuejs.org), [vue-router](https://router.vuejs.org), and [VueUse](https://vueuse.org). However, it's also versatile enough to build server-side rendered and statically generated web applications using the [Nuxt framework](https://nuxt.com).
+
+Vue's HTML-based template syntax enables declarative binding of the rendered DOM to the underlying Vue instance's data. This, in conjunction with the [reactivity system](https://vuejs.org/guide/extras/reactivity-in-depth.html), ensures high performance by intelligently determining the minimal components to re-render and applying the minimal DOM manipulations when the app-state changes. Furthermore, applications can be organized into [Single File Components](https://vuejs.org/guide/scaling-up/sfc.html), each containing the template (HTML), style (CSS), and functionality (JS). The [Composition API and 'script setup'](https://vuejs.org/api/sfc-script-setup.html) syntax further enhance code readability and modularity, promoting reusability and maintainability throughout the development process.
+
+Vue introduces powerful features like Teleport, which enables components to render at any position on the page, and Fragment, removing the requirement for a single root element in a template. Additionally, Vue enhances performance through Tree-Shaking, reducing bundle size, and Compiler-informed Virtual DOM optimizations, resulting in faster initial renders and updates while consuming less memory.

radar/2023-11-01/webpack.md

@@ -0,0 +1,9 @@
+---
+title:      "Webpack"
+ring:       adopt
+quadrant:   tools
+tags:       [frontend, coding]
+featured:   false
+---
+
+Webpack remains one of the, if not the most, widely used bundlers. The team behind it is continually fixing bugs and adding new features, which are released in major version updates. Despite the emergence of new bundlers in recent years, we still recommend using Webpack.

radar/2023-11-01/yarn.md

@@ -0,0 +1,13 @@
+---
+title:      "Yarn"
+ring:       adopt
+quadrant:   tools
+tags:       [frontend, coding]
+featured:   false
+---
+
+We have decided to move Yarn into the "adopt" ring as it has continued to establish itself in recent years and has proven to be successful in many of our projects.
+
+Yarn consistently offers better performance than npm and, in addition, provides both offline installation and the Plug'n'Play approach. With Plug'n'Play mode, Yarn replaces the node_modules directory with a virtual file system to enhance performance and save disk space.
+
+Yarn is an excellent choice for monorepos, thanks to its support for workspaces, and is highly recommended as a package manager.