Merge branch 'radar-2021-01-01' into newBuilderVersion

radar/2017-03-01/akeneo.md

@@ -13,6 +13,6 @@ We use Akeneo with success in our projects and products (For example in OM3), wh
 -   Managing livecycles of products and managing product portfolios with their category structures
 -   Managing attributes and families and therefore acting as attribute master for the suite
 
-The system has a modern and friendly user interface and product managers find things such as completenesscheck, translation views and mass editing very helpful.
+The system has a modern and friendly user interface and product managers find things such as completenesscheck, translation views and mass editing very helpful.
 
-With delta export and import capabilities and the usage of Mongo DB as persitence backend, the performance is acceptable. We miss a richer API - but the system is extendable and based on PHP/Symfony 2.
+With delta export and import capabilities and the usage of Mongo DB as persitence backend, the performance is acceptable. We miss a richer API - but the system is extendable and based on PHP/Symfony 2.

radar/2017-03-01/ant.md

@@ -4,6 +4,6 @@ ring:       hold
 quadrant:   tools
 
 ---
-Apache Ant was build in 1997 to have something like Make in the C/C++ world for Java. Ant uses xml files to describe steps required to produce executable artifacts from source code. The main concepts of tasks and targets are programmable in an imperative style.
+Apache Ant was build in 1997 to have something like Make in the C/C++ world for Java. Ant uses xml files to describe steps required to produce executable artifacts from source code. The main concepts of tasks and targets are programmable in an imperative style.
 
-Apache Ant was and is widely used by large software projects. Our recommendation is to stop using Apache Ant for new projects. If you are free to choose, we recommend Gradle as an Apache Ant replacement.
+Apache Ant was and is widely used by large software projects. Our recommendation is to stop using Apache Ant for new projects. If you are free to choose, we recommend Gradle as an Apache Ant replacement.

radar/2017-03-01/anypoint-platform.md

@@ -6,8 +6,8 @@ quadrant:   tools
 ---
 Anypoint platform (formally known as Mule or Mule ESB) is an Enterprise Integration Platform written in Java.
 
-Anypoint provide tools to use Enterprise Integration Patterns (EAI) and has a high number of ready-to-use connectors to communicate with software tools such as SAP, Salesforce, etc.
+Anypoint provide tools to use Enterprise Integration Patterns (EAI) and has a high number of ready-to-use connectors to communicate with software tools such as SAP, Salesforce, etc.
 
-Anypoint Community Version is Open Source and contribution is possible. The platform is pluggable with own connectors. Mulesoft is also driving the [raml](/tools/raml.html) specification and related Open Source tools.
+Anypoint Community Version is Open Source and contribution is possible. The platform is pluggable with own connectors. Mulesoft is also driving the [raml](/tools/raml.html) specification and related Open Source tools.
 
-AOE is a Mulesoft Partner and we use both the Community and Enterprise Versions of Anypoint. We use Anypoint as an API Gateway to combine and transform data from multiple backends. We use it as ESB or Integration platform for loose coupling of software components. And we also use it as legacy modernization to provide modern APIs for legacy- or foreign software.
+AOE is a Mulesoft Partner and we use both the Community and Enterprise Versions of Anypoint. We use Anypoint as an API Gateway to combine and transform data from multiple backends. We use it as ESB or Integration platform for loose coupling of software components. And we also use it as legacy modernization to provide modern APIs for legacy- or foreign software.

radar/2017-03-01/artifactory.md

@@ -4,7 +4,7 @@ ring:       trial
 quadrant:   platforms-and-aoe-services
 
 ---
-JFrog [Artifactory ](https://www.jfrog.com/open-source/)is a software tool, which, in the end, manages and stores (binary) artifacts.
+JFrog [Artifactory ](https://www.jfrog.com/open-source/)is a software tool, which, in the end, manages and stores (binary) artifacts.
 In addition to storage, it provides a managing interface, which also allows to store build information, properties as well as dependencies per artifact which are organized within repositories. A fine grained security system enables easy management of which artifacts are available to whom.
 The artifacts are exposed via an HTTP(S)-Url Artifactory, which can generate package-manager compatible manifests for the repositories. AOE utilizes Artifactory to serve Maven, Apt, Npm, Composer and Docker Repositories.
 

radar/2017-03-01/bower.md

@@ -5,7 +5,7 @@ quadrant:   tools
 
 ---
 
-[Bower](https://bower.io/) is a package manager for frontend resources such as JavaScript libraries and CSS frameworks. Compared to [npm](https://www.npmjs.com/), it has a somewhat different approach to loading and resolving the packages, resulting in a smaller and cleaner folder structure.
+[Bower](https://bower.io/) is a package manager for frontend resources such as JavaScript libraries and CSS frameworks. Compared to [npm](https://www.npmjs.com/), it has a somewhat different approach to loading and resolving the packages, resulting in a smaller and cleaner folder structure.
 
 In small web projects, this approach is good and sufficient, but larger projects will need more dependencies such as task runners or testing frameworks, which are not available through Bower. As most of the frontend libraries are also available through npm, it's not suprising that we ask ourselves why Bower is still needed.
 

radar/2017-03-01/consul.md

@@ -7,6 +7,6 @@ quadrant:   tools
 Consul is a lightweight service to provide a service discovery registry with failure detection (health checks) for circuit breakers. It also provides configuration management with key/value storage.\
 The typical way to use it is that a consul master cluster takes care of the update and write processes and consul clients run locally on the apps host - data is shared accross the complete Consul cluster. The data can be accessed by using DNS and HTTP APIs.
 
-At AOE, we use Consul for settings distribution with consul-template as a way to do [Settings Injection](/methods-and-patterns/settings-injection.html) during deployment. Consul is also used as service discovery between apps inside [microservice](/methods-and-patterns/microservices.html) environments.
+At AOE, we use Consul for settings distribution with consul-template as a way to do [Settings Injection](/methods-and-patterns/settings-injection.html) during deployment. Consul is also used as service discovery between apps inside [microservice](/methods-and-patterns/microservices.html) environments.
 
 With Vault there is another tool that can be used to manage and share secrets.

radar/2017-03-01/dagger.md

@@ -5,6 +5,6 @@ quadrant:   tools
 
 ---
 
-[Dagger](https://google.github.io/dagger/) is a fully static, compile-time [dependency injection](http://en.wikipedia.org/wiki/Dependency_injection) framework for both Java and Android. [Dagger](https://google.github.io/dagger/) doesn't use reflections at runtime, it saves resources. For us, it is a perfect match for Android development.
+[Dagger](https://google.github.io/dagger/) is a fully static, compile-time [dependency injection](http://en.wikipedia.org/wiki/Dependency_injection) framework for both Java and Android. [Dagger](https://google.github.io/dagger/) doesn't use reflections at runtime, it saves resources. For us, it is a perfect match for Android development.
 
 We at AOE use it as a base framework for every Android project.

radar/2017-03-01/decoupling-infrastructure-via-messaging.md

@@ -4,6 +4,6 @@ ring:       trial
 quadrant:   methods-and-patterns
 
 ---
-In [Microservices](/methods-and-patterns/microservices.html) we have already covered the trend that modern architectures are moving away more and more from big monolithic applications to distributed software suites. The result of splitting our software and infrastructure in smaller parts, is the need to communicate with each other. This can be done by direct communication or by message-based asynchronouous communication. While synchronuous communication allows for more plannable "real-time" response times of the overall systems, asynchronouos communication increases the resilience and stability of the system significantly and allows one to use other integration and scaling patterns. However, it often comes with additional complexity.
+In [Microservices](/methods-and-patterns/microservices.html) we have already covered the trend that modern architectures are moving away more and more from big monolithic applications to distributed software suites. The result of splitting our software and infrastructure in smaller parts, is the need to communicate with each other. This can be done by direct communication or by message-based asynchronouous communication. While synchronuous communication allows for more plannable "real-time" response times of the overall systems, asynchronouos communication increases the resilience and stability of the system significantly and allows one to use other integration and scaling patterns. However, it often comes with additional complexity.
 
-Most of the IaaS Cloud providers offer messaging services such as AWS SQS which provide the possibility to decouple our infrastructure via Messaging. Also, we use [RabbitMQ](/tools/rabbitmq.html) as a Messaging and Broker solution within our applications. The decision of using messaging and messaging patterns as an integration strategy can be made as part of [strategic design](/methods-and-patterns/strategic-domain-driven-design.html) considerations.
+Most of the IaaS Cloud providers offer messaging services such as AWS SQS which provide the possibility to decouple our infrastructure via Messaging. Also, we use [RabbitMQ](/tools/rabbitmq.html) as a Messaging and Broker solution within our applications. The decision of using messaging and messaging patterns as an integration strategy can be made as part of [strategic design](/methods-and-patterns/strategic-domain-driven-design.html) considerations.

radar/2017-03-01/docker.md

@@ -13,6 +13,6 @@ In a DevOps environment, this helps a lot as we can run the exact same software
 
 Also, Docker allows us to keep our development setup much smaller and faster; instead of VirtualBox setups on a per-project base, we can compose our project development setup out of small containers. A CI environment building the containers allows us to package and test the whole environment instead of different software components on different runtimes in a much more stable way.
 
-Backed by services such as [Kubernetes](/platforms-and-aoe-services/kubernetes.html), we can deploy Docker containers on a flexible infrastructure and enable our developers to test their software more easily in different environments.
+Backed by services such as [Kubernetes](/platforms-and-aoe-services/kubernetes.html), we can deploy Docker containers on a flexible infrastructure and enable our developers to test their software more easily in different environments.
 
 Here at AOE, we assess Docker in different projects to become more flexible and faster, which increases our focus on development of even better and more stable software.

radar/2017-03-01/elasticsearch.md

@@ -6,4 +6,4 @@ quadrant:   platforms-and-aoe-services
 ---
 Elasticsearch is a REST-based search and analytics engine based on Lucene. Unlike its competitor Apache Solr, it was developed in the beginning with clustering and scaling in mind. It allows you to create complex queries while still delivering results very fast.
 
-At AOE, we use Elasticsearch for logging as well as our own search solution [Searchperience®](http://www.searchperience.com/). We recently moved the Searchperience stack from Solr to Elasticsearch and think this was the right decision. Especially in terms of scaling, ease of use and performance, Elasticsearch really shines. Also, the API design took some of the learnings from Apache SOLR into account - for example, the queryDSL is a powerful way of describing different search use cases with highly flexible support of aggregations, etc.
+At AOE, we use Elasticsearch for logging as well as our own search solution [Searchperience®](http://www.searchperience.com/). We recently moved the Searchperience stack from Solr to Elasticsearch and think this was the right decision. Especially in terms of scaling, ease of use and performance, Elasticsearch really shines. Also, the API design took some of the learnings from Apache SOLR into account - for example, the queryDSL is a powerful way of describing different search use cases with highly flexible support of aggregations, etc.

radar/2017-03-01/explicit-test-strategy.md

@@ -4,17 +4,17 @@ ring:       assess
 quadrant:   methods-and-patterns
 
 ---
-According to the [ISTQB Glossar](http://glossar.german-testing-board.info/#teststrategie)- a **Test Strategy** is an abstract specification that comprises the designated test levels (unit, integration, system and acceptance tests) and the implementation of each level for a whole organization or for an application. This test strategy can be applicable to one or more projects.
+According to the [ISTQB Glossar](https://glossary.istqb.org/)- a **Test Strategy** is an abstract specification that comprises the designated test levels (unit, integration, system and acceptance tests) and the implementation of each level for a whole organization or for an application. This test strategy can be applicable to one or more projects.
 
 At AOE, we established an explicit test strategy for many of our projects. The coordination of the test levels improves the effectivity of test runs and helps to avoid testing gaps, double inspection and overhead. Every test level has a different focus. Tests that are executed on one level don't have to be implemented on others.
 
 These are the test levels that we implement as a standard in the software deployment pipeline of our projects and that handle multiple integrated components and services:
 
--   **Unit Test:** The unit level tests verify the functionality of a specific section of code, usually at the function level. We use static as well as dynamic test methods such as code reviews, style or complexity checks and white-box testing. 
+-   **Unit Test:** The unit level tests verify the functionality of a specific section of code, usually at the function level. We use static as well as dynamic test methods such as code reviews, style or complexity checks and white-box testing. 
--   **Module Tests:** Module Tests focus on testing the functionality that a service or component provides in isolation to other components or services that this service depends on. This test stage finds errors in a component. It should never fail due to a consumed service that is not reachable or has been altered. Therefore, all dependencies of these components are mocked or stubbed on some level. Tests are most commonly conducted through interfaces using black-box testing.
+-   **Module Tests:** Module Tests focus on testing the functionality that a service or component provides in isolation to other components or services that this service depends on. This test stage finds errors in a component. It should never fail due to a consumed service that is not reachable or has been altered. Therefore, all dependencies of these components are mocked or stubbed on some level. Tests are most commonly conducted through interfaces using black-box testing.
--   **Integration Tests:** On the integration level, individual software modules are combined and tested as a group. The integration testing verifies functional, performance and reliability requirements. These tests are also most commonly conducted through interfaces using black-box testing. In case there is a great number of (external) subsystems, we mock these systems outside of the defined context and use contract-based testing to verify the interfaces. All contract-based tests that focus on testing the interface contracts between services are also executed on this test level.
+-   **Integration Tests:** On the integration level, individual software modules are combined and tested as a group. The integration testing verifies functional, performance and reliability requirements. These tests are also most commonly conducted through interfaces using black-box testing. In case there is a great number of (external) subsystems, we mock these systems outside of the defined context and use contract-based testing to verify the interfaces. All contract-based tests that focus on testing the interface contracts between services are also executed on this test level.
--   **System Level Tests:** On the system level, tests are performed on a complete, integrated system, where they evaluate the system's compliance with its specified requirements. System tests not only verify the design, but they also check the system's behavior in general and even the assumed expectations of the customer. They are intended to test up to and beyond the bounds defined by the explicit system requirements.
+-   **System Level Tests:** On the system level, tests are performed on a complete, integrated system, where they evaluate the system's compliance with its specified requirements. System tests not only verify the design, but they also check the system's behavior in general and even the assumed expectations of the customer. They are intended to test up to and beyond the bounds defined by the explicit system requirements.
--   **Client Acceptance Tests:** The client acceptance level includes all testing done by the customer and is the last one in the succession of the five test levels. The objective is to evaluate the system's compliance with the business requirements and to assess whether it is acceptable for delivery.
+-   **Client Acceptance Tests:** The client acceptance level includes all testing done by the customer and is the last one in the succession of the five test levels. The objective is to evaluate the system's compliance with the business requirements and to assess whether it is acceptable for delivery.
 
 As a rule, we automate the execution of tests where it is feasible and sensible. Related to the test strategy are the test concept, test data management and the usage of a test case management tool that allows one to assess and categorize functional test cases.
 

radar/2017-03-01/galen.md

@@ -5,9 +5,9 @@ quadrant:   tools
 
 ---
 
-With [Galen Framework](http://galenframework.com/), layout testing can be automated to save you a lot of manual work. With its own specification language (Galen Spec), you can write tests to verify the correct look of the web page as well as the location and alignment of specific elements on a page.
+With [Galen Framework](http://galenframework.com/), layout testing can be automated to save you a lot of manual work. With its own specification language (Galen Spec), you can write tests to verify the correct look of the web page as well as the location and alignment of specific elements on a page.
 
-So, you can write simple tests such as "The button should be green" as well as more complex behavior specifications such as "On mobile devices the button should be inside the viewport". Especially when testing a responsive website on multiple devices, browsers and resolutions, the manual testing effort gets expensive. To help with that, Galen runs its specifications fully automated with Selenium against the required browsers and devices.
+So, you can write simple tests such as "The button should be green" as well as more complex behavior specifications such as "On mobile devices the button should be inside the viewport". Especially when testing a responsive website on multiple devices, browsers and resolutions, the manual testing effort gets expensive. To help with that, Galen runs its specifications fully automated with Selenium against the required browsers and devices.
 
 Whenever a test fails Galen writes a test report with screenshots to show the mismatching areas on the page to help testers and developers become aware of the problem.
 

radar/2017-03-01/gatlin.md

@@ -4,11 +4,11 @@ ring:       trial
 quadrant:   tools
 
 ---
-[Gatling](http://gatling.io/) is a highly capable load testing tool. It is designed for ease of use, maintainability and high performance.
+[Gatling](http://gatling.io/) is a highly capable load testing tool. It is designed for ease of use, maintainability and high performance.
 
 Out of the box, Gatling comes with excellent support of the HTTP protocol that makes it a tool of choice for load testing any HTTP server. As the core engine is actually protocol agnostic, it is perfectly possible to implement support for other protocols. For example, Gatling currently also ships [JMS support](http://gatling.io/docs/current/).
 
-Gatling is built with [Scala Lang](https://extranet.aoe.com/confluence/display/knowledge/Scala+Lang) and [Akka](https://extranet.aoe.com/confluence/display/knowledge/Akka). By making good use of Scala's native language features (such as as the extensive type system), it makes writing tests feel natural and expressive, instead of writing load tests based on a DSL encoded in some special syntax.
+Gatling is built with [Scala Lang](/languages-and-frameworks/scala-lang.html) and [Akka](/languages-and-frameworks/akka.html). By making good use of Scala's native language features (such as as the extensive type system), it makes writing tests feel natural and expressive, instead of writing load tests based on a DSL encoded in some special syntax.
 
 This allows us to use all native Scala features to work with, with the focus on the ability to structure your tests as pure code, and actually unit test your load tests.
 

radar/2017-03-01/gradle.md

@@ -10,4 +10,4 @@ It uses a Groovy-based DSL to declaratively model your problem domain (Build aut
 
 While providing plugins for building libs, apps and webapps in Java, Groovy and Scala out of the box it is not tied to the JVM as target platform, which is impressively shown by the native build support for C / C++.
 
-At AOE, it is used in various places already: to build [Anypoint](/tools/anypoint-platform.html)- and [Spring Boot-](/languages-and-frameworks/spring-boot.html) based applications; to build Android Apps; to automate the creation of Jenkins Jobs; to create Docker images and Debian packages and also do some deployment scripting with it.
+At AOE, it is used in various places already: to build [Anypoint](/tools/anypoint-platform.html)- and [Spring Boot-](/languages-and-frameworks/spring-boot.html) based applications; to build Android Apps; to automate the creation of Jenkins Jobs; to create Docker images and Debian packages and also do some deployment scripting with it.

radar/2017-03-01/hystrix.md

@@ -1,5 +1,5 @@
 ---
-title:      "Hystrix "
+title:      "Hystrix"
 ring:       assess
 quadrant:   tools
 

radar/2017-03-01/imgix.md

@@ -4,7 +4,7 @@ ring:       assess
 quadrant:   platforms-and-aoe-services
 
 ---
-[Imgix](https://www.imgix.com/) is an SaaS solution for delivering and processing images. When developing responsive websites, you will quickly reach the point where you need various versions of your images to achieve a good responsive user interface. You want high quality versions for retina displays but small versions for mobile devices with a slow Internet connection.
+[Imgix](https://www.imgix.com/) is an SaaS solution for delivering and processing images. When developing responsive websites, you will quickly reach the point where you need various versions of your images to achieve a good responsive user interface. You want high quality versions for retina displays but small versions for mobile devices with a slow Internet connection.
 
 Especially when dealing with user-generated uploads, it is getting hard to create different versions for any supported device and breakpoint of your web page. Doing this manually is hardly an option.
 

radar/2017-03-01/infrastructure-as-code.md

@@ -7,6 +7,6 @@ quadrant:   methods-and-patterns
 
 Infrastructure as Code (IaC) describes the process of managing all infrastructure resources via code. Treating infrastructure code the same way we treat application code, we can benefit from the same advantages of having a history in our version control system, doing code reviews and rolling out updates via a Continuous Delivery pipeline in a way that closely approaches how we handle application deployments.
 
-Infrastructure code is often described in a declarative language und the target platforms figure out what to create, update or delete in order to get to the desired state, while doing this in a safe and efficient way. We've worked with [AWS CloudFormation](https://aws.amazon.com/de/cloudformation/) in the past, and while this is a great tool, you can only manage AWS resources with it and you need some more tooling around it in order to automate things nicely and embed it into other processes such as Jenkins Jobs. That's what we created [StackFormation](https://github.com/AOEpeople/StackFormation) for. Another tool that is actively developed is [Terraform](https://www.terraform.io/). Terraform comes with a lot of concepts that make managing environments easier out of the box and nicely embeds into other related tools. Also, Terraform allows you to manage a variety of different infrastructure providers.
+Infrastructure code is often described in a declarative language und the target platforms figure out what to create, update or delete in order to get to the desired state, while doing this in a safe and efficient way. We've worked with [AWS CloudFormation](https://aws.amazon.com/de/cloudformation/) in the past, and while this is a great tool, you can only manage AWS resources with it and you need some more tooling around it in order to automate things nicely and embed it into other processes such as Jenkins Jobs. That's what we created [StackFormation](https://github.com/AOEpeople/StackFormation) for. Another tool that is actively developed is [Terraform](https://www.terraform.io/). Terraform comes with a lot of concepts that make managing environments easier out of the box and nicely embeds into other related tools. Also, Terraform allows you to manage a variety of different infrastructure providers.
 
 Infrastructure as code should cover everything from orchestration of your infrastructure resources, networking and provisioning as well as monitoring setup. The orchestration tools mentioned above are supplemented by other tools such as Puppet, Chef or simple Bash scripts that take over provisioning the instances after they are booted.

radar/2017-03-01/job-dsl.md

@@ -4,8 +4,8 @@ ring:       trial
 quadrant:   tools
 
 ---
-The [Job DSL ](https://wiki.jenkins-ci.org/display/JENKINS/Job+DSL+Plugin)is a plugin for the Jenkins automation server. Jenkins jobs that automate parts of a software project are usually configured using the web interface of Jenkins. If Jenkins is the choice for your project and the number of build jobs tend to grow, the Job DSL plugin is your friend.
+The [Job DSL ](https://wiki.jenkins-ci.org/display/JENKINS/Job+DSL+Plugin)is a plugin for the Jenkins automation server. Jenkins jobs that automate parts of a software project are usually configured using the web interface of Jenkins. If Jenkins is the choice for your project and the number of build jobs tend to grow, the Job DSL plugin is your friend.
 
-The plugin allows Jenkins jobs to be described by code (Groovy DSL). This code is then used for generating Jenkins jobs. As a consequence, job configuration can be part of the project's source code. During the generation step, existing jobs are synchronized, overwritten or left alone, depending on the configuration. The same configuration manages deleting or ignoring jobs that are not described in code anymore. Jobs can easily be restored in case of data loss and changed without clicking buttons for hours. The automation also makes it easy to seed large numbers of homogeneous components and builds on different branches.
+The plugin allows Jenkins jobs to be described by code (Groovy DSL). This code is then used for generating Jenkins jobs. As a consequence, job configuration can be part of the project's source code. During the generation step, existing jobs are synchronized, overwritten or left alone, depending on the configuration. The same configuration manages deleting or ignoring jobs that are not described in code anymore. Jobs can easily be restored in case of data loss and changed without clicking buttons for hours. The automation also makes it easy to seed large numbers of homogeneous components and builds on different branches.
 
-The ability to treat Jenkins jobs as code is a big advantage. We highly suggest that every team automate the setup of their jobs and their pipelines. Another way of expressing build pipelines as code is the new [Jenkins Pipeline](https://jenkins.io/doc/book/pipeline/) feature - but still we see the need of Job DSL seeder jobs to seed the Jenkins pipeline jobs themselves and any additional jobs.
+The ability to treat Jenkins jobs as code is a big advantage. We highly suggest that every team automate the setup of their jobs and their pipelines. Another way of expressing build pipelines as code is the new [Jenkins Pipeline](https://jenkins.io/doc/book/pipeline/) feature - but still we see the need of Job DSL seeder jobs to seed the Jenkins pipeline jobs themselves and any additional jobs.

radar/2017-03-01/keycloak.md

@@ -4,14 +4,14 @@ ring:       trial
 quadrant:   tools
 
 ---
-User management, authentication, authorization and Single Sign-On are part of most distributed systems nowadays. Building these sensitive and serious parts on your own might be a problem due to knowledge- and budget restrictions. Because of growing requirements in that field (social logins, single sign-on, federation, two-factor authentication, etc.), as well as growing security concerns, building these things on your own has become more challenging during the past decade.
+User management, authentication, authorization and Single Sign-On are part of most distributed systems nowadays. Building these sensitive and serious parts on your own might be a problem due to knowledge- and budget restrictions. Because of growing requirements in that field (social logins, single sign-on, federation, two-factor authentication, etc.), as well as growing security concerns, building these things on your own has become more challenging during the past decade.
 
-As a consequence, the recommendation is: use an existing solution and connect it with your project's codebase using provided standards. Our recommended solution is the Open Source project JBoss Keycloak. We use Keycloak in our OM3 suite for several authentication-related use cases - such as user management for system users and single sign-on for customers. The OAuth access tokens can be used to secure APIs that access sensitive information.
+As a consequence, the recommendation is: use an existing solution and connect it with your project's codebase using provided standards. Our recommended solution is the Open Source project JBoss Keycloak. We use Keycloak in our OM3 suite for several authentication-related use cases - such as user management for system users and single sign-on for customers. The OAuth access tokens can be used to secure APIs that access sensitive information.
 
-Keyloak is based on standards such as OAuth2, OIDC and SAML2. Securing a distributed system is supported by adapters, which are provided by the Keycloak developers for different technology stacks. If there is no adapter for your technology stack, an integration on protocol level with a library is simple. A lot of configurable features require no coding in the integrated projects.
+Keyloak is based on standards such as OAuth2, OIDC and SAML2. Securing a distributed system is supported by adapters, which are provided by the Keycloak developers for different technology stacks. If there is no adapter for your technology stack, an integration on protocol level with a library is simple. A lot of configurable features require no coding in the integrated projects.
 
-By design, the Keycloak project offers customizability and extensibility via so-called SPIs, e.g. a custom authenticator can be implemented to address project specific problems.
+By design, the Keycloak project offers customizability and extensibility via so-called SPIs, e.g. a custom authenticator can be implemented to address project specific problems.
 
-Keycloak normally runs standalone and can use various database products. A docker image is available to start in a containerized environment.
+Keycloak normally runs standalone and can use various database products. A docker image is available to start in a containerized environment.
 
-Keycloak might be overkill, depending on your project needs. For a simple integration with, for instance, a social login provider (Facebock, Twitter, etc.) Keycloak might be too much. For a JVM project, the pac4j library might be an alternative. If a cloud-based solution is preferred and data privacy concerns are not an issue, Auth0 might be the choice.
+Keycloak might be overkill, depending on your project needs. For a simple integration with, for instance, a social login provider (Facebock, Twitter, etc.) Keycloak might be too much. For a JVM project, the pac4j library might be an alternative. If a cloud-based solution is preferred and data privacy concerns are not an issue, Auth0 might be the choice.

radar/2017-03-01/kubernetes.md

@@ -7,4 +7,4 @@ quadrant:   platforms-and-aoe-services
 
 Kubernetes is a container orchestration platform, which supports many different infrastructure providers. It allows you to deploy containers and takes care of running, scaling or self-healing your applications based on configurations you provide. It's based on years of knowledge and experience Google gained by using containers.
 
-At AOE, we started Kubernetes in a test environment on bare metal to experiment with it. It's currently used for running AOE internal apps such as dashboards as well as running builds in containers. We also started to use it for upcoming projects to run and manage several services. There are Tools to automate the setup of kubernetes in AWS like [Cops](https://kubernetes.io/docs/getting-started-guides/kops/). Another helpful tool is [Minikube](https://github.com/kubernetes/minikube), which allows to test and run kubernetes locally.
+At AOE, we started Kubernetes in a test environment on bare metal to experiment with it. It's currently used for running AOE internal apps such as dashboards as well as running builds in containers. We also started to use it for upcoming projects to run and manage several services. There are Tools to automate the setup of kubernetes in AWS like [Cops](https://kubernetes.io/docs/getting-started-guides/kops/). Another helpful tool is [Minikube](https://github.com/kubernetes/minikube), which allows to test and run kubernetes locally.

radar/2017-03-01/neo4j.md

@@ -4,7 +4,7 @@ ring:       assess
 quadrant:   platforms-and-aoe-services
 
 ---
-Neo4j is one of the oldest Open Source Graph Databases. It's one of the rare NoSQL databases that is fully ACID-compliant. We see two main advantages of graph databases:
+Neo4j is one of the oldest Open Source Graph Databases. It's one of the rare NoSQL databases that is fully ACID-compliant. We see two main advantages of graph databases:
 
 * for a lot of domains there is a natural way of modeling this in a graph (the Neo4j website says "everything is a graph"),
 * and querying relations between nodes is very efficient in a graph database.
@@ -15,4 +15,4 @@ You can also choose to run it in a classic server mode, which then provides you
 
 The cypher query language which comes with Neo4j is a declarative graph query language that allows for expressive and efficient querying and updating of the graph.
 
-At AOE, we use Neo4j mostly for explorative, interactive work with weakly structured or highly connected data, also we are evaluating this for knowledge-based recommendations in our [Searchperience](http://www.searchperience.de/home.html) product.
+At AOE, we use Neo4j mostly for explorative, interactive work with weakly structured or highly connected data, also we are evaluating this for knowledge-based recommendations in our [Searchperience](http://www.searchperience.de/home.html) product.

radar/2017-03-01/npm.md

@@ -4,23 +4,23 @@ ring:       adopt
 quadrant:   tools
 
 ---
-[NPM](https://www.npmjs.com/) is one of, if not the most, popular package manager for JavaScript. Because of the big community, you can find nearly every dependency in npm.
+[NPM](https://www.npmjs.com/) is one of, if not the most, popular package manager for JavaScript. Because of the big community, you can find nearly every dependency in npm.
 
-Instead of other package managers such as [bower](/tools/bower.html), you have to write your packages as [modules](https://en.wikipedia.org/wiki/CommonJS). This unifies the way you have to use, test and, of course, understand dependencies.
+Instead of other package managers such as [bower](/tools/bower.html), you have to write your packages as [modules](https://en.wikipedia.org/wiki/CommonJS). This unifies the way you have to use, test and, of course, understand dependencies.
 
-NPM creates a tree for your dependencies and their nesting dependencies. Because of this, you don't need to handle version conflicts, since every dependency uses there own version of e.g. [webpack](/tools/webpack.html).
+NPM creates a tree for your dependencies and their nesting dependencies. Because of this, you don't need to handle version conflicts, since every dependency uses there own version of e.g. [webpack](/tools/webpack.html).
 
-With [shrinkwrap](https://docs.npmjs.com/cli/shrinkwrap) you have a robust tool to lock down and manage the versions of your dependencies - following the [Pin (external) dependencies](/methods-and-patterns/pin-external-dependencies.html) approach.
+With [shrinkwrap](https://docs.npmjs.com/cli/shrinkwrap) you have a robust tool to lock down and manage the versions of your dependencies - following the [Pin (external) dependencies](/methods-and-patterns/pin-external-dependencies.html) approach.
 
 For each package you have to classify your dependencies:
 
--   dependencies are needed for use without the need of pre compiling, e.g. [lodash](https://lodash.com/)
+-   dependencies are needed for use without the need of pre compiling, e.g. [lodash](https://lodash.com/)
--   devDependencies are needed for development only, e.g. testing frameworks or pre compiler e.g. [babel](/languages-and-frameworks/babel.html)
+-   devDependencies are needed for development only, e.g. testing frameworks or pre compiler e.g. [babel](/languages-and-frameworks/babel.html)
 -   peerDependencies you have to provide for using the package
 
-With [scripts](https://docs.npmjs.com/misc/scripts) you get support for the most common build lifecycle steps, e.g. build, start, test ...
+With [scripts](https://docs.npmjs.com/misc/scripts) you get support for the most common build lifecycle steps, e.g. build, start, test ...
 
 Other useful features:
 
--   mirror support for your own repository (e.g. [artifactory](/platforms-and-aoe-services/artifactory.html))
+-   mirror support for your own repository (e.g. [artifactory](/platforms-and-aoe-services/artifactory.html))
--   can be used for server and client JavaScript development (see [node.js](/languages-and-frameworks/node-js.html) )
+-   can be used for server and client JavaScript development (see [node.js](/languages-and-frameworks/node-js.html) )

radar/2017-03-01/oro-platform.md

@@ -5,12 +5,12 @@ quadrant:   tools
 
 ---
 
-OroPlatform is a framework built on Symfony 2 with the purpose of providing the features you need in every business application that is not your core business logic. Hence, it serves you with a basic application, providing login and complex security, menus and menu management, history, audit trails, settings management, etc. It comes complete with a design and many widgets to be utilized in own entities. Other Features of OroPlatform are, for example, a WebSocket server-driven user interface, queue-based task runners, REST Interface, as well as messaging- and workflow systems.
+OroPlatform is a framework built on Symfony 2 with the purpose of providing the features you need in every business application that is not your core business logic. Hence, it serves you with a basic application, providing login and complex security, menus and menu management, history, audit trails, settings management, etc. It comes complete with a design and many widgets to be utilized in own entities. Other Features of OroPlatform are, for example, a WebSocket server-driven user interface, queue-based task runners, REST Interface, as well as messaging- and workflow systems.
 
 One of the central features is that entities, which are to be managed within the system, can be set up completely by configuring them using the UI. This in itself implies that it puts another abstraction layer upon doctrine and symfony defaults.
 
-As with every framework or application, the general-purpose goals and abstraction comes with drawbacks: In fact, OroPlatform modifies and extends the common way of doing things in Symfony in several places, which makes the developer's life hard at times. Also, the UI and package managing are set in such a way that they are hard to extend or replace. The many additional abstraction layers can result in decreased performance.
+As with every framework or application, the general-purpose goals and abstraction comes with drawbacks: In fact, OroPlatform modifies and extends the common way of doing things in Symfony in several places, which makes the developer's life hard at times. Also, the UI and package managing are set in such a way that they are hard to extend or replace. The many additional abstraction layers can result in decreased performance.
 
-On the other hand, OroPlatform gives you a good headstart for prototyping and frees you from rebuilding common requirements - which makes it a relevant choice for business applications with the need to manage several entities in a backend. Also, projects such [Akeneo](/tools/akeneo.html) or OroCRM use OroPlatform with success.
+On the other hand, OroPlatform gives you a good headstart for prototyping and frees you from rebuilding common requirements - which makes it a relevant choice for business applications with the need to manage several entities in a backend. Also, projects such [Akeneo](/tools/akeneo.html) or OroCRM use OroPlatform with success.
 
-Since the project is still young, the future development and improvements need to be watched. We classified the Framework as ***Assess***.
+Since the project is still young, the future development and improvements need to be watched. We classified the Framework as ***Assess***.

radar/2017-03-01/phan.md

@@ -11,4 +11,4 @@ We expect at least the following benefits:
 -   Decreased bug density; possible bugs and issues are found early
 -   Safer code and higher code quality
 
-We think Phan can be used in the deployment pipeline or as commit hooks for PHP 7-based applications. For a full Feature list check [here](https://github.com/etsy/phan#features).
+We think Phan can be used in the deployment pipeline or as commit hooks for PHP 7-based applications. For a full Feature list check [here](https://github.com/etsy/phan#features).

radar/2017-03-01/rabbitmq.md

@@ -4,10 +4,10 @@ ring:       trial
 quadrant:   tools
 
 ---
-RabbitMQ is an Open Source message broker - implementing the Advanced Message Queuing Protocol (AMQP) protocol. It provides a reliable and scalable way to transport data between loosely coupled applications, using different EAI patterns such as the Publish & Subscriber pattern. AMQP supports direct and fan-out exchanges (broadcasts) as well as topics. Queuing mechanisms allow for robust architectures, mitigating the risks of application downtimes. Typically, a RabbitMQ server can easily buffer millions of messages. RabbitMQ supports JMS in addition to AMQP. It is not intended to use JMS for new systems, but it makes RabbitMQ useful for integrating legacy systems.
+RabbitMQ is an Open Source message broker - implementing the Advanced Message Queuing Protocol (AMQP) protocol. It provides a reliable and scalable way to transport data between loosely coupled applications, using different EAI patterns such as the Publish & Subscriber pattern. AMQP supports direct and fan-out exchanges (broadcasts) as well as topics. Queuing mechanisms allow for robust architectures, mitigating the risks of application downtimes. Typically, a RabbitMQ server can easily buffer millions of messages. RabbitMQ supports JMS in addition to AMQP. It is not intended to use JMS for new systems, but it makes RabbitMQ useful for integrating legacy systems.
 
-There are several alternative solutions to RabbitMQ, e. g. the free Apache ActiveMQ, which is integrated in [Anypoint platform](/tools/anypoint-platform.html). ActiveMQ implements a somewhat simpler routing concept than RabbitMQ, but offers more protocols. Commercial products in this area are offered by IBM (Websphere MQ), Fiorano and almost every vendor of ESB products.
+There are several alternative solutions to RabbitMQ, e. g. the free Apache ActiveMQ, which is integrated in [Anypoint platform](/tools/anypoint-platform.html). ActiveMQ implements a somewhat simpler routing concept than RabbitMQ, but offers more protocols. Commercial products in this area are offered by IBM (Websphere MQ), Fiorano and almost every vendor of ESB products.
 
-We use RabbitMQ internally for transferring messages safely in our logging ecosystem between [Logstash](/platforms-and-aoe-services/elk-stack.html) proxies and servers using direct and fan-out exchanges for delivering messages to appropriate destinations. RabbitMQ is also used to asynchronously trigger Jenkins jobs from our SCMs to mitigate heavy load on the SCMs, usually caused by Jenkins polls for SCM changes. Additionally, some critical events for monitoring are using RabbitMQ for guaranteed notification. 
+We use RabbitMQ internally for transferring messages safely in our logging ecosystem between [Logstash](/platforms-and-aoe-services/elk-stack.html) proxies and servers using direct and fan-out exchanges for delivering messages to appropriate destinations. RabbitMQ is also used to asynchronously trigger Jenkins jobs from our SCMs to mitigate heavy load on the SCMs, usually caused by Jenkins polls for SCM changes. Additionally, some critical events for monitoring are using RabbitMQ for guaranteed notification. 
 
-RabbitMQ is rated "Trial". It fits into our approach to build robust, [resilient systems](/methods-and-patterns/resilience-thinking.html) and use [asyncronous messages](/methods-and-patterns/decoupling-infrastructure-via-messaging.html) for loosely coupled communications between components. In practice, RabbitMQ proved to be stable and dealt well with service interruptions from failures and maintenance slots. A common pain point is RabbitMQ as a single point of failure disrupting the data flow in a system. This issue is currently approached by setting up a HA cluster for RabbitMQ. The outcome of this approach will clarify the extent of future usage of RabbitMQ in our systems.
+RabbitMQ is rated "Trial". It fits into our approach to build robust, [resilient systems](/methods-and-patterns/resilience-thinking.html) and use [asyncronous messages](/methods-and-patterns/decoupling-infrastructure-via-messaging.html) for loosely coupled communications between components. In practice, RabbitMQ proved to be stable and dealt well with service interruptions from failures and maintenance slots. A common pain point is RabbitMQ as a single point of failure disrupting the data flow in a system. This issue is currently approached by setting up a HA cluster for RabbitMQ. The outcome of this approach will clarify the extent of future usage of RabbitMQ in our systems.

radar/2017-03-01/raml.md

@@ -5,8 +5,8 @@ quadrant:   tools
 
 ---
 
-[RAML](http://raml.org/) (the RESTful API Modelling Language) is a YAML-based API specification language. It's now available in [version 1.0](https://github.com/raml-org/raml-spec/blob/master/versions/raml-10/raml-10.md#defining-types). The philosophy behind it is to [specify the API before implementation](/methods-and-patterns/api-first-design-approach.html).
+[RAML](http://raml.org/) (the RESTful API Modelling Language) is a YAML-based API specification language. It's now available in [version 1.0](https://github.com/raml-org/raml-spec/blob/master/versions/raml-10/raml-10.md#defining-types). The philosophy behind it is to [specify the API before implementation](/methods-and-patterns/api-first-design-approach.html).
 
-If you follow this philosophy, you can design your API and discuss it with your clients and team before implementing a single line of code. API consumers are able to implement against the API before it's really up and running. The [api-console](https://github.com/mulesoft/api-console) provides a beautiful online documentation with "try it" features for your raml definition.
+If you follow this philosophy, you can design your API and discuss it with your clients and team before implementing a single line of code. API consumers are able to implement against the API before it's really up and running. The [api-console](https://github.com/mulesoft/api-console) provides a beautiful online documentation with "try it" features for your raml definition.
 
-The RAML ecosystem provides a rich toolset for code generation (e.g. [online editor](http://rawgit.com/mulesoft/api-designer/master/dist/index.html#/?xDisableProxy=true);[ api-workbench](http://apiworkbench.com/)), automatically generated documentation, code generation (e.g. [go-raml](https://github.com/Jumpscale/go-raml)), mocking, testing and much more. We prefer RAML over Swagger because of this.
+The RAML ecosystem provides a rich toolset for code generation (e.g. [online editor](http://rawgit.com/mulesoft/api-designer/master/dist/index.html#/?xDisableProxy=true);[ api-workbench](http://apiworkbench.com/)), automatically generated documentation, code generation (e.g. [go-raml](https://github.com/Jumpscale/go-raml)), mocking, testing and much more. We prefer RAML over Swagger because of this.

radar/2017-03-01/rest-assured.md

@@ -5,8 +5,8 @@ quadrant:   tools
 
 ---
 
-**[REST-assured](https://github.com/rest-assured/rest-assured)** is a Java DSL for simplifying testing of REST-based services built on top of HTTP Builder. It supports the most important http request methods and can be used to validate and verify the response of these requests.
+**[REST-assured](https://github.com/rest-assured/rest-assured)** is a Java DSL for simplifying testing of REST-based services built on top of HTTP Builder. It supports the most important http request methods and can be used to validate and verify the response of these requests.
 
-At AOE, we use REST-assured with Spock to automate our API testing. We appreciate the easy-to-use DSL, which uses the Given-When-Then template (also known as Gherkin language). This template helps other project members to understand the code/test easily.
+At AOE, we use REST-assured with Spock to automate our API testing. We appreciate the easy-to-use DSL, which uses the Given-When-Then template (also known as Gherkin language). This template helps other project members to understand the code/test easily.
 
-Because of the seamless integration with Spock and our positive experience in one of our major projects, we classify REST-assured as *assess.*
+Because of the seamless integration with Spock and our positive experience in one of our major projects, we classify REST-assured as *assess.*

radar/2017-03-01/rxjava.md

@@ -5,4 +5,4 @@ quadrant:   tools
 
 ---
 
-[RxJava](https://github.com/ReactiveX/RxJava) is the Open Source Java implementation of ReactiveX. The main concept heavily relies on the Observer- (and Subscriber)-Pattern. An Observer emits a stream of data, which can be consumed by Subscribers. The Subscriber reacts (That's where the 'Rx' comes from) asynchronously to those data events. Reactive Extensions were originally developed by Mircosoft's Erik Meijer and his team and have been ported to all major programming languages after being released to the public as Open Source software. We use RxJava (but actually RxAndroid to be precise) in the Congstar Android App to let the UI layer react to changes in the underlaying data layer.
+[RxJava](https://github.com/ReactiveX/RxJava) is the Open Source Java implementation of ReactiveX. The main concept heavily relies on the Observer- (and Subscriber)-Pattern. An Observer emits a stream of data, which can be consumed by Subscribers. The Subscriber reacts (That's where the 'Rx' comes from) asynchronously to those data events. Reactive Extensions were originally developed by Mircosoft's Erik Meijer and his team and have been ported to all major programming languages after being released to the public as Open Source software. We use RxJava (but actually RxAndroid to be precise) in the Congstar Android App to let the UI layer react to changes in the underlaying data layer.

radar/2017-03-01/settings-injection.md

@@ -6,6 +6,6 @@ quadrant:   methods-and-patterns
 ---
 While deploying applications to an environment, the application typically needs to be configured for that specific environment. Typical settings include domain names, database credentials and the location of other dependent services such as cache backends, queues or session storages.
 
-These settings should not be shipped with the build package. Instead, it's the environment - this build is being deployed to - that should expose these values to application. A common way to "inject" these values is by making them available as environment variables or dynamically creating configuration files for the application. You can achieve this pattern without special tools - but this concept of settings injection also works with tools such as [Consul](/tools/consul.html), [kubernetes](/platforms-and-aoe-services/kubernetes.html) (with configMaps and secrets) or [YAD](https://github.com/AOEpeople/YAD).
+These settings should not be shipped with the build package. Instead, it's the environment - this build is being deployed to - that should expose these values to application. A common way to "inject" these values is by making them available as environment variables or dynamically creating configuration files for the application. You can achieve this pattern without special tools - but this concept of settings injection also works with tools such as [Consul](/tools/consul.html), [kubernetes](/platforms-and-aoe-services/kubernetes.html) (with configMaps and secrets) or [YAD](https://github.com/AOEpeople/YAD).
 
 In this manner, the build package can be independent from the environment it's being deployed to - making it easier to follow the "Build once, deploy often" CI/CD principle.

radar/2017-03-01/sparkpost.md

@@ -4,10 +4,10 @@ ring:       assess
 quadrant:   platforms-and-aoe-services
 
 ---
-Sparkpost is an SaaS service for E-Mail delivery and E-Mail templating that can be used to send E-Mails by calling an API.
+Sparkpost is an SaaS service for E-Mail delivery and E-Mail templating that can be used to send E-Mails by calling an API.
 
 In a lot of projects, it is a typical requirement that different E-Mails need to be sent and that the project stakeholders want to adjust E-Mail templates and content on a relatively regular basis.
 
-Also, (mass) sending E-Mails and avoiding that they are classified as Spam is not an easy topic. That's why we decided to use E-Mail delivery services in our projects and evaluated different providers.
+Also, (mass) sending E-Mails and avoiding that they are classified as Spam is not an easy topic. That's why we decided to use E-Mail delivery services in our projects and evaluated different providers.
 
-We decided to start using SparkPost because of pricing, feature set and the available reviews on the Internet. There are also other possible solutions such as SendGrid or Postmark.
+We decided to start using SparkPost because of pricing, feature set and the available reviews on the Internet. There are also other possible solutions such as SendGrid or Postmark.

radar/2017-03-01/spring-rest-docs.md

@@ -4,6 +4,6 @@ ring:       assess
 quadrant:   tools
 
 ---
-[Spring REST Docs](https://projects.spring.io/spring-restdocs/) auto generates [Asciidoctor](http://asciidoctor.org/) snippets with the help of [Spring MVC Test](http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle#spring-mvc-test-framework) or [RestAssured](https://extranet.aoe.com/confluence/pages/viewpage.action?pageId=86937862).  So you can be sure that your tests are inline with the documentation.
+[Spring REST Docs](https://projects.spring.io/spring-restdocs/) auto generates [Asciidoctor](http://asciidoctor.org/) snippets with the help of [Spring MVC Test](http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle#spring-mvc-test-framework) or [RestAssured](/tools/rest-assured.html).  So you can be sure that your tests are inline with the documentation.
 
-At AOE, we use [Spring REST Docs](https://projects.spring.io/spring-restdocs/) to document our Rest Services and Hal Resources. We also use it to auto generate [Wiremock](/tools/wiremock.html) Stubs, so the consumer of the service can test against the exact API of the service.
+At AOE, we use [Spring REST Docs](https://projects.spring.io/spring-restdocs/) to document our Rest Services and Hal Resources. We also use it to auto generate [Wiremock](/tools/wiremock.html) Stubs, so the consumer of the service can test against the exact API of the service.

radar/2017-03-01/styleguide-driven-development.md

@@ -10,4 +10,4 @@ In the old days, the frontend was developed based on page-centric Photoshop file
 You can start developing your UI components (HTML/CSS/JavaScript) very early in the production phase without having to wait for a ready-to-use development system.\
 Designers and Testers can give feedback early and you can share the documentation and code with external teams.
 
-At AOE, we use [Hologram](https://trulia.github.io/hologram/) to build a living documentation right from the source files. Whenever a new UI Element is needed, a developer starts building it in the styleguide -- not in the actual application code. By writing the code for the new component, the documentation for it is created instantly. Any other developer can easily see which elements exist and how it can be used in the code.
+At AOE, we use [Hologram](https://trulia.github.io/hologram/) to build a living documentation right from the source files. Whenever a new UI Element is needed, a developer starts building it in the styleguide -- not in the actual application code. By writing the code for the new component, the documentation for it is created instantly. Any other developer can easily see which elements exist and how it can be used in the code.

radar/2017-03-01/webpack.md

@@ -4,23 +4,23 @@ ring:       trial
 quadrant:   tools
 
 ---
-[Webpack](https://webpack.js.org/) is a web bundler for JavaScript applications. Instead of writing scripts to build and bundle your app like you would with [Gulp](/tools/gulp.html), you just define what files you want to load into your bundle.
+[Webpack](https://webpack.js.org/) is a web bundler for JavaScript applications. Instead of writing scripts to build and bundle your app like you would with [Gulp](/tools/gulp.html), you just define what files you want to load into your bundle.
 
-In the following example, we define that JavaScript files should be handled by babel-loader, excluding the files from node_modules. The logic behind the process comes from the [loader](https://webpack.js.org/concepts/loaders/). You can find the right loader in [npm](https://www.npmjs.com/search?q=loader%20webpack&page=1&ranking=optimal).
+In the following example, we define that JavaScript files should be handled by babel-loader, excluding the files from node_modules. The logic behind the process comes from the [loader](https://webpack.js.org/concepts/loaders/). You can find the right loader in [npm](https://www.npmjs.com/search?q=loader%20webpack&page=1&ranking=optimal).
 
 ```
 {
     test: /\.js$/,
-    loader: 'babel-loader',
+    loader: 'babel-loader',
     exclude: /node_modules/,
 }
 ```
 
-On top of that you can use [plugins](https://webpack.js.org/plugins/) to optimize your bundle like uglifying your code or put your common libraries in a separate file.
+On top of that you can use [plugins](https://webpack.js.org/plugins/) to optimize your bundle like uglifying your code or put your common libraries in a separate file.
 
 Under the hood, you've got nice features such as:
 
--   [tree shaking](https://webpack.js.org/guides/tree-shaking/) to just bundle the features from a library you need
+-   [tree shaking](https://webpack.js.org/guides/tree-shaking/) to just bundle the features from a library you need
--   [chunk splitting](https://webpack.js.org/guides/code-splitting/) to split your code to manage the load prioritization
+-   [chunk splitting](https://webpack.js.org/guides/code-splitting/) to split your code to manage the load prioritization
 
-The configuration is simple and there is excellent and extensive [documentation](https://webpack.js.org/configuration/).
+The configuration is simple and there is excellent and extensive [documentation](https://webpack.js.org/configuration/).

radar/2018-03-01/imgix.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "imgix"
+ring:       assess
+quadrant:   platforms-and-aoe-services
+featured:   false
 ---

radar/2018-03-01/maintain-third-party-packages.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Maintain third party packages"
+ring:       hold
+quadrant:   platforms-and-aoe-services
+featured:   false
 ---

radar/2018-03-01/micro-frontends.md

@@ -12,6 +12,6 @@ challenges. Integrating different Frontends on the client- or server-side can be
 User Experience consistent.
 
 Despite the challenges, Micro Frontends help us to develop large applications across multiple teams. Developers can
-work more independently without having too much trouble maintaining a large codebase. Being able to update oder 
+work more independently without having too much trouble maintaining a large codebase. Being able to update or 
 replace Frontend libraries in some parts of the application is yet another benefit in the fast-moving world of 
 frontend development.

radar/2018-03-01/neo4j.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Neo4j"
+ring:       assess
+quadrant:   platforms-and-aoe-services
+featured:   false
 ---

radar/2018-03-01/oro-platform.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Oro Platform"
+ring:       assess
+quadrant:   tools
+featured:   false
 ---

radar/2018-03-01/pair-working.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Pair working"
+ring:       trial
+quadrant:   methods-and-patterns
+featured:   false
 ---

radar/2018-03-01/phan.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "phan"
+ring:       assess
+quadrant:   tools
+featured:   false
 ---

radar/2018-03-01/php7-over-php5.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "PHP7 over PHP5"
+ring:       adopt
+quadrant:   languages-and-frameworks
+featured:   false
 ---

radar/2018-03-01/sparkpost.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "SparkPost"
+ring:       assess
+quadrant:   platforms-and-aoe-services
+featured:   false
 ---

radar/2018-03-01/typo3-as-a-framework.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "TYPO3 as a Framework"
+ring:       hold
+quadrant:   tools
+featured:   false
 ---

radar/2018-03-01/xataface.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Xataface"
+ring:       hold
+quadrant:   platforms-and-aoe-services
+featured:   false
 ---

radar/2019-11-01/ant.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Ant"
+ring:       hold
+quadrant:   tools
+featured:   false
 ---

radar/2019-11-01/hal-hateoas.md

@@ -1,5 +1,8 @@
 ---
-featured: false
+title:      "HAL / HATEOAS"
+ring:       trial
+quadrant:   methods-and-patterns
+featured:   false
 ---
 
 We use HAL in cases where we need to link ressources in payloads. HATEOAS has not proven to be very useful in our projects.

radar/2019-11-01/hystrix.md

@@ -1,5 +1,8 @@
 ---
-featured: false
+title:      "Hystrix"
+ring:       assess
+quadrant:   tools
+featured:   false
 ---
 
 Hystrix is not actively mainatined anymore and some of its goals can now be handled with service meshs.

radar/2019-11-01/job-dsl.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Job DSL (Jenkins)"
+ring:       trial
+quadrant:   tools
+featured:   false
 ---

radar/2019-11-01/npm.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "NPM"
+ring:       adopt
+quadrant:   tools
+featured:   false
 ---

radar/2019-11-01/play-framework.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Play Framework"
+ring:       adopt
+quadrant:   languages-and-frameworks
+featured:   false
 ---

radar/2019-11-01/protobuf.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Protobuf"
+ring:       assess
+quadrant:   languages-and-frameworks
+featured:   false
 ---

radar/2019-11-01/puppet-environments.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Puppet Environments"
+ring:       assess
+quadrant:   platforms-and-aoe-services
+featured:   false
 ---

radar/2019-11-01/styleguide-driven-development.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Styleguide Driven Development"
+ring:       adopt
+quadrant:   methods-and-patterns
+featured:   false
 ---

radar/2019-11-01/symfony-components.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Symfony Components"
+ring:       trial
+quadrant:   languages-and-frameworks
+featured:   false
 ---

radar/2019-11-01/xmlunit.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "XMLUnit"
+ring:       assess
+quadrant:   tools
+featured:   false
 ---

radar/2019-11-01/yarn.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Yarn"
+ring:       trial
+quadrant:   tools
+featured:   false
 ---

radar/2021-01-01/docker.md

@@ -0,0 +1,10 @@
+---
+title:      "Docker"
+ring:       assess
+quadrant:   platforms-and-aoe-services
+featured:   false
+---
+
+Docker is best known for its capability to build and run containers. This is how we have used the term "Docker" in the Tech Radar recently. But "Docker" is also a complete production platform, where the capability to build and run Containers is only a small fraction of its capabilities. At the same time numerous alternate runtimes for containers – like containerd and podman – as well as image builders – like Kaniko and Buildah – have evolved during the last years. Thanks to the standards established by the Open Container Initiative these tools are mostly interchangeable for the purposes of building and running containers.
+
+To be more distinct, we now recommend using [Containers and Runtimes as specified by the Open Container Initiative](/platforms-and-aoe-services/oci-container.html). "Docker" is one of many tools to achieve that.

radar/2021-01-01/elk-stack.md

@@ -0,0 +1,6 @@
+---
+title:      "ELK Stack"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+featured:   false
+---

radar/2021-01-01/flutter.md

@@ -0,0 +1,18 @@
+---
+title:      "Flutter"
+ring:       assess
+quadrant:   languages-and-frameworks
+
+---
+
+[Flutter](https://flutter.io) allows writing native applications for different platforms with a single code base in [Dart](https://dart.dev).
+
+It provides stable platform implementations for both major mobile platforms iOS and Android.
+With [Flutter on the Web](https://flutter.dev/web) it is possible to build single-page applications (SPA) out of the same code with full support for service workers.
+The [Desktop](https://flutter.dev/desktop) (Windows, Mac, Linux) platform is currently still in beta (as of mid 2021).
+
+The compilation into native platform code prevents from bottleneck-issues due context switching and runtime bridging, which can be found in other cross-platform frameworks like [React Native](https://reactnative.dev).
+
+Comparing to a Javascript-based PWA, Flutter's approach promises a better performance and energy-efficiency.
+
+We gathered first positive experience with small applications, which used the Alpha and Beta state of Flutter for Linux (x64) and Web by the time of development.

radar/2021-01-01/micro-frontends.md

@@ -0,0 +1,9 @@
+---
+title:      "Micro Frontends"
+ring:       adopt
+quadrant:   methods-and-patterns
+---
+
+The Micro Frontends approach continues to prove to be a valuable pattern for large-scale systems developed by several teams. Therefore, we moved this pattern to "adopt".
+
+We use [page composing](methods-and-patterns/page-composing.html) as one implementation of this pattern.

radar/2021-01-01/next-js.md

@@ -1,3 +1,5 @@
 ---
-ring: adopt
+title:      "Next.js"
+ring:       adopt
+quadrant:   languages-and-frameworks
 ---

radar/2021-01-01/node-js.md

@@ -1,3 +1,5 @@
 ---
-ring: adopt
+title:      "node.js"
+ring:       adopt
+quadrant:   languages-and-frameworks
 ---

radar/2021-01-01/oci-container.md

@@ -0,0 +1,18 @@
+---
+title:      "OCI Container"
+ring:       adopt
+quadrant:   platforms-and-aoe-services
+
+---
+
+OCI-compatible containers are currently the most-used solution for creating and managing container-based infrastructures and deployments.
+
+Containers and their runtime are an easy way to run applications and serivces as an isolated process (using Linux kernel cgroups, network namespaces and custom mounts).
+
+In a DevOps environment, this helps a lot as we can run the exact same software and runtime (such as NodeJS) on both production and locally while developing. This enables us to debug our software much easier. We can compose our project development setup out of small containers. Also, containers allow us to keep our development environment much simpler and independent of our developer's operating system or pre-installed software versions.
+
+In a CI environment building the containers allows us to package and test the whole environment instead of different software components on different runtimes in a much more stable way.
+
+Backed by services such as [Kubernetes](/platforms-and-aoe-services/kubernetes.html) and [Helm](/platforms-and-aoe-services/helm.html), we can deploy containers on a flexible infrastructure and enable our developers to test their software more easily in different environments.
+
+Here at AOE, we use containers in different projects to become more flexible and faster, which increases our focus on development of even better and more stable software.

radar/2021-01-01/open-policy-agent.md

@@ -0,0 +1,16 @@
+---
+title:      "Open Policy Agent"
+ring:       assess
+quadrant:   tools
+
+---
+
+[Open Policy Agent](https://www.openpolicyagent.org/) (OPA) is a framework which allows to model and evaluate policy access services. The underlying expression language *Rego* is purpose-built for the policy evaluations and implements the **Policy As Code** pattern. 
+
+This allows to decouple policy from the service's code so you can release, and review policies seperatly.
+
+The benefits of using OPA and Rego comes from the various available integrations into other cloud-native services and tools. It can be used with the "Kubernetes Admission Controller", to authorize decisions within a Service Mesh or as part of infrastructure evaluation pipelines. 
+
+We use OPA in some of our infrastructure pipelines to ensure that changes don't have undesired impact or within Kubernetes to evaluate the overall conformity of our deployments with the given policies.
+
+We have also evaluated OPA as part of permission management in distributed architectures. The concept promisses to provide value especially for distributed enterprise architectures.

radar/2021-01-01/page-composing.md

@@ -0,0 +1,13 @@
+---
+title:      "Page Composing"
+ring:       trial
+quadrant:   methods-and-patterns
+---
+
+Page composing is a way to aggregate multiple independent page fragments into one combined web page. As an implementation of [Micro Frontends](methods-and-patterns/micro-frontends.html), this approach supports to deploy and run services agnostic to the technologies used per team.
+
+The concept builds upon the fact that all involved services deliver valid HTML as their output. Our solution is a small application which takes care of gathering the page fragments from all services and composing each into a defined HTML template. A configuration layer further allows to control which fragment gets pulled from the serving instance.
+
+With such a page composing application in place, teams can autonomously develop, deploy and operate their service with the freedom of choosing technologies and release strategies.
+
+Martin Fowler et al. described this as [Server-side template composition](https://martinfowler.com/articles/micro-frontends.html#Server-sideTemplateComposition).

radar/2021-01-01/pin-external-dependencies.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Pin external dependencies"
+ring:       adopt
+quadrant:   methods-and-patterns
+featured:   false
 ---

radar/2021-01-01/redux.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Redux"
+ring:       trial
+quadrant:   languages-and-frameworks
+featured:   false
 ---

radar/2021-01-01/semver2.md

@@ -0,0 +1,11 @@
+---
+title:      "Semantic Versioning 2.0"
+ring:       adopt
+quadrant:   methods-and-patterns
+featured:   false
+---
+
+[Semantic Versioning 2.0](https://semver.org/spec/v2.0.0.html) is a scheme for specifying a software's version.
+As the de facto standard, this is widely used and established in all areas of software development. It offers a clear way of communicating changes over the lifetime of the software being developed.
+
+Especially in large-scale projects with many components being dependent on each other, it is important to use unambiguous communication across teams.

radar/2021-01-01/settings-injection.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Settings Injection"
+ring:       adopt
+quadrant:   methods-and-patterns
+featured:   false
 ---

radar/2021-01-01/tailwindcss.md

@@ -0,0 +1,23 @@
+---
+title:      "Tailwind CSS"
+ring:       trial
+quadrant:   languages-and-frameworks
+
+---
+Tailwind CSS is a framework that heavily utilizes CSS classes.
+What seems to be a very different approach in the beginning, turns into a big "ah-ha-moment" during development and even more during the build step.
+CSS classes are entirely generated based on a configuration file that outlines the entire design system including states, nuances, etc.
+Tailwind's high flexibility results in a set of CSS classes aligned with UX/design, requiring just a fraction of code compared to a self-built solution.
+Colours, sizes, spaces etc. can have meaningful names that are easy to remember and shared between developers and designers.
+In turn, this results in a shared language with less explanation required.
+Support for deep integration into the development and build processes ensure optimized build times with incremental rebuilds only on parts really necessary.
+This obviously leads to very small build sizes with nearly 100% CSS coverage.
+
+The deep integration and the extraordinary small build sizes were the main aspects for us to choose Tailwind CSS for resource-limited projects in the field of industry 4.0.
+These projects have a huge demand on a variety of interaction forms.
+
+Tailwind helps us to fulfil modern user expectations by reducing the complexity of sophisticated industrial processes with a multi-device approach.
+
+This is an unspoken expectation of today's operators of industrial processes. The evolution from classic
+cellular phones towards smartphones showed, there is still a huge untapped potential for usability improvements and
+adaptive processes, that reduce complexity especially the industry 4.0 field.

radar/2021-01-01/vuex.md

@@ -1,3 +1,6 @@
 ---
-featured: false
+title:      "Vuex"
+ring:       assess
+quadrant:   languages-and-frameworks
+featured:   false
 ---