chore: set v8 release date

radar/2024-07-10/12-factor-apps.md

@@ -0,0 +1,35 @@
+---
+title:      "12 / 15 factor apps"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [architecture]
+---
+
+The [12-factor app](https://12factor.net/de/) methodology, originally developed by Heroku, provides a comprehensive set of best practices for building cloud-native applications. This methodology emphasizes creating applications that are easy to manage, scalable, and portable across different environments. The [15-factor model](https://developer.ibm.com/articles/15-factor-applications/) extends this framework to address additional concerns relevant in modern cloud-native development.
+
+### Core Principles of 12-Factor Apps
+
+1. **Codebase**: Maintain a single codebase tracked in version control, with multiple deployments.
+2. **Dependencies**: Explicitly declare and isolate dependencies.
+3. **Config**: Store configuration in the environment.
+4. **Backing Services**: Treat backing services as attached resources.
+5. **Build, Release, Run**: Strictly separate build and run stages.
+6. **Processes**: Execute the app as one or more stateless processes.
+7. **Port Binding**: Export services via port binding.
+8. **Concurrency**: Scale out via the process model.
+9. **Disposability**: Maximize robustness with fast startup and graceful shutdown.
+10. **Dev/Prod Parity**: Keep development, staging, and production as similar as possible.
+11. **Logs**: Treat logs as event streams.
+12. **Admin Processes**: Run admin/management tasks as one-off processes.
+
+### Extending to 15 Factors
+
+The 15-factor model builds upon the original principles by adding:
+
+13. **API First**: Design APIs first to ensure interoperability and future-proofing.
+14. **Telemetry**: Implement robust telemetry for monitoring and diagnostics.
+15. **Authentication and Authorization**: Incorporate strong, centralized authentication and authorization mechanisms.
+
+### Relevance
+
+For us, this rather old pattern is still very relevant, and many methods, patterns, and practices on our radar are related and enable these patterns at their core. To name a few, [Kubernetes](/platforms-and-aoe-services/kubernetes/), [Prometheus](/platforms-and-aoe-services/prometheus/), [Self-Service Infrastructure](/platforms-and-aoe-services/self-service-infrastructure/), or the [API-First Design Approach](/methods-and-patterns/api-first-design-approach/) are very related. Others, like [Shared Responsibility Models](/methods-and-patterns/shared-responsibility/), are easier to implement based on this pattern.

radar/2024-07-10/adr.md

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

radar/2024-07-10/akka.md

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

radar/2024-07-10/angular.md

@@ -0,0 +1,16 @@
+---
+title:      "Angular"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+[Angular](https://angular.io/) version 18 introduces transformative features, notably the introduction of Signals and the partnership with Wiz.
+
+Signals offer a more efficient and declarative way to handle reactivity, allowing automatic UI updates with changing data, thus reducing boilerplate and enhancing maintainability.
+
+Standalone components, further refined in Angular 18, reduce module dependency and complexity, promoting a modular and maintainable codebase. Enhancements in monorepo management improve the organization and sharing of components across projects, supporting large-scale applications.
+
+Wiz is a Google internal framework used for performance-critical apps like Google Search. The merge with Wiz brings advanced profiling, debugging, and performance optimization tools from Wiz into Angular, streamlining workflows and improving application performance. This collaboration aims to boost developer productivity and efficiency by combining Angular's framework robustness with Wiz's powerful tools.
+
+Overall, Angular 18's advancements in reactivity and tooling, along with the Wiz integration, significantly boost performance, usability, and developer productivity, solidifying Angular's status as a leading framework for modern web development.

radar/2024-07-10/api-first-design-approach.md

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

radar/2024-07-10/apisix.md

@@ -0,0 +1,15 @@
+---
+title:      "Apache APISIX"
+ring:       trial
+quadrant:   tools
+tags:       [devops]
+---
+
+[Apache APISIX](https://apisix.apache.org/) is an open-source, high-performance API gateway designed for microservices, cloud-native, and container-based architecture. It provides a wide range of features to manage and secure API services:
+
+- **Scalability**: Load balancing and routing, dynamic scaling
+- **Performance**: Fast and reliable, supports caching and rate limiting
+- **Multi-Protocol Support**: Supports HTTP, HTTPS, WebSockets, and gRPC
+- **Customization**: Plugins for authentication, authorization, and traffic management
+
+APISIX is currently in trial at AOE and is being used in multiple projects.

radar/2024-07-10/apm.md

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

radar/2024-07-10/appium.md

@@ -0,0 +1,18 @@
+---
+title:      "Appium"
+ring:       trial
+quadrant:   tools
+tags:       [academy training, quality assurance, ux/ui]
+---
+
+[Appium](https://appium.io) is an open-source automation tool for scripting and testing native, mobile web, and hybrid applications on Android and iOS platforms. It uses the WebDriver protocol to drive iOS and Android applications. Widely used in mobile application testing, Appium allows developers and testers to write tests using the same API across different platforms and programming languages. This reduces the complexity of maintaining separate test suites for each platform, making it a versatile tool for cross-platform mobile testing.
+
+### Key Features
+
+- **Cross-Platform**: Supports Android and iOS, allowing for broad test coverage with a single tool.
+- **Language Agnostic**: Compatible with any programming language that can send HTTP requests.
+- **WebDriver Protocol**: Utilizes the WebDriver standard, ensuring consistency and ease of use.
+- **Extensibility**: Provides a plugin system for custom extensions and functionality.
+- **Community Support**: Benefits from a vibrant open-source community contributing to its growth and stability.
+
+At AOE, we use Appium for testing hybrid and native Android and iOS apps.

radar/2024-07-10/argocd.md

@@ -0,0 +1,8 @@
+---
+title:      "Argo CD"
+ring:       adopt
+quadrant:   tools
+tags:       [ci/cd]
+---
+
+Argo CD has proven its effectiveness in various projects by successfully simplifying and automating Kubernetes application deployments.

radar/2024-07-10/assisted-ai.md

@@ -0,0 +1,21 @@
+---
+title:      "AI Assisted Programming"
+ring:       adopt
+quadrant:   "methods-and-patterns"
+tags:       [ai, architecture, coding]
+---
+
+### Adopting GitHub Copilot
+
+We've adopted AI Assisted Programming to enhance our overall efficiency and product quality, with [GitHub Copilot](/tools/github-copilot/) serving as our primary tool for this purpose.
+
+Guidelines for its usage have been established, and we continuously refine our practices by sharing best practices and insights within our communities.
+
+The use of [GitHub Copilot](/tools/github-copilot/) is currently project-based and requires customer consent. While utilizing it, we remain mindful of potential risks and actively work to mitigate them.
+
+### Potential Risks and Mitigation Strategies
+
+- **Code Quality and Reliability**: Validate and review generated code before integration into the project. Manual code reviews and testing should remain fundamental to the development process.
+- **Security Vulnerabilities**: Conduct thorough security assessments and penetration testing to identify and rectify potential weaknesses. Stay updated with security best practices and ensure AI-generated code aligns with secure coding guidelines.
+- **Intellectual Property Concerns**: Scrutinize licensing and usage terms of AI tools. Exercise caution when incorporating code snippets from external sources and ensure compliance with relevant licenses.
+- **Data Privacy**: Review data access and privacy policies of AI tools meticulously. Prevent inadvertent exposure or sharing of sensitive or confidential information with third parties.

radar/2024-07-10/bun.md

@@ -0,0 +1,10 @@
+---
+title:      "Bun"
+ring:       assess
+quadrant:   tools
+tags:       [coding, frontend]
+---
+
+[Bun](https://bun.sh/) is an all-in-one toolkit for JavaScript and TypeScript environments. It includes a JavaScript runtime, bundler, test runner, and Node.js-compatible package manager. It is designed to optimize the performance and development experience of JavaScript and TypeScript applications. Bun provides fast startup times, native TypeScript support, and improved dependency management.
+
+We are very curious whether Bun is suitable for our projects and fulfills our requirements with regard to professional environments.

radar/2024-07-10/client-side-error-logging.md

@@ -0,0 +1,7 @@
+---
+title:      "Client-Side Error Logging"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [architecture, frontend]
+featured:   false
+---

radar/2024-07-10/conventionalcommits.md

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

radar/2024-07-10/css-in-js.md

@@ -0,0 +1,8 @@
+---
+title:      "CSS-in-JS"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [coding, frontend]
+---
+
+Since the last release, [Stylex](/languages-and-frameworks/stylex/) and [Panda CSS](/languages-and-frameworks/panda-css/) have emerged as the most promising CSS-in-JS solutions for us.

radar/2024-07-10/cypress.md

@@ -0,0 +1,15 @@
+---
+title:      "Cypress"
+ring:       adopt
+quadrant:   tools
+tags:       [academy training, frontend, quality assurance]
+---
+
+[Cypress](https://www.cypress.io/) continues to prove its value in AOE Group projects and has evolved significantly since early 2022. Cypress remains one of our preferred testing tools for front-end developers, thanks to its robust support for JavaScript and [TypeScript](/languages-and-frameworks/typescript/). The ease of adoption and implementation, combined with the maintainability of test specifications, has only improved with recent updates.
+
+### Key Updates and Enhancements of the Past Years
+
+- **Broader Browser Support**: Cypress now supports a wider range of browsers, including Edge and WebKit, in addition to Chrome, Firefox, and Electron. This expansion ensures comprehensive testing across more environments.
+- **Improved Performance**: The latest versions of Cypress have focused on enhancing test execution speed. Optimizations in the core engine and better resource management have resulted in faster and more reliable test runs, even for large and complex test suites.
+- **Enhanced Debugging Capabilities**: Debugging has become even more user-friendly with improved tooling. Features like time travel, where developers can step through each test command, and better error messages help in quickly identifying and resolving issues.
+- **CI/CD Integration**: Cypress has strengthened its integration with popular CI/CD tools. Improved plugins and configurations for platforms like GitHub Actions, GitLab CI, CircleCI, and Jenkins make it easier to incorporate Cypress tests into continuous integration and continuous deployment pipelines.

radar/2024-07-10/decoupling-via-messaging.md

@@ -0,0 +1,13 @@
+---
+title:      "Decoupling via Messaging"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [architecture, devops]
+featured:   false
+---
+
+In recent years, messaging systems have become more robust, scalable, and easier to integrate with existing applications. This has increased the importance of messaging in modern software architectures, making it an essential strategy for decoupling components and ensuring the resilience and stability of distributed systems:
+
+- **Event Streaming**: Platforms such as [Apache Kafka](/tools/kafka/) have evolved significantly to handle massive data streams with enhanced reliability and integration capabilities.
+- **Serverless Messaging**: The rise of [serverless computing](/methods-and-patterns/serverless/) has simplified the creation of scalable, event-driven architectures, allowing developers to build complex workflows and event-processing pipelines without the overhead of managing infrastructure.
+- **Advanced Observability**: Improved tools for monitoring and managing messaging systems now offer detailed insights into message flows and system performance, enabling faster diagnosis and resolution of issues.

radar/2024-07-10/dependency-update-scan.md

@@ -0,0 +1,7 @@
+---
+title:      "Dependency Update Scan"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [coding, security]
+featured:   false
+---

radar/2024-07-10/design-system.md

@@ -0,0 +1,7 @@
+---
+title:      "Design System"
+ring:       adopt
+quadrant:   "methods-and-patterns"
+tags:       [architecture, coding, documentation, frontend, ux/ui]
+featured:   false
+---

radar/2024-07-10/devspace.md

@@ -0,0 +1,14 @@
+---
+title:      "DevSpace"
+quadrant:   tools
+ring:       assess
+tags:       [coding, devops]
+---
+
+[DevSpace](https://www.devspace.sh/) is an open-source developer tool for Kubernetes that lets you develop and deploy cloud-native software faster. As a "client-only" development tool, it is very simple to develop Kubernetes-native applications in local or any remote cluster.
+
+- **Build**, test, and debug applications directly inside Kubernetes.
+- **Develop** with hot reloading: updates your running containers without rebuilding images or restarting containers.
+- **Unify** deployment workflows within your team and across dev, staging, and production.
+- **Automate** repetitive tasks for image building and deployment.
+- **Hot-Reloading** allows to recompile and restart Pods in local or remote clusters.

radar/2024-07-10/elk-stack.md

@@ -0,0 +1,9 @@
+---
+title:      "ELK Stack"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+featured:   false
+---
+
+While we continue to recommend the ELK Stack for specific use cases, we now prefer [Loki](/platforms-and-aoe-services/loki/) for most [Kubernetes](/platforms-and-aoe-services/kubernetes/)-based setups due to its seamless integration, cost efficiency, and user-friendly query language.

radar/2024-07-10/falco.md

@@ -0,0 +1,7 @@
+---
+title:      "Falco"
+ring:       assess
+quadrant:   tools
+tags:       [security]
+featured:   false
+---

radar/2024-07-10/fitness-functions.md

@@ -0,0 +1,23 @@
+---
+title:      "Fitness Functions"
+ring:       assess
+quadrant:   methods-and-patterns
+tags:       [architecture, ci/cd, quality assurance]
+---
+
+[Fitness Functions](https://www.thoughtworks.com/insights/articles/fitness-function-driven-development) are a method for guiding software development decisions based on predefined criteria that ensure software health and alignment with desired outcomes. Inspired by evolutionary algorithms, fitness functions evaluate how well a given solution or set of actions meets specified goals, enabling teams to maintain and improve system quality in a continuous and measurable manner.
+
+### Key Features
+
+- **Objective Measurement**: Provides quantifiable metrics for evaluating various aspects of software quality and performance.
+- **Continuous Monitoring**: Integrates with CI/CD pipelines to continuously assess the system’s fitness against predefined goals.
+- **Automated Feedback**: Offers immediate insight and feedback on the impact of code changes, reducing the risk of degradation over time.
+- **Customizable Criteria**: Allows teams to define fitness functions tailored to specific project needs and quality attributes.
+- **Alignment with Business Goals**: Ensures that technical decisions are aligned with business goals by making trade-offs explicit and measurable.
+- **Evolutionary Approach**: Encourages iterative improvement and adaptation, similar to natural selection processes in evolutionary biology.
+
+[DORA (DevOps Research and Assessment) Metrics](/methods-and-patterns/dora-metrics/), such as deployment frequency, lead time for changes, mean time to recovery, and change failure rate, provide high-level insights into the overall health and effectiveness of an organization's software delivery practices. By integrating fitness functions into development workflows, teams receive detailed, actionable feedback on specific aspects of their systems, leading to continuous improvement in deployment speed, reliability, and quality.
+
+By embedding fitness functions into the CI/CD pipeline, teams can ensure that their applications adhere to architectural standards and quality attributes. This proactive approach helps maintain a robust and scalable architecture that provides a solid foundation for the software as it evolves.
+
+At AOE, we utilize fitness functions to ensure our software systems remain robust, maintainable, and aligned with business goals throughout the development lifecycle.

radar/2024-07-10/flutter.md

@@ -0,0 +1,7 @@
+---
+title:      "Flutter"
+ring:       trial
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend, ux/ui]
+featured:   false
+---

radar/2024-07-10/gitflow.md

@@ -0,0 +1,7 @@
+---
+title:      "GitFlow"
+ring:       hold
+quadrant:   methods-and-patterns
+tags:       [agile, coding, devops]
+featured:   false
+---

radar/2024-07-10/github-copilot.md

@@ -0,0 +1,17 @@
+---
+title:      "GitHub Copilot"
+ring:       adopt
+quadrant:   tools
+tags:       [ai, architecture, coding]
+---
+
+[GitHub Copilot](https://github.com/features/copilot) is an AI-powered code completion tool that integrates seamlessly with popular IDEs to assist our developers by providing code suggestions and automations based on natural language prompts.
+
+### Features and Benefits
+
+- **Contextual Code Suggestions**: Understands the context of your project and suggests relevant code snippets, functions, and even whole classes.
+- **Natural Language Understanding**: Converts natural language comments into functional code, helping developers quickly translate ideas into executable code.
+- **Code Generation Across Languages**: Supports multiple programming languages and frameworks, making it versatile for different project requirements.
+- **Automated Documentation**: Generates documentation comments automatically, aiding in better code maintenance and readability.
+
+See [AI Assisted Programming](/methods-and-patterns/assisted-ai/) for more information on our adoption of AI tools in our development workflows.

radar/2024-07-10/graalnative.md

@@ -0,0 +1,7 @@
+---
+title:      "Graal Native Image"
+ring:       trial
+quadrant:   tools
+tags:       [coding]
+featured:   false
+---

radar/2024-07-10/graphql.md

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

radar/2024-07-10/harbor.md

@@ -0,0 +1,8 @@
+---
+title:      "Harbor"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+---
+
+[Harbor](https://goharbor.io) has become the de-facto standard for self-hosted container registries in our projects.

radar/2024-07-10/invision.md

@@ -0,0 +1,9 @@
+---
+title:      "InVision"
+ring:       hold
+quadrant:   tools
+tags:       [ux/ui]
+featured:   false
+---
+
+InVision will discontinue its design collaboration services (including prototypes, DSM, etc.) at the end of 2024, as announced by CEO Michael Shenkman in [this statement](https://www.invisionapp.com/inside-design/invision-design-collaboration-services-shutdown/).

radar/2024-07-10/k3d.md

@@ -0,0 +1,8 @@
+---
+title:      "K3D"
+ring:       trial
+quadrant:   tools
+tags:       [devops]
+---
+
+[k3d](https://k3d.io/) is a lightweight wrapper to run [k3s](https://k3s.io) (Rancher Lab’s minimal Kubernetes distribution) in Docker. It is a very useful tool to create Kubernetes-native development environments or use it as a sandbox to test out things locally.

radar/2024-07-10/langchain.md

@@ -0,0 +1,19 @@
+---
+title:      "LangChain"
+ring:       trial
+quadrant:   languages-and-frameworks
+tags:       [ai]
+---
+
+[LangChain](https://github.com/langchain-ai/langchain) is a framework designed to enhance the development and deployment of applications leveraging natural language processing (NLP) models. It is particularly suited for applications such as "question-answering," "chatbots," or "conversational agents," often utilizing the [Retrieval Augmented Generation (RAG)](/methods-and-patterns/retrieval-augmented-generation/) pattern.
+
+## Key Features
+
+- **Integration with Multiple NLP Models**: LangChain supports the integration of various NLP models, allowing developers to choose the best-suited models for their specific use cases.
+- **Support for Vector Databases**: The framework can seamlessly connect with different vector databases, which are crucial for implementing RAG patterns and enhancing the retrieval process in NLP applications.
+- **Preconfigured Chains**: LangChain provides pre-built chains for typical NLP tasks, such as question-answering and chatbots, reducing the time and effort required to build these functionalities from scratch.
+- **Compatibility with Open-Source Libraries**: LangChain is designed to work well with established open-source libraries, making it easier for developers to incorporate it into their existing workflows and leverage a wide range of tools and resources.
+- **Ease of Deployment**: The framework simplifies the deployment process of NLP applications, ensuring that they can be quickly and efficiently moved from development to production.
+- **Versatile Use Cases**: LangChain is suitable for a variety of NLP applications, making it a versatile tool for developers working in different domains.
+
+LangChain stands out as a powerful framework for developers, utilizing and integrating well-known open-source libraries.

radar/2024-07-10/microsilos.md

@@ -0,0 +1,17 @@
+---
+title:      "Microsilos"
+quadrant:   methods-and-patterns
+ring:       hold
+tags:       [agile, architecture]
+---
+
+A core concept of Domain-Driven Design (DDD) is the distillation of the problem domain into distinct, bounded contexts, with dedicated teams assigned to and responsible for those contexts. Microservices are often used to implement these bounded contexts in software applications. The communication patterns between teams will shape how these microservices are designed and interact, as per Conway's Law.
+
+Team autonomy is crucial for achieving a truly independent microservice architecture, driving innovation and agility. However, full autonomy can lead to the formation of microsilos: isolated teams working independently, often resulting in inconsistent implementations, communication gaps, hidden dependencies, and redundancies.
+
+### Mitigation Strategies
+- **Strategic Domain-Driven Design**: Ensure that bounded contexts and their interrelationships are well-defined, both organizationally (team structure) and technically (interfaces).
+- **Cross-Team Communication**: Facilitate regular meetings, use collaborative tools, and hold periodic cross-team workshops to improve information sharing and alignment.
+- **Domain Experts and Coordination Roles**: Appoint system architects, domain experts, and integration leads to oversee cross-team coordination and maintain alignment with overall project goals.
+
+It is important to strike a balance between autonomy and alignment to benefit from independence while ensuring cohesive and efficient collaboration across the organization.

radar/2024-07-10/mob-programming.md

@@ -0,0 +1,9 @@
+---
+title:      "Mob Programming"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [agile, coding]
+featured:   false
+---
+
+We have adopted mob programming as it has proven to enhance team collaboration through successful and extensive practice in our work environments.

radar/2024-07-10/monolith-first.md

@@ -0,0 +1,19 @@
+---
+title:      "Monolith First"
+quadrant:   methods-and-patterns
+ring:       trial
+tags:       [architecture]
+---
+
+The [Monolith First](https://martinfowler.com/bliki/MonolithFirst.html) approach advocates starting new projects with a monolithic architecture that is carefully modularized. It balances the simplicity of monolithic systems with the flexibility of microservices by ensuring that the monolith is well-structured into discrete, encapsulated modules.
+
+The concept of the strategic monolith stems from the idea that starting with a monolithic architecture can be beneficial for many organizations, especially when dealing with new or smaller projects. Monoliths are easier to develop, test, and deploy because of their cohesive nature. As Martin Fowler points out, many successful software systems have started as monoliths and only transitioned to microservices when scale or complexity required it. This approach allows teams to manage complexity and maintainability while providing a foundation for potential future transitions to microservices. By modularizing the monolith, developers create clear boundaries within the codebase, making it easier to extract individual services as needed.
+
+### Benefits
+
+- **Future-Proof Architecture**: Modular design within a monolith allows for parts of the system to be easily extracted into individual microservices as requirements evolve or the business grows. This approach ensures that the architecture can adapt to changing needs without extensive refactoring.
+- **Operational Simplicity**: Starting with a monolithic architecture simplifies deployment and management by keeping all modules within a single deployable unit. This reduces the complexity and overhead associated with distributed systems, such as handling inter-service communication, distributed data management, and comprehensive monitoring.
+- **Performance and Latency Benefits**: Intra-process communication within a monolith results in lower latency and higher performance compared to inter-service communication in microservices. This ensures that the system remains responsive and efficient as it scales.
+- **Reduced Complexity**: A "monolith first" approach avoids the initial challenges of distributed systems, allowing teams to focus on building robust features and gaining a deep understanding of the domain before considering a transition to microservices.
+
+At AOE, we strive to follow this approach when starting greenfield projects. We aim to balance between creating systems that are "as small as possible" yet "as big as necessary," ensuring robust and maintainable architectures that can scale and evolve with business needs. This provides a balanced path that aligns immediate development needs with long-term architectural goals.

radar/2024-07-10/nocode-lowcode.md

@@ -0,0 +1,7 @@
+---
+title:      "No-Code / Low-Code"
+ring:       assess
+quadrant:   methods-and-patterns
+tags:       [coding]
+featured:   false
+---

radar/2024-07-10/oci-container.md

@@ -0,0 +1,7 @@
+---
+title:      "OCI Container"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+featured:   false
+---

radar/2024-07-10/ollama.md

@@ -0,0 +1,16 @@
+---
+title:      "Ollama"
+ring:       trial
+quadrant:   tools
+tags:       [ai, coding]
+---
+
+Running large language models locally?
+
+Downloading [Ollama](https://ollama.com/download) and typing `ollama run llama3` is all you need.
+
+Ollama is great for running various open source (open weight) models locally and interacting with them. You can do this either via the command line or via the [Ollama API](https://github.com/ollama/ollama/blob/main/docs/api.md).
+
+Ollama takes care of downloading and running models, and it supports the specification of your own model packages in a "Modelfile".
+
+At AOE, we use it for local development and testing.

radar/2024-07-10/open-api.md

@@ -0,0 +1,29 @@
+---
+title:      "Open API"
+ring:       adopt
+quadrant:   tools
+tags:       [architecture]
+---
+
+The [OpenAPI Specification](https://www.openapis.org/) (OAS) is a broadly adopted industry standard for describing modern REST APIs. Other initiatives like RAML have [joined](https://blogs.mulesoft.com/dev/api-dev/open-api-raml-better-together/) the OpenAPI Initiative.
+
+**OpenAPI v3**
+
+The current version, OpenAPI v3, added more features to the specification, for example, the ability to describe APIs supporting request/callback patterns.
+
+There is a very good API designer: [Apicurio](https://www.apicur.io/) and a good mock generator: [Microcks](http://microcks.github.io/).
+
+The general tool support is excellent. See [OpenAPI Tools](https://openapi.tools/).
+
+**TM Forum Open API**
+
+The TeleManagement Forum (TM Forum) has introduced its own set of Open APIs to foster interoperability and standardization within the telecommunications industry. The TM Forum Open API initiative provides a suite of REST-based APIs designed to accelerate the digital transformation of service providers and their ecosystem partners. These APIs cover a wide range of business scenarios and operational areas, such as customer management, product management, and service activation.
+
+The TM Forum's Open API specifications aim to ensure that diverse systems can interoperate seamlessly, promoting agility and reducing integration costs. The comprehensive documentation and resources provided by TM Forum are instrumental in helping organizations adopt and implement these APIs effectively.
+
+For more information on the TM Forum Open API, visit the following resources:
+- [TM Forum Open API Overview](https://www.tmforum.org/open-apis/)
+- [TM Forum Open API Specifications](https://projects.tmforum.org/wiki/display/API/Open+API+Table)
+- [TM Forum GitHub Repository](https://github.com/tmforum-apis)
+
+These additions from TM Forum further enhance the value of the OpenAPI Specification by providing industry-specific standards that help streamline telecommunications operations.

radar/2024-07-10/opentofu.md

@@ -0,0 +1,8 @@
+---
+title:      "OpenTofu"
+ring:       assess
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+---
+
+[OpenTofu](https://opentofu.org/) is an open-source, community-driven fork of [Terraform](/platforms-and-aoe-services/terraform/) in response to HashiCorp's license changes. It's Terraform 1.6 compatible and can act as a drop-in replacement. We watch development and ecosystem growth closely and evaluate a move from Terraform to OpenTofu in some projects.

radar/2024-07-10/page-composing.md

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

radar/2024-07-10/panda-css.md

@@ -0,0 +1,22 @@
+---
+title:      "Panda CSS"
+ring:       assess
+quadrant:   languages-and-frameworks
+tags:       [frontend, styling]
+---
+
+[Panda CSS](https://panda-css.com/) is a feature-rich and highly versatile [CSS-in-JS](/methods-and-patterns/css-in-js/) library that generates CSS at build time. It provides a great developer experience without the disadvantages of runtime libraries. It is framework-agnostic, but unlike [Stylex](/languages-and-frameworks/stylex/) and Vanilla Extract, it provides JSX-specific features like the `styled` function and style props on top of it.
+
+### Key Features:
+- Compatible with [React Server Components](/methods-and-patterns/react-server-components/)
+- No performance disadvantages compared to runtime libraries
+- Highly versatile:
+  - Recipes and variants like Stitches
+  - Framework-agnostic
+  - `styled` function to create UI components like Stitches
+  - Style props like styled-system
+  - Utility classes like Tailwind
+- W3C-compliant design system with tokens and utilities support
+- Fully typed API
+
+With comprehensive documentation and great community support from the Chakra UI Team, we see a lot of potential for it to become one of the best CSS-in-JS libraries in the future.

radar/2024-07-10/pkl.md

@@ -0,0 +1,12 @@
+---
+title:      "PKL"
+ring:       assess
+quadrant:   languages-and-frameworks
+tags:       [ci/cd, devops]
+---
+
+[PKL](https://pkl-lang.org/) -- pronounced Pickle -- is a configuration language created by Apple. It provides rich support for data templating and validation and can be used simply from the command line, integrated into build pipelines, or embedded into programs. PKL also provides some tooling around package management, which makes it easy to split up bigger projects into packages or just consume packages that are already out there.
+
+Available PKL packages and docs can be found [here](https://pkl-lang.org/package-docs/).
+
+At AOE, we are currently using PKL for the generation of different kinds of DevOps resources like GitLab CI pipelines or Kubernetes resources, but this might change.

radar/2024-07-10/ports-and-adapters.md

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

radar/2024-07-10/puppet.md

@@ -0,0 +1,9 @@
+---
+title:      "Puppet"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+tags:       [devops]
+featured:   false
+---
+
+Puppet has worked well for us for over 11 years.

radar/2024-07-10/react-native.md

@@ -0,0 +1,7 @@
+---
+title:      "React Native"
+ring:       assess
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+featured:   false
+---

radar/2024-07-10/remix.md

@@ -0,0 +1,12 @@
+---
+title:      "Remix"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding, frontend]
+---
+
+With Remix v2.2.0, Remix itself is now just a Vite plugin. This gives us access to the entire ecosystem of Vite plugins and even more, for example:
+
+- **Near-instant dev startup**: Vite lazily compiles your app code on-demand, so the dev server can boot immediately.
+- **Pre-bundled dependencies**: Vite only processes dependencies once, so large libraries like Material UI and AntD don’t become bottlenecks for rebuilds or hot updates.
+- **Incremental hot updates**: Vite keeps track of dependencies so it only needs to reprocess app code that depends on the changes.

radar/2024-07-10/renovate.md

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

radar/2024-07-10/resilience-thinking.md

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

radar/2024-07-10/retrieval-augmented-generation.md

@@ -0,0 +1,26 @@
+---
+title:      "Retrieval Augmented Generation (RAG)"
+ring:       trial
+quadrant:   methods-and-patterns
+tags:       [ai]
+---
+
+[Retrieval Augmented Generation (RAG)](https://blogs.nvidia.com/blog/what-is-retrieval-augmented-generation/) is a method that enhances generative AI models by incorporating external information retrieval. RAG combines the strengths of retrieval-based and generation-based models, enabling AI to generate more accurate and contextually relevant responses by accessing and integrating external data sources during the generation process. This approach often uses embeddings to convert text into high-dimensional vectors and vector databases to efficiently store and retrieve these vectors based on similarity searches. This significantly improves the quality and reliability of AI-generated content, making it particularly useful in applications that require up-to-date information or domain-specific knowledge.
+
+### Benefits
+
+- **Enhanced contextual accuracy**: By integrating external data, RAG models provide more accurate and contextually relevant answers than traditional generative models.
+- **Dynamic information access**: Allows models to retrieve and use the most relevant information available at the time of the query, ensuring up-to-date responses.
+- **Versatile applications**: Suitable for a wide range of use cases, from customer support and virtual assistants to content creation and research, where accurate information is critical.
+- **Sustainable resource utilization**: By leveraging external, up-to-date data sets for information retrieval and combining them with generative capabilities, RAG models reduce the need for extensive data processing and computing power, resulting in lower energy consumption.
+- **Reduced hallucination**: Minimizes the instances of AI generating plausible but incorrect information by grounding responses in verifiable external data.
+
+### Challenges
+
+- **Latency**: Retrieving and processing external data in real-time can introduce latency, potentially slowing down response times compared to purely generative models.
+- **Dependence on external data quality**: The accuracy and relevance of the generated content are highly dependent on the quality and reliability of the external data sources. Poor quality or outdated data can negatively impact the results.
+- **Security and privacy**: Accessing external data sources can expose the system to security vulnerabilities and privacy concerns. Mitigation strategies include careful data access management and robust security measures in the retrieval process.
+- **Maintenance overhead**: Regular updates and maintenance of the retrieval system and data sources are required to ensure continued accuracy and relevance, adding to the operational burden.
+- **Potential for bias**: The retrieval process can introduce biases present in the external data, which can be propagated into the generated content, affecting the fairness and objectivity of the outputs.
+
+At AOE, we are evaluating [LangChain](/languages-and-frameworks/langchain/) as a framework for implementing chatbots that allow users to better interact with existing knowledge and ensure that they deliver accurate, contextual, and reliable information.

radar/2024-07-10/rxjava.md

@@ -0,0 +1,7 @@
+---
+title:      "RxJava"
+ring:       trial
+quadrant:   tools
+tags:       [architecture, coding]
+featured:   false
+---

radar/2024-07-10/scala3.md

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

radar/2024-07-10/self-service-infrastructure.md

@@ -0,0 +1,7 @@
+---
+title:      "Self-Service Infrastructure"
+ring:       trial
+quadrant:   platforms-and-aoe-services
+tags:       [agile, devops]
+featured:   false
+---

radar/2024-07-10/service-mesh.md

@@ -0,0 +1,10 @@
+---
+title:      "Service Mesh"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+tags:       [architecture, devops, security]
+---
+
+Service Meshes are part of all our Kubernetes implementations now. We value the additional security features they provide to our platforms.
+
+We are using [Istio](https://istio.io/) on multiple production clusters and are assessing [Cilium](https://docs.cilium.io/en/latest/network/servicemesh/) as it also improves on Kubernetes' NetworkPolicies. We also consider [Linkerd](https://linkerd.io) a good candidate when looking for a Service Mesh for your project.

radar/2024-07-10/socketio.md

@@ -0,0 +1,8 @@
+---
+title:      "Socket.IO"
+ring:       assess
+quadrant:   tools
+tags:       [architecture, coding]
+---
+
+[Socket.IO](https://socket.io) is a library for enabling real-time, bidirectional communication between web clients and servers based on websockets. It simplifies complex tasks involved in real-time data transfer and supports features like automatic reconnection and fallback to different transports if needed. This makes it ideal for applications such as chat apps, live notifications, and collaborative tools. Its event-based architecture and support for namespaces and rooms make it versatile and scalable. We are currently evaluating if its usage could be beneficial for some of our projects.

radar/2024-07-10/spring-boot.md

@@ -0,0 +1,14 @@
+---
+title:      "Spring Boot"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags:       [coding]
+---
+
+For new microservices in a cloud environment, Spring Boot is still one of our defaults. In addition to the aforementioned reasons, we at AOE especially like the following features:
+
+- Full integration with the [Kotlin language](/languages-and-frameworks/kotlin/)
+- Excellent plugins and libraries for supporting GraphQL ([DGS Framework](https://netflix.github.io/dgs/), [Spring for GraphQL](https://spring.io/projects/spring-graphql))
+- Easy-to-use and powerful provision of RESTful services, including support for [OpenAPI](/tools/open-api/)
+- Support for many cache providers, including distributed and replicated caches
+- Metrics and monitoring support with [Micrometer](https://micrometer.io/)

radar/2024-07-10/spring-rest-docs.md

@@ -0,0 +1,7 @@
+---
+title:      "Spring REST Docs"
+ring:       hold
+quadrant:   tools
+tags:       [documentation]
+featured:   false
+---

radar/2024-07-10/strategic-domain-driven-design.md

@@ -0,0 +1,16 @@
+---
+title:      "Strategic Domain-Driven Design"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [academy training, architecture]
+---
+
+With the increasing complexity of software systems, Strategic Domain-Driven Design has become more and more important. Aligning software design with business needs through tactical and strategic patterns has proven invaluable, especially in the era of microservices and Agile methodologies.
+
+In addition, new tools and techniques have emerged that support the practical application of Strategic Domain-Driven Design, such as:
+
+* **Core Domain Charts**: Introduced by Eric Evans in 2019, these support the identification and prioritization of core business domains, ensuring that critical areas receive appropriate focus and resources.
+* **Event Storming**: A popular workshop format for collaboratively exploring complex domains, facilitating a shared understanding and uncovering domain insights.
+* **Wardley Maps**: Created by Simon Wardley, these are a visualization tool that helps organizations understand their business landscape, anticipate change, and identify strategic opportunities.
+
+The continuing relevance of Eric Evans' *Domain-Driven Design*, more than 20 years after the book was first published, underscores its importance in modern software development.

radar/2024-07-10/stride-threat-modeling.md

@@ -0,0 +1,7 @@
+---
+title:      "STRIDE Threat Modeling"
+ring:       trial
+quadrant:   methods-and-patterns
+tags:       [security]
+featured:   false
+---

radar/2024-07-10/stylex.md

@@ -0,0 +1,19 @@
+---
+title:      "StyleX"
+ring:       assess
+quadrant:   languages-and-frameworks
+tags:       [frontend, styling]
+---
+
+Facebook has released [StyleX](https://stylexjs.com/), an open-source JavaScript syntax and compiler for styling web apps. It combines the developer experience of [CSS-in-JS](/methods-and-patterns/css-in-js/) libraries with the performance and scalability of static CSS using compile-time tools.
+
+It supports frameworks like [React](/languages-and-frameworks/react/) and [Angular](/languages-and-frameworks/angular/). Styles are defined using an object syntax and `create()` API, and can be conditionally applied within components.
+
+### Key Features
+- **Atomic CSS**: Minimizes CSS output
+- **Type-Safe**: Ensures reliability in large projects
+- **Composable**: Facilitates reusable components
+- **Fast Performance**: Optimized for speed
+- **Scalable and Predictable**: Ideal for large projects
+
+We are eager to evaluate how well StyleX will integrate into our projects.

radar/2024-07-10/supply-chain-security.md

@@ -0,0 +1,23 @@
+---
+title:      "Supply Chain Security"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [devops, security]
+---
+
+Software supply chain security is a complex endeavor. Attack vectors range from external dependencies in source code to operating systems and tools used in build, test, and production environments. Compromise of a single stage of the supply chain may lead to compromise of the produced software and subsequently of customers that rely on it.
+
+Over the last few years, successful attacks on large software vendors have demonstrated the potential impact of such attacks. For instance, the SolarWinds Orion software was [compromised](https://en.wikipedia.org/wiki/SolarWinds#2019%E2%80%932020_supply_chain_attacks) due to an insecure password that allowed attackers to inject a backdoor into software artifacts. Several SolarWinds customers, including US federal government agencies, were compromised as a result of this attack. The [xz backdoor](https://tukaani.org/xz-backdoor/) showed that malicious parties are also stepping up their efforts to place backdoors in widely used open-source software projects in ways that are very hard to detect and prevent.
+
+Software libraries and other external dependencies are a major attack vector when building software. We use the following measures regarding external dependencies to improve supply chain security:
+
+- Verify dependency artifact signatures and checksums to detect artifacts that were released or replaced by an attacker.
+- Raise developer awareness regarding malicious dependencies and issues such as typosquatting in dependency package managers.
+- Generate [Software Bills of Materials (SBOMs)](/platforms-and-aoe-services/sbom/) for transparency regarding used software dependencies and to support the automated detection of known vulnerabilities.
+- Evaluate and reduce the number of external dependencies to minimize the attack surface.
+
+We believe that supply chain security can only be achieved when taking every step of the supply chain into account. Therefore, we utilize the DevSecOps lifecycle and evaluate potential attack vectors and countermeasures for the complete software development and operation lifecycle. As a result, we use the following general measures to improve supply chain security:
+
+- Secure build, test, and deployment environments with [Zero Trust](/methods-and-patterns/zero-trust/).
+- Sign built software artifacts and verify the signature of artifacts before deploying them.
+- Use static application security testing (SAST) and dynamic application security testing (DAST) to scan for known vulnerabilities and logic flaws before deploying artifacts to production environments.

radar/2024-07-10/svelte.md

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

radar/2024-07-10/temporal-modeling.md

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

radar/2024-07-10/terraform.md

@@ -0,0 +1,13 @@
+---
+title:      "Terraform"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+tags:       [academy training, devops]
+featured:   false
+---
+
+Terraform has become a de facto standard as a cloud-provider-agnostic infrastructure-as-code tool in recent years.
+
+Unfortunately, the [license change for HashiCorp products in August 2023](https://www.hashicorp.com/blog/hashicorp-adopts-business-source-license) has caused [some](https://blog.gruntwork.io/the-future-of-terraform-must-be-open-ab0b9ba65bca) [turmoil](https://zeet.co/blog/the-impact-of-hashicorps-license-change-on-terraform-users-and-providers-what-you-need-to-know) within the open-source community. Terraform can no longer be considered truly open source. Of particular concern are the [usage limitations that prohibit "competitive offerings" to HashiCorp's products](https://www.hashicorp.com/license-faq#usage-limitations). The vagueness of this definition, coupled with the fact that HashiCorp can change their interpretation of what constitutes a "competitive offer" at any time, poses a potential liability for agencies and their customers.
+
+As a result, we are currently [assessing OpenTofu](/platforms-and-aoe-services/opentofu/) as a drop-in replacement for Terraform. [OpenTofu](https://opentofu.org) is an open-source fork under the umbrella of the Linux Foundation, created from the last commit before Terraform's license change.

radar/2024-07-10/trivy.md

@@ -0,0 +1,9 @@
+---
+title:      "Trivy"
+ring:       adopt
+quadrant:   tools
+tags:       [ci/cd, devops, security]
+featured:   false
+---
+
+See [Supply Chain Security](/methods-and-patterns/supply-chain-security/) for updated recommendations.

radar/2024-07-10/turborepo.md

@@ -0,0 +1,7 @@
+---
+title:      "Turborepo"
+ring:       trial
+quadrant:   tools
+tags:       [frontend]
+featured:   false
+---

radar/2024-07-10/unleash.md

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

radar/2024-07-10/vistecture.md

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

radar/2024-07-10/visual-regression-tests.md

@@ -0,0 +1,16 @@
+---
+title:      "Visual Regression Tests for Frontend Developers"
+ring:       adopt
+quadrant:   methods-and-patterns
+tags:       [coding, frontend, quality assurance]
+---
+
+In the realm of frontend development, ensuring that applications not only function correctly but also look as intended across various devices and browsers is paramount. This is where visual regression tests come into play, solving a critical problem faced by developers: detecting unintended visual changes. By automating the comparison of screenshots over time, these tests can identify differences between expected and actual UI appearances, down to the pixel level. In this respect, they exceed and replace some use cases of traditional unit tests, which focus on functional aspects of the code.
+
+Visual regression tests address several challenges. They ensure consistency in the user interface, a crucial aspect of user experience. They also significantly reduce the manual effort required to check visual aspects of an application across different environments. This automation speeds up the development process, allowing for quicker feedback and iterations compared to debugging visual issues in the terminal.
+
+Moreover, integrating visual regression tests into development pipelines enhances the reliability of deployments. By catching visual discrepancies early, it prevents potential UI issues from reaching end-users. This not only saves time and resources but also maintains the application's quality and reputation.
+
+Currently, several AOE teams use visual regression tests with [Playwright](/tools/playwright/) in their daily operations, with more teams expected to adopt this practice in the future.
+
+In summary, visual regression tests are an invaluable tool for frontend developers. They streamline the development process, ensure visual consistency, and maintain high-quality user interfaces, making them an essential part of modern web development workflows.