DCX Technology Radar
Technology RadarDCX Technology RadarDCX Technology RadarTechnology RadarDCX Technology RadarAdobe Creative Cloud transcends traditional design boundaries by providing a comprehensive platform that fosters seamless collaboration and streamlines the design process. We use applications such as Adobe XD, Photoshop, Illustrator, InDesign, and more, each of which serves a unique purpose in the design workflow, including photo and video editing. The integration of these specialized tools allows us to work efficiently and effectively, thus maximizing our productivity.
\\n","featured":true,"flag":"new","tags":["ux/ui"],"position":[445,508]},{"id":"adr","release":"2021-07-01","title":"ADR","ring":"adopt","quadrant":"methods-and-patterns","body":"ADRs have proven to be a useful tool for documentation and are commonly used in \\nour organisation. We therefore promote it to the "adopt" ring.
\\n","featured":true,"flag":"default","tags":["architecture","documentation"],"revisions":[{"release":"2018-03-01","ring":"assess","body":"Architecture Decision Records
\\nADR is a lightweight documentation of important architecture decisions taken by the team.\\nWithout documentation of the architecture and the architecture decisions, new team members can only do two things:
\\nIt goes without saying that both options aren't right.
\\nTherefore, we suggest documenting the important architecture decisions. We use a simple tool such as https://github.com/npryce/adr-tools and store them in version control.\\nIn larger projects with many teams we also establish a regular "architecture board / COI" with regular meetings.\\nOften, the architecture decisions are taken in such meetings.
\\nThe main purpose of this documentation is to:
\\nIn recent years, the field of Artificial Intelligence (AI) has made monumental strides, and AI has demonstrated its ability to augment human capabilities and enhance user experiences. One noteworthy facet of this evolution is Assisted AI—a paradigm that holds great promise for software development companies.
\\nAssisted AI combines human and machine intelligence to enhance productivity. It leverages AI's computational capabilities while preserving human critical thinking.
\\nDevelopers should consider using generative artificial intelligence (AI) for a multitude of reasons:
\\nEthical, privacy, and bias concerns need careful attention, especially data protection concerns while working with cloud-based solutions, which are important to consider.
\\nAssisted AI is a pivotal development. Embracing this shift promises improved efficiency and better products.
\\nWe are currently establishing the following aspects:
\\nWe continue to use Akeneo with a variety of customers to store and process product data in a standardized format. It is the de facto standard for open source PIM's and therefore an integral part of our e-commerce solutions.
\\nIn the meantime, Akeneo has been continuously developed and offers many new features that further facilitate product data collection.
\\nThe recent switch to Elasticsearch and an update of Symfony improved runtime behaviour as well as scalability for future-prove use. Support for the latest release of PHP 8 is upcoming.
\\n","featured":false,"flag":"default","revisions":[{"release":"2019-11-01","ring":"assess","body":""},{"release":"2017-03-01","ring":"assess","body":"Akeneo is a Product Information Management system (also known as PIM, PCM or Product MDM) and helps centralize and harmonize all the technical and marketing information of products.
\\nWe use Akeneo with success in our projects and products (For example in OM3), where it is responsible for:
\\nThe system has a modern and friendly user interface and product managers find things such as completeness check, translation views and mass editing very helpful.
\\nWith delta export and import capabilities and the usage of Mongo DB as persistence backend, the performance is acceptable. We miss a richer API - but the system is extendable and based on PHP/Symfony 2.
\\n"}],"position":[470,517]},{"id":"akka","release":"2023-11-01","title":"Akka","ring":"hold","quadrant":"languages-and-frameworks","body":"With the growing adoption of microservice-based architectures, the interest in frameworks and tools that make building systems that follow the reactive manifesto possible has increased.
\\nAkka provides you a toolkit and runtime based on the Actor model known from Erlang to reach this goal.
\\nIt's one of the most-adopted toolkits in its space with its key contributors being heavily involved in the overall movement of the reactive community as well.\\nAt AOE, we use Akka when we need high-performance, efficient data processing or where its finite state machine plays nicely with the domain of the application. It is worth mentioning that the actor model might come with extra complexity and therefore should be used in problem spaces where the advantages of this approach bring enough value and no accidental complexity.
\\n","featured":true,"flag":"changed","tags":["coding"],"revisions":[{"release":"2017-03-01","ring":"trial","body":"With the growing adoption of microservice-based architectures, the interest in frameworks and tools that make building systems that follow the reactive manifesto possible has increased.
\\nAkka provides you a toolkit and runtime based on the Actor model known from Erlang to reach this goal.
\\nIt's one of the most-adopted toolkits in its space with its key contributors being heavily involved in the overall movement of the reactive community as well.\\nAt AOE, we use Akka when we need high-performance, efficient data processing or where its finite state machine plays nicely with the domain of the application. It is worth mentioning that the actor model might come with extra complexity and therefore should be used in problem spaces where the advantages of this approach bring enough value and no accidental complexity.
\\n"}],"position":[97,178]},{"id":"akka-streams","release":"2019-11-01","title":"Akka Streams","ring":"adopt","quadrant":"languages-and-frameworks","body":"Updated to "adopt"
\\n","featured":false,"flag":"default","revisions":[{"release":"2018-03-01","ring":"assess","body":"In our backend services, we frequently encounter the task to transform data coming from and uploading to external sources and services.
\\nBuilding more complex data transformation processes with Akka Actors has proven very difficult for us in the past.
\\nSeeing this data as a stream of elements could allow handling them piece by piece and only keeping as much of the data in-process as can currently be handled.
\\nAkka Streams is a Reactive Streams implementation that provides a very end-user friendly API for setting up streams for data processing that are bounded in resource usage and efficient. \\nIt uses the Akka Actor Framework to execute these streams in an asynchronous and parallel fashion exploiting today's multi-core architectures without having the user to interact with Actors directly. \\nIt handles things such as message resending in failure cases and preventing message overflow. It is also interoperable with other Reactive Streams implementations.
\\nOur first trials with Akka Streams were promising but we haven't yet implemented complex services with it.
\\nWe will continue looking into it together with the Alpakka Connectors for integration\\nwork.
\\n"}],"position":[252,321]},{"id":"alpakka","release":"2023-11-01","title":"Alpakka","ring":"adopt","quadrant":"languages-and-frameworks","body":"Updated to "adopt"
\\n","featured":false,"flag":"changed","tags":["coding"],"revisions":[{"release":"2018-03-01","ring":"assess","body":"When using Akka Streams to build reactive data transformation services you usually need to connect to several services such as FTP, S3 buckets, AMQP brokers or different databases.
\\nAlpakka provides integration building blocks for Akka Streams to access these services in a reactive fashion and contains transformations for working with XML, CSV or JSON structured data.
\\nCombined, Akka Streams and Alpakka enable us to build small reactive integration services with minimal resource consumption and good performance, and are a good alternative to larger ESB solutions or integration tools.
\\n"}],"position":[308,346]},{"id":"angular","release":"2023-11-01","title":"Angular","ring":"adopt","quadrant":"languages-and-frameworks","body":"Angular, now in version 15, remains a robust and well-maintained front-end framework that continues to build new features on its solid foundation. Angular offers excellent tools for building large-scale applications.
\\nFor instance, it includes built-in capabilities for setting up and managing a monorepo, simplifying the sharing of components across multiple projects. As a framework, Angular takes an opinionated approach to solving various problems, reducing the need for extensive decision-making while maintaining consistency, yet still providing flexibility where necessary. Angular 15 further stabilizes standalone components, a feature introduced in Angular 14, with the aim of simplifying Angular applications and reducing module complexity, addressing a common criticism of Angular.
\\nThe ease of upgrading to new versions has improved significantly due to the framework's stability and the detailed migration guides provided by the maintainers.
\\n","featured":true,"flag":"changed","tags":["coding","frontend"],"revisions":[{"release":"2021-07-01","ring":"adopt","body":"Actually in version 11 Angular has become an adult SPA framework with much faster build time and significant smaller production builds.\\nUpdating to newer versions has become mostly a "no-brainer" which helps us to integrate the latest community bug-fix & improvements on a friday during a cup of coffee.\\nAngular ships as a fully integrated development platform from scaffolding, code generation, routing, guarding, unit/e2e-testing, multi-language builds (i18n) and stable dev/build processes and keeping it extensible at the same time.\\nThis holistic nature of Angular makes it in the beginning way more difficult to learn but once understood it's a great candidate to go very fast into "requirement implementation" aka providing early value rather than library wiring.\\nBeside the existing telco-industry projects we've actually also chosen Angular for resource critical industry 4.0 / embedded projects.\\nHere we've selected Angular beside the performance aspects to fulfill requirements like adaptive multi device support (custom hardware buttons, tablets and laptops) on the one hand and on the other hand to reduce the risk loosing time by having too many self-managed external dependencies.
\\n"},{"release":"2018-03-01","ring":"trial","body":"In addition to numerous major upgrades from version 2 to 5, which often needed a "hands-on" approach, a lot has happened in the Angular ecosystem in 2017. \\nSpecifically, the improvements in the HTTP-Client, which now requires less coding effort. \\nOr the vast improvements on angular.cli such as aot (ahead of time compile) for faster rendering, fewer requests and much smaller builds, to just name the most important ones.
\\nWe have achieved particularly good results using Angular in large and medium-size projects. \\nActually, it's our framework-of-choice in our telecommunication sector teams as a single-page application framework (SPA) for microservice front ends.
\\nThe convenient scaffolding of unit- and end-to-end-tests provides a quality-driven workflow. \\nAlso, the module- and component architecture helps to keep the codebase understandable end maintainable.
\\n"},{"release":"2017-03-01","ring":"assess","body":"The latest version of the Angular Framework, which is used for large single-page applications.
\\nAngular is a complete rewrite of Angular 1 — many things have changed compared to the first version. The latest best practices and toolings from the JavaScript community have found their way into Angular.
\\nIt supports DI (dependency injection), it has a clean inheritance and a good separation of concerns. Angular follows the web component standards to avoid negative side effects between components.
\\nWe think that Angular is well-structured on both a development and an application level.
\\nWhen talking about Angular, we must consider the angular.cli as well, which provides a huge level of intelligent automation along the development process and project setup.
\\n"}],"position":[381,351]},{"id":"ant","release":"2019-11-01","title":"Ant","ring":"hold","quadrant":"tools","body":"Apache Ant was build in 1997 to have something like Make in the C/C++ world for Java.\\nAnt uses xml files to describe steps required to produce executable artifacts from source code.\\nThe main concepts of tasks and targets are programmable in an imperative style.
\\nApache Ant was and is widely used by large software projects.\\nOur recommendation is to stop using Apache Ant for new projects.\\nIf you are free to choose, we recommend Gradle as an Apache Ant replacement.
\\n","featured":false,"flag":"default","position":[762,465]},{"id":"anypoint-platform","release":"2019-11-01","title":"Anypoint Platform","ring":"trial","quadrant":"tools","body":"Recently our teams migrated some project from Anypoint to "Apache Camel" or use "Alpakka" for integration work.
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"Anypoint platform (formerly known as Mule or Mule ESB) is an Enterprise Integration Platform written in Java.
\\nAnypoint provides 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.
\\nAnypoint Community Version is Open Source and contribution is possible.\\nThe platform is pluggable with own connectors.\\nMulesoft is also driving the RAML specification and related Open Source tools.
\\nAOE is a Mulesoft Partner and we use both the Community and Enterprise Versions of Anypoint.\\nWe use Anypoint as an API Gateway to combine and transform data from multiple backends.\\nWe use it as ESB or Integration platform for loose coupling of software components.\\nWe also use it as legacy modernization to provide modern APIs for legacy or external software.
\\n"}],"position":[446,622]},{"id":"apisix","release":"2023-02-23","title":"Apache APISIX","ring":"assess","quadrant":"tools","body":"Apache APISIX is an open-source, high-performance API gateway, designed for\\nmicroservices, cloud-native and container-based architecture. It provides a wide range of features to manage\\nand secure API services:
\\nAt AOE, we are currently assessing Apache APISIX in one of our cloud infrastructure projects.
\\n","featured":true,"flag":"default","tags":["devops"],"position":[545,690]},{"id":"apache-camel","release":"2019-11-01","title":"Apache Camel","ring":"trial","quadrant":"languages-and-frameworks","body":""Camel" is an open source integration framework that empowers you to quickly and easily integrate various systems consuming or producing data.
\\nOur teams are using Apache Camel as API Gateway that offers APIs and takes care of Federation to various Backends as well as Authorisation tasks.
\\n","featured":false,"flag":"default","position":[354,155]},{"id":"api-first-design-approach","release":"2022-03-28","title":"API-First Design Approach","ring":"adopt","quadrant":"methods-and-patterns","body":"The API of any software we develop shapes in which way developers, teams, customers and users interact with our\\nsoftware.
\\nNo matter if a Frontend-API like GraphQL, a rpc-API like gRPC or an internal API published by a module in a larger\\nproject or shared library, messing the API up always creates headaches and is hard to correct.\\nIf we stick to semantic versioning, it's actually pretty impossible to change a once-published API without breaking\\nconsumers.
\\nBy today's standards we prioritize API design before actual development, to be clear on how our software interacts, and\\nthus move this pattern to "adopt".
\\n","featured":true,"flag":"default","tags":["architecture"],"revisions":[{"release":"2017-03-01","ring":"trial","body":"The API-First Design Approach puts the API design at the beginning of the implementation without any constraints, for example, from the current IT infrastructure or the implementation itself.\\nThe idea is to design the API in a way that it serves its purpose best and the consumers are enabled to work efficiently.
\\nThere are several advantages to this approach. For example, it can help to avoid reflecting the internal structure of the application or any internal constraints.\\nFurthermore, as one of the most important design aspects is consistency, one can define features such as the behavior of security, URL schemes, and API keys upfront.\\nIt also helps speed up parallel implementation.\\nA team that consumes the API can start working directly after the API design because it can easily be mocked.
\\nThere are several tools for modelling an API, but here at AOE we mainly use RAML as it provides a rich set of tools for generating documentation, mocking and more.\\nFor mocking we use WireMock, for example.
\\nRelated to the "API-First" approach is the "Headless" approach where an existing application (with or without existing API) is used as a backend for a separate frontend.\\nWe used this with sucess for Magento-based E-Commerce platforms.\\nThis allows encapsulating the core features of that application, while integrating it into a larger landscape of components using its API as a unified way to interact between components.\\nDecoupling the core logic from its presentation layer allows picking the best technology stack for the various parts independently.
\\nFor further reading see:
\\n\\n"}],"position":[469,352]},{"id":"apicurio","release":"2021-07-01","title":"Apicurio Studio","ring":"trial","quadrant":"tools","body":"Apicurio Studio is a browser-based, open-source API design studio. It can be used to create or modify APIs using the OpenAPI specification. The visual editor supports collaborative development and allows to easily define example responses matching incoming requests.
\\nAt AOE, we use Apicurio Studio in conjunction with Microcks as part of our API-first development approach. While specifying an API, a corresponding mock server can be set up with a single mouse click. The frontend and backend parts of an application can then be developed independently by using the mock server and the API specification generated by Apicurio Studio.
\\n","featured":true,"flag":"default","tags":["architecture"],"position":[624,491]},{"id":"apollo-client","release":"2023-02-23","title":"Apollo Client","ring":"trial","quadrant":"tools","body":"The Apollo Client is a tool to efficiently work together with an GraphQL server. \\nIt makes it easy to run your queries and mutations, cache results, brings tooling to download schemas and generate types to name a few of the useful features.
\\n","featured":false,"flag":"default","tags":["architecture"],"position":[504,627]},{"id":"apm","release":"2021-07-01","title":"Application Performance Management","ring":"adopt","quadrant":"methods-and-patterns","body":"Application performance management (APM) enables to predict and prevent performance issues before they impact your users or your business.\\nAPM solutions help organizations to ensure that applications meet performance, availability and user experience expectations.\\nThis can be achieved by measuring application performance, providing visibility into performance issues, alerting developers and administrators when performance problems appear, and allow analysing how reliable an improvement is compared to a previous state.\\nIn the last years APM solutions are evolving from application performance monitoring tools to more feature full systems that incorporating observability, performance data collection and analysis, which is more to date with distributed cloud-native applications.
\\nOur experience with APM relates to the instrumentation of applications. This includes exposing metrics, tracing and integration with external services such as New Relic. We decided to go for this approach given the simplicity and the benefits they proved on a daily basis when analyzing and optimizing our software.
\\n","featured":true,"flag":"default","tags":["devops"],"position":[426,367]},{"id":"argocd","release":"2022-03-28","title":"Argo CD","ring":"trial","quadrant":"tools","body":"We've been managing the state of application deployments in YAML files via Git repositories in the past. But we still\\nwouldn't call this GitOps. A lot of custom glue code and tools were involved.\\nWhile helmfile replaces some of our custom tooling in a nice way we've also been\\ntrying a new approach with Argo CD.
\\nArgo CD watches Git repositories continuously and makes sure the state defined there is applied to the Kubernetes\\ncluster. It introduces a couple of CRDs including one representing a Helm deployment. Using\\nan "app of apps"\\npattern you can bundle multiple apps together and use existing Git workflows (branching, tagging, PR) to manage releases\\nto your various stages.
\\nAlso, the fact the Argo CD only needs read-only access to the Git repositories makes it a lot cleaner from a security\\npoint of view since no credentials to any clusters need to be buried in any CI/CD pipelines anymore.
\\nAdditionally, Argo CD comes with a nice web frontend that gives a lot of insight into what has been deployed and where\\nproblems might exist. For many developers this view on the cluster (with focus on their apps) might be the first go-to\\nfor checking their apps and troubleshooting issues making other tools like Lens or access via kubectl obsolete.
\\n","featured":true,"flag":"default","tags":["ci/cd"],"position":[633,448]},{"id":"asciidoc","release":"2019-11-01","title":"AsciiDoc","ring":"assess","quadrant":"tools","body":"AsciiDoc is a lightweight markup language such as Markdown. \\nWith a concise Syntax, it supports more features than Markdown without extensions such as Tables and Table of Contents.\\nIt's easy to write complex documentation with AsciiDoc. And with Asciidoctor you can export your text to Pdf, HTML, etc.
\\nAt AOE, we use AsciiDoc for Documentation in our Repositories.
\\n","featured":false,"flag":"default","position":[514,676]},{"id":"axure","release":"2023-11-01","title":"Axure","ring":"trial","quadrant":"tools","body":"Axure is a tool that enables the creation of flowcharts, wireframes, mockups, user journeys and more.\\nThrough features such as conditional logic, dynamic content and animations it is possible to create highly functional and rich UI prototypes, which convey a realistic look and feel as to how the application to be developed should behave and look.
\\nWe at AOE have used Axure successfully in several projects and it helped us a lot, particularly:
\\nIn conclusion, Axure is a great tool that provides all stakeholders with a common understanding and helped us a lot to specify requirements and find their implications.
\\n","featured":false,"flag":"changed","tags":["ux/ui"],"position":[613,535]},{"id":"babel","release":"2022-03-28","title":"Babel","ring":"adopt","quadrant":"languages-and-frameworks","body":"We have been using babel for some time now. Since we have started using it, we don't have to struggle with unimplemented features of ECMAScript. \\nIn this regard, JavaScript is JavaScript, no matter what browser you are using. We strongly recommend using Babel or similar solutions (e.g. TypeScript).
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"Babel gives you the possibility to use the latest features from JavaScript (ECMAScript) in the browser of your choice.
\\nWithout Babel you had to use the feature set of your oldest browser or use feature detections such as modernizr or write polyfills on your own.
\\nIn general, Babel is split in 2 ways to bring you the new goodies you want.
\\nNew syntax will be compiled to old EcmaScript 5 code e.g.:
\\nNew globals and functions are provided by babel-polyfill e.g.:
\\nThe configuration is really simple due to the plugin system. You can choose which ECMAScript version and stage presets you want to use.
\\nTo know what you need you can practice ECMAScript 6 by doing it with es6katas and ask caniuse.
\\nIf you are using TypeScript, Babel is not necessary since you already get the new features with TypeScript.
\\n"}],"position":[311,304]},{"id":"backstage","release":"2022-03-28","title":"backstage","ring":"assess","quadrant":"tools","body":"We see a lot of clustering in teams, microservices, libraries, and so on. We think a centralized software catalog\\nlike Backstage can help use to get a clearer view of our stack and the dependencies of a\\nplatform.\\nIt also helps to get the information and documentation you need as a developer more quickly.
\\nBackstage is an open-source developer portal platform created by Spotify. There is a very active community around it\\nwith already a lot of plugins for integrations with other tools, ci, monitoring and so on.
\\nAt AOE we assess backstage in a big project with a subset of features.
\\n","featured":true,"flag":"default","tags":["documentation","agile"],"position":[591,646]},{"id":"blameless-post-mortems","release":"2023-11-01","title":"Blameless Post Mortems","ring":"adopt","quadrant":"methods-and-patterns","body":"\\n\\nFailure and invention are inseparable twins.
\\n— Jeff Bezos
\\n
Blameless Post Mortems provide a concept for dealing with failures that inevitably occur when developing and operating complex software solutions. After any major incident or outage, the team gathers to perform an in-depth analysis of what happened and what can be done to mitigate the risk of similar issues in the future.
\\nBased on trust and the assumption that everyone involved had good intentions to do the best possible job given the information at hand, Blameless Post Mortems offer an opportunity to continuously improve the quality of software and infrastructure and the processes for dealing with critical situations. We consider this a fundamental principle that enables our staff to address deficiencies without fear of repercussions and reduces the probability of incidents being concealed.
\\nThe post-mortem documentation usually includes a timeline of the events leading to an incident and the steps taken for its remediation, as well as future actions and lessons learned to enhance the resilience and stability of our services.
\\nAt AOE, we make it a priority to conduct a Blameless Post Mortem meeting after every user-visible incident.
\\n","featured":false,"flag":"changed","tags":["devops","documentation"],"revisions":[{"release":"2019-11-01","ring":"assess","body":""},{"release":"2018-03-01","ring":"trial","body":"\\n\\nFailure and invention are inseparable twins.
\\n— Jeff Bezos
\\n
Blameless Post Mortems provide a concept of dealing with failures that inevitably occur when developing and operating complex software solutions. After any major incident or outage, the team gets together to perform an in-depth analysis of what happened and what can be done to mitigate the risk of similar issues happening in the future.
\\nBased on trust, and under the assumption that every person involved had good intentions to do the best-possible job given the information at hand, Blameless Post Mortems provide an opportunity to continuously improve the quality of software and infrastructure and the processes to deal with critical situations.
\\nThe post mortem documentation usually consists of both a timeline of the events leading to an incident and the steps taken to its remediation, as well as future actions and learnings for increasing resilience and stability of our services.
\\nAt AOE, we strive to conduct a Blameless Post Mortem meeting after every user-visible incident.
\\n"}],"position":[424,293]},{"id":"bower","release":"2019-11-01","title":"Bower","ring":"hold","quadrant":"tools","body":"Bower is a package manager for frontend resources such as JavaScript libraries and CSS frameworks. Compared to npm, it has a somewhat different approach to loading and resolving the packages, resulting in a smaller and cleaner folder structure.
\\nIn 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.\\nAs most of the frontend libraries are also available through npm, it's not surprising that we ask ourselves why Bower is still needed.
\\nAt AOE, we decided to use npm as the only package manager to avoid having multiple tools doing similar things.\\nDevelopers only need to deal with one solution, which makes the project easier to maintain.
\\n","featured":false,"flag":"default","position":[762,517]},{"id":"csharp","release":"2023-02-23","title":"C#","ring":"adopt","quadrant":"languages-and-frameworks","body":"C# is a statically, strongly typed and object-oriented language.
\\nAfter PHP and several JVM languages, we also have projects with C#. We value all features of this highly developed\\nlanguage.
\\n","featured":true,"flag":"default","tags":["coding"],"position":[262,354]},{"id":"client-side-error-logging","release":"2023-02-23","title":"Client-Side Error Logging","ring":"adopt","quadrant":"methods-and-patterns","body":"Updated to adopt.
\\n","featured":true,"flag":"default","tags":["architecture","frontend"],"revisions":[{"release":"2017-03-01","ring":"trial","body":"More and more business logic is done client-side with various web and app technologies.\\nHow do we know if everything works in production?\\nWe can easily track backend exceptions in the server logs, but what about client-side errors in the user's browser or mobile app?
\\nWith client-side error logging, we send errors to a central server to see instantly what is going wrong.\\nWith this method errors can be found and resolved quickly before they affect even more users.
\\nAt AOE, we use the Open Source solution Sentry.io.\\nIt can handle multiple projects and teams and integrates well with other services such as Mattermost/Slack and Issue Tracking Systems.
\\n"}],"position":[449,339]},{"id":"cockpit","release":"2021-07-01","title":"Cockpit","ring":"hold","quadrant":"tools","body":"We decided to put this CMS on hold due to other - more adopted - alternatives like Strapi.
\\n","featured":false,"flag":"default","revisions":[{"release":"2019-11-01","ring":"assess","body":"Cockpit is a self-hosted headless and api-driven content management system.
\\n"}],"position":[677,649]},{"id":"colima","release":"2022-03-28","title":"Colima","ring":"assess","quadrant":"tools","body":"Colima provides container runtimes on macOS with minimal setup.
\\nAt AOE, we are using Colima as drop-in replacement\\nfor Docker Desktop.
\\nThe main benefits are
\\nas well as the usual requirements for container runtimes like
\\nOur world is increasingly complex - our society and the economic system is developing fast - we constantly have to deal with surprises and uncertainty. This is especially the case in IT organisations that collaboratively and cross-functional work on innovations, "digitalization strategies" or "transformation projects".
\\nSomething is complex, when it is not possible to relate all its elements at the same time. There is no clear cause and result relationship. Decision making processes cannot be well structured.
\\nBut of course that should not be used as an excuse. This realisation can motivate us to find ways to better deal with it. To come to better and new ideas together, to take good decisions and to learn from them.
\\nComplexity management capabilities describe the ability to deal with complexity. The more different dimensions are used to observe and analyse a situation, the higher they are differenciated and the faster this is done - the better complexity is managed. C2M Model
\\nThe complexity in IT initiatives and projects comes from the uncertainties of how a product is adopted by the users and the market, the nearly endless choices of technical ingredients, the team and organisational structures and the established collaboration and communication etc.
\\nAgile methods and other best practices evolved from that challenges - and are now widely adopted - but without proper reflection and complexity management they can also lead to dysfunctional communication patterns.
\\nSince we are solving problems in collaboration we also need to deal with the complexity of the communication system (social system):
\\nAn understanding of how communication systems are working - and what conditions for working communication (and therefore collaboration) exist, helps to address such situations better. It also helps to understand how we can use conflicts for creativity (creating new perspectives and ideas).
\\nThat includes the awareness that we can always learn from each other!
\\nThat is the reason we see systemic perspectives with proper system theoretical background emerging in the space of organisational development. We believe that proper learning of these perspectives and the awareness of complexity management capabilities can help organisations to form functional collaboration. This learning helps to reflect systems and oneself more conscious - and that can be a healthy condition for more impact and learning. It may also help that an organisation does not blindly follow the next model, agile "hype" or consultant promises.
\\nMore on that topic: Systemic Communication
\\n","featured":true,"flag":"default","tags":["agile","architecture"],"position":[608,303]},{"id":"concourse-ci","release":"2023-02-23","title":"Concourse","ring":"trial","quadrant":"tools","body":"Concourse is an open-source continuous "thing-doer".\\nIt represents a general approach for automation which can be used for Continuous Integration and Continuous Delivery.\\nConcourse CI follows a strict concept that is based on idempotency, immutability, declarative config, stateless workers, and reproducible builds.\\nPipelines are built on the mechanics of resources, tasks and jobs, which are all configured in one or multiple YAML files.
\\nConcourse claims to be "simple" but has a steep learning curve in the beginning till it gets simple to use. \\nConcourse is used in the Congstar Team to automate infrastructure deployments.
\\n","featured":false,"flag":"default","tags":["ci/cd"],"position":[584,523]},{"id":"consul","release":"2018-03-01","title":"Consul","ring":"assess","quadrant":"tools","body":"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 across the complete Consul cluster.\\nThe 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 during deployment.\\nConsul is also used as service discovery between apps inside microservice environments.
\\nWith Vault there is another tool that can be used to manage and share secrets.
\\n","featured":false,"flag":"default","position":[670,562]},{"id":"container-based-builds","release":"2022-03-28","title":"Container-based builds","ring":"adopt","quadrant":"methods-and-patterns","body":"Updated to "adopt". Container based builds has getting to the de facto standard for our pipelines in GitLab or other CI Tools.
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"assess","body":"Running your builds in isolated containers keeps your build servers clean.\\nIt allows you to even run them with multiple versions of a framework or programming language.\\nYou don't need additional machines like you would for running builds with PHP5 or PHP7 at the same time or running some legacy builds.
\\nNote that you need to think about some kind of caching mechanism for your dependencies to avoid downloading them in every build, which would cause long build times.
\\nAt AOE, we are currently starting to use this approach for building services and it is especially useful if your build has special dependencies.\\nAlso, it's possible to use GitLab as a build tool or use Docker with the new Jenkins pipeline.\\nFor caching we are evaluating minio as a cache server.\\nWe noticed that our builds run quite rapidly and reliably with that.\\nAlso, the complexity of the builds decreased since we don't need any workarounds, which were caused by having everything installed on one build server.
\\n"}],"position":[503,353]},{"id":"conventionalcommits","release":"2022-03-28","title":"Conventional Commits","ring":"adopt","quadrant":"methods-and-patterns","body":"Conventional commits are being widely used in our teams, therefore we're changing this to adopt. Using commit messages\\nwhich follow the conventional commits specification helps us to easily\\nprocess changes made within a software release. It also helps to reduce confusion around commit message requirements for\\nnew team members.
\\nThe Semanticore release bot is a tool we published, which utilizes\\nconventional commits to maintain the release notes of our software and suggests the correct version of the upcoming\\nrelease.
\\n","featured":true,"flag":"default","tags":["coding","quality assurance","ci/cd"],"revisions":[{"release":"2021-07-01","ring":"trial","body":"The Conventional Commits specification is a lightweight convention on top of commit messages.\\nIt provides a small set of rules for writing commit messages and therefore creating an explicit commit history.\\nThe convention dovetails with SemVer, by describing the features, fixes, and breaking changes made in commit messages.\\nThe specification contains only 16 items that are easy to follow. The predefined structure allows everyone in the team to get a better overview of what the commit messages relates to and what part of the code a change has to do with.\\nSome benefits of using these specifications include: the ability to automatically generate changelogs, the ability to determine a semantic version bump (based on the types of commits landed) and being able to communicate the nature of changes to teammates and stakeholders.
\\nWe use conventional commits in the team with the help of a git template.\\nThe template contains a guide of elements that are required in the specification plus some information about project specific items that should also be part of a commit, such as a ticket number.
\\n"}],"position":[473,329]},{"id":"crc","release":"2022-03-28","title":"CRC Games","ring":"assess","quadrant":"methods-and-patterns","body":"Class Responsibility Collaboration Card Games are a method to discuss and align the software design - especially useful for object-oriented software.
\\nA proper software design is one of the most important things to ensure the sucess and the maintainability of your software.\\nEspecially for iterative development methods, where you work on a software task by task, it is important to have designs sessions that also look forward to the next iterations and the conceptional whole.
\\nAnd for software design to be successful, it is very important that everybody (in the team) has the same understanding of the design and stands behind it.
\\nCRC sessions help to design and align the high-level object design and collaboration of your system with the whole team. During such sessions new team members can learn from the experience and explanations of tropers.
\\nThis is how we often conduct a CRC Session:
\\nSince the release of React 18, many CSS-in-JS libraries like styled-components, emotion, and stitches have encountered a significant challenge. They generate CSS only at runtime, making them incompatible with streaming and React Server Components. React developers have addressed this issue in an article, where they explicitly advise against using CSS-in-JS libraries that generate CSS at runtime.
\\nThis has created substantial uncertainty among developers and the communities of these affected libraries. The question arises: Is it possible to refactor these runtime libraries into buildtime libraries? To date, none of the libraries have announced any such plans, and, unfortunately, one of the most popular new libraries, stitches, is no longer being maintained.
\\nFortunately, there has been a growing number of CSS-in-JS solutions that generate CSS at buildtime. Libraries like Vanilla Extract, panda, and Kuma UI maintain an excellent developer experience, overcome performance disadvantages, and are compatible with React 18.
\\nUnfortunately, these libraries are not yet widely adopted, and it's challenging to predict how they will develop in the future. Therefore, at AOE, we continue to use established solutions as long as the new React features are not mandatory.
\\nMoreover, we are gaining experience with these new libraries because we see significant potential in them.
\\n","featured":true,"flag":"changed","tags":["coding","frontend"],"revisions":[{"release":"2022-03-28","ring":"adopt","body":"At AOE we use CSS-in-JS over regular CSS because it provides a much better developer experience and plays nicely together with modern component libraries like React.
\\n"},{"release":"2021-07-01","ring":"trial","body":"CSS-in-JS is a method where JavaScript is used to style components. The first libraries which implemented this technique were Styled-Components, Emotion & JSS.
\\nconst Button = styled.button`\\n display: inline-block;\\n padding: 0.5rem 0;\\n background: transparent;\\n color: white;\\n border: 2px solid white;\\n\\n ${(props) =>\\n props.primary &&\\n css`\\n background: white;\\n color: black;\\n `}\\n`;\\n\\nreturn <Button primary>Click me</Button>;\\nAdvantages of CSS-in-JS
\\nDisadvantages of CSS-in-JS
\\nIn the meantime CSS-in-JS has evolved even more. There are some libraries which leverages nearly zero-runtime costs such as Stitches or Vanilla Extract while still providing an excellent developer experience with TypeScript.
\\nWe at AOE think that CSS-in-JS is the future of writing good, performant and maintainable CSS, therefore we already use different CSS-in-JS solutions throughout multiple applications.
\\n"}],"position":[446,280]},{"id":"cypress","release":"2021-07-01","title":"Cypress","ring":"adopt","quadrant":"tools","body":"Cypress has proven itself in AOE projects.\\nWith its support for JavaScript and TypeScript, Cypress is a testing tool that strongly relates to front-end developers.\\nIt is very easy to adopt, and the test specifications are easy to implement and to maintain.\\nTest execution is very fast, and the results are well documented, understandable and easy to publish, e.g. via GitLab Pages.\\nIt currently supports Chrome, Firefox and Electron.
\\n","featured":true,"flag":"default","tags":["frontend","quality assurance"],"revisions":[{"release":"2019-11-01","ring":"assess","body":"Cypress is a front-end testing tool (E2E). It comes as a simple node package and is therefore easy to use and maintain for front-end developers and testers. Cypress has a different approach than Selenium. It runs in the browser and in the same loop as the device under test.
\\nGood:
\\nNot so good:
\\nExample of a test :
\\ndescribe('My First Test', function() {\\n it('Visits the Kitchen Sink', function() {\\n cy.visit('https://example.cypress.io')\\n\\n cy.contains('type').click()\\n\\n cy.url().should('include', '/commands/actions')\\n\\n cy.get('.action-email')\\n .type('fake@email.com')\\n .should('have.value', 'fake@email.com')\\n })\\n})\\nDagger is a fully static, compile-time dependency injection framework for both Java and Android. Dagger doesn't use reflections at runtime, it saves resources.\\nFor us, it is a perfect match for Android development.
\\nWe at AOE use it as a base framework for every Android project.
\\n","featured":false,"flag":"default","position":[563,444]},{"id":"ddev","release":"2023-02-23","title":"DDEV","ring":"adopt","quadrant":"tools","body":"DDEV is an open source tool that makes it dead simple to get local PHP development environments up and running within minutes.\\nIt's powerful and flexible as a result of its per-project environment configurations, which can be extended, version controlled, and shared.\\nIn short, DDEV aims to allow development teams to use Docker in their workflow without the complexities of bespoke configuration.
\\nAt AOE, we use DDEV in a variety of PHP projects (large and small).\\nIt has made the onboarding process extremely easy for new developers and developers who have already worked with DDEV feel right at home in other projects.
\\nDDEV makes adding needed dependencies super easy and so far has met every requirement we've ever had.\\nThis is mainly because DDEV is just a wrapper for existing tools like Docker-Compose. However, it does take away a lot of the complexity that is normally involved in configuring these tools.
\\n","featured":false,"flag":"default","tags":["coding","ci/cd"],"position":[441,435]},{"id":"decoupling-infrastructure-via-messaging","release":"2019-11-01","title":"Decoupling Infrastructure via Messaging","ring":"trial","quadrant":"methods-and-patterns","body":"In Microservices we have already covered the trend that modern architectures are moving away more and more from big monolithic applications to distributed software suites.\\nThe result of splitting our software and infrastructure in smaller parts, is the need to communicate with each other.\\nThis can be done by direct communication or by message-based asynchronouous communication.\\nWhile 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.
\\nMost of the IaaS Cloud providers offer messaging services such as AWS SQS which provide the possibility to decouple our infrastructure via Messaging.\\nAlso, we use RabbitMQ as a Messaging and Broker solution within our applications.\\nThe decision of using messaging and messaging patterns as an integration strategy can be made as part of strategic design considerations.
\\n","featured":false,"flag":"default","position":[573,205]},{"id":"deno","release":"2023-11-01","title":"Deno","ring":"assess","quadrant":"languages-and-frameworks","body":"> 'node'.split('').sort().join('')\\n> 'deno'\\nDeno is a secure, modern JavaScript and TypeScript runtime built on the V8 JavaScript engine. It was developed as a more secure and developer-friendly alternative to Node.js by Ryan Dahl, the core author of Node.js.
\\nDeno prioritizes security by default, enforcing strict permissions for file system access, network access, and environment variable usage. It also offers improved performance, thanks to its utilization of the latest JavaScript features and optimizations. Deno supports TypeScript out of the box, allowing developers to take advantage of static type checking and other TypeScript features. It incorporates a built-in module system, reducing dependency conflicts and simplifying module management.
\\nWith its streamlined developer experience, which includes a standard library and support for modern language features, Deno offers a compelling option for JavaScript and TypeScript developers.
\\n","featured":true,"flag":"new","tags":["coding"],"position":[297,113]},{"id":"dependency-update-scan","release":"2022-03-28","title":"Dependency Update Scan","ring":"adopt","quadrant":"methods-and-patterns","body":"Tools for automated dependency updates continue to offer a big productivity gain when integrated well into the build workflow.
\\nNonetheless, this comes not without a word of warning.\\nWhile it's great in theory, constant updates might quickly lead to a bombardment of merge requests.\\nIt is crucial that the chosen tools work reliably and are really well integrated. Otherwise, this might become overwhelming for teams.\\nAs an alternative, we also had good experience with disabling automatic merge requests and just manually triggering a job when we wanted to take care of the updates.
\\n","featured":true,"flag":"default","tags":["security","ci/cd"],"revisions":[{"release":"2021-07-01","ring":"trial","body":"Tools for automated dependency updates continue to offer a big productivity gain when integrated well into the build workflow.
\\nNonetheless, this comes not without a word of warning.\\nWhile it's great in theory, constant updates might quickly lead to a bombardment of merge requests.\\nIt is crucial that the chosen tools work reliably and are really well integrated. Otherwise, this might become overwhelming for teams.\\nAs an alternative, we also had good experience with disabled automatic merge requests and just manually triggered a job when we wanted to take care of the updates.
\\n"},{"release":"2019-11-01","ring":"assess","body":"Automated dependency scans are useful to remove the manual task of regularly checking for version updates.\\nOur teams are utilizing the Open Source bots Renovate and Scala Steward, both of which are running as a scheduled GitLab job in our internal infrastructure.\\nThe bots are regularly creating merge requests with dependency version updates against our projects.
\\nHaving this automated comes with a few advantages:
\\nAutomated merge requests allow us to focus on reviewing, testing and prioritization of dependency version updates with considerably less effort.
\\n"}],"position":[461,371]},{"id":"design-system","release":"2023-11-01","title":"Design System","ring":"adopt","quadrant":"methods-and-patterns","body":"Through the implementation of design systems, we have demonstrated that this approach aligns with many of the mentioned benefits and recommend its use in future projects.
\\n","featured":true,"flag":"changed","tags":["ux/ui","frontend","coding","architecture","documentation"],"revisions":[{"release":"2023-02-23","ring":"trial","body":"A Design System is a collection of reusable design components, guidelines and standards that serve as the foundation for\\ncreating a consistent user experience across a product or a whole brand.
\\nIt helps to create a unified visual language, improve collaboration among design and development teams, and streamline\\nthe design and development process.
\\nDesign Systems also increase the maintainability of the design of products, making it easier for teams to make updates\\nand add new features over time.
\\nWe are in the process to implement a design system in close cooperation with one of our customers.
\\nTools we use for this are zeroheight as a documentation hub,\\nStyle Dictionary for the token generation,\\nStorybook to document the components and Figma for the Designs.
\\n"}],"position":[524,325]},{"id":"devops-practices","release":"2023-11-01","title":"DevOps Practices","ring":"adopt","quadrant":"methods-and-patterns","body":"DevOps is a term that has been around for some years now.\\nWe understand DevOps as a philosophy and culture with related practices and tools - all with the aim of bringing (IT) Operations closer to Development.
\\nJez Humble described the devops movement like this: "a cross-functional community of practice dedicated to the study of building, evolving and operating rapidly changing, secure, resilient systems at scale".
\\nWith the size of software projects and the effects of agile development, the need to also deliver operation and infrastructure in an agile way increases more and more.
\\nWe have been using the following practices with success:
\\nCross-functional Teams "you build it, you run it"
\\nIn the past year, we have moved from a more centralistic or standalone IT and operations service team to cross-functional teams with Infrastructure experts working in and with the development team (admins joining the project team).
\\nAnd, we changed to cross-functional teams and a "you build it, you run it" approach for the bigger projects.\\nWe have seen that this leads to the following positive effects:
\\nAs always, we are establishing "community of interests" to improve and promote the knowledge transfer between different teams.
\\nIncrease of relevant tools
\\nAnother important aspect and also enabler of DevOps practices is the increase of certain tool and methods - some of them are also represented in the Tech Radar. For example: Puppet Environments; Docker; Cloud Services, Terraform, Consul etc.
\\nDevSetup = Prod Setup, Infrastructure as a Code
\\nKeeping the development infrastructure setup close to production is also a commonly implemented practice and a direct result of the "Infrastructure as Code" method.\\nHandling infrastructure and the required changes and innovations in ways similar to those used for applications is important; you can ready more about this here: Infrastructure as Code
\\nWe encourage all teams to adopt devops practices in the teams and to take care that there is a true collaboration between the different experts in a team and no invisible wall.
\\n","featured":false,"flag":"changed","tags":["devops"],"position":[459,312]},{"id":"dgs","release":"2023-02-23","title":"DGS Framework","ring":"assess","quadrant":"tools","body":"DGS has proven to simplify the development of GraphQL server applications.\\nThus, we recommend a broader usage across AOE and decided to move the blip\\nto "trial".
\\n","featured":false,"flag":"default","tags":["frontend","architecture"],"revisions":[{"release":"2022-03-28","ring":"trial","body":"DGS has proven to simplify the development of GraphQL server applications.\\nThus, we recommend a broader usage across AOE and decided to move the blip\\nto "trial".
\\n"},{"release":"2021-07-01","ring":"assess","body":"The DGS Framework is a GraphQL server framework based on Spring Boot.\\nIt extends GraphQL Java with additional features such as:
\\nIt works well with both Java and Kotlin and allowed us a quick start with getting our first GraphQL servers up and running.
\\n"}],"position":[626,614]},{"id":"diagrams-as-code","release":"2023-11-01","title":"Diagrams as Code","ring":"adopt","quadrant":"methods-and-patterns","body":"Documenting concepts and software architecture as diagrams using code offers significant benefits over heavier solutions. Treating documentation and diagrams as code and checking them into version control increases transparency, collaboration, and productivity. The textual representation of diagrams is easy to write and read, and generating graphical representations as SVG or PNG images is also straightforward with the associated tools.
\\nWe extensively use PlantUML in combination with Asciidoc and tools like AsciiDoctor Diagram to include and inline PlantUML diagrams in our documentation. The latter allows for a variety of other diagram formats, which can be easily mixed and matched.
\\nOther tools worth mentioning include:
\\nDocumenting concepts and software architecture as diagrams using code offers great benefit over heavier solutions.\\nHaving documentation and diagrams treated as code and checked-in into version control increases transparency, collaboration as well as productivity.\\nThe textual representation of diagrams is easy to write and read. Generation of graphical representations as SVG or PNG images is also easy with the associated tools.
\\nWe make heavy use of PlantUML combined with Asciidoc and tools like AsciiDoctor Diagram to include and inline PlantUML diagrams into documentations.\\nThe latter allows a variety of other diagram formats which can be easily mixed and matched.
\\n"}],"position":[528,363]},{"id":"dora-metrics","release":"2023-11-01","title":"DORA Metrics for DevOps","ring":"trial","quadrant":"methods-and-patterns","body":"A primary goal of software development organizations is to enhance the performance of software delivery and operations.
\\nThere are numerous best practices and differing opinions on how to approach "DevOps the right way." We've learned that IT organizations and software delivery are complex issues, which means that most of the time there are no "easy" answers. Instead, continuous improvement within a contextual framework is a critical element.
\\nTo introduce more objectivity and a measure of verifiability, we like to use the four key metrics suggested by "The State of DevOps" and "DORA." These four key metrics are:
\\nTo evaluate velocity:
\\nTo evaluate stability:
\\nThe DevOps Research and Assessment (DORA) is the largest and longest-running research program of its kind, aiming to understand the capabilities driving software delivery and operations performance. Their report, "The State of DevOps," regularly provides insights, observations, and insights into high-performing IT organizations.
\\nDrupal is an open source content management system and framework based on a PHP stack.\\nIt has a huge community, so it's no wonder it's among the top 10 CMS worldwide in terms of market share.
\\nAt AOE we consume Drupal mainly headless via JSON API. We appreciate its large feature set and mature plugin system as well as the general ecosystem.
\\nIn addition, the extensive documentation and setup with DDEV make it easy to get started.
\\n","featured":false,"flag":"default","position":[496,606]},{"id":"event-storming","release":"2019-11-01","title":"Event Storming","ring":"assess","quadrant":"methods-and-patterns","body":"Event Storming is a method of modeling business processes using domain events.
\\nWith complex business processes, people usually know their part of the process very well.\\nHaving people from different departments in one room, allows (and requires!) a conversation.\\nKnowledge silos get opened up. All learnings can be directly visualized.
\\nWe tried this method a couple of times with different sized scopes. We believe it can be of value and has potential.
\\nIt's like brainstorming - with the goal to visualize a business line or process.
\\nEvent Storming is done in a workshop format.
\\nTo get a business process modeled quickly and complete, it's important to get domain experts, developers, UX and everybody else who is involved to some extent in the related business line into one room.\\nWith virtually unlimited space for modeling using big paper rolls put onto the walls, equipped with colored stickies and markers, the modeling workshop can start.
\\nDuring the workshop, the goal is to model the big picture, without limiting or focusing just on parts of a process.
\\n","featured":true,"flag":"default","tags":["architecture"],"position":[703,313]},{"id":"evil-user-stories","release":"2022-03-28","title":"Evil User Stories","ring":"assess","quadrant":"methods-and-patterns","body":"With Evil User Stories, we aim to raise the project teams' (PO, Dev-Team, QA) and clients' awareness for security topics and introduce a security-by-design principle.
\\nThe first step is to identify business use cases of potential vulnerabilities in our software product. The next step is to write an Evil User Story for this use case, from the perspective of an evil persona, e.g. "John Badboy who wants to hack our software". The idea behind this is to take a look at specific parts (business logic) of the software from a perspective that would otherwise not be considered when working on standard user stories.
\\nSo how would this work? To illustrate this, let's consider the following user story: "As Emma Shopping I am be able to pay for a product in my checkout using a credit card". To get that story done, we might have to persist some payment data somewhere. But within the context of an Evil user story we now also need to consider the security for the credit card and payment handling in our application. So, for that reason, we write an Evil User Story, which in this case could, for example, be "As John Badboy, I want to steal payment data" or more specifically "As John Badboy, I want to do to sql inject to get the payment token".
\\nBefore implementation of this particular user story starts, developers should think about how they can secure potentially vulnerable parts of the software to prevent attacks such as sql injections. In this case, one approach should be the use of prepared statements for sql queries. When the development is finished, we should then be able to test the story using an automated testing approach with a penetration testing tool such as sqlmap to confirm that our database queries are not vulnerable to sql injections.
\\nAdditionally, both solutions should be checked during the development process using code reviews to identify and correct potentially buggy code.
\\n","featured":false,"flag":"default","position":[666,240]},{"id":"explicit-test-strategy","release":"2019-11-01","title":"Explicit test strategy","ring":"assess","quadrant":"methods-and-patterns","body":"According to the ISTQB Glossar- 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.
\\nAt 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.
\\nThese 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:
\\nAs 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.
\\nDue to the practical usefulness of having a sound test strategy for a project, we classify the explicit test strategy for projects with assess.
\\n","featured":false,"flag":"default","position":[617,179]},{"id":"falco","release":"2019-11-01","title":"Falco","ring":"assess","quadrant":"tools","body":"Falco is an open source project for intrusion and abnormality detection for Cloud Native platforms such as Kubernetes. \\nIt detects abnormal application behavior and sends alerts via Slack, Fluentd, NATS, and more.
\\nWe are assessing Falco to add another angle to host based intrusion detection and alerting.
\\n","featured":true,"flag":"default","tags":["security"],"position":[712,481]},{"id":"figma","release":"2021-07-01","title":"Figma","ring":"adopt","quadrant":"tools","body":"Figma became our go-to tool for the next generation collaborative design. It allowed UX/UI designers, engineers, stakeholders, product managers, and other roles to view, inspect and comment on designs and wireframes, create high- and low-fidelity prototypes, and much more.
\\nFigma puts together all of the features we used in different tools (Axure, Miro, Abstract, Sketch, Anima, Invision) in one. It allowed us to make a single source of truth for our products, create design systems, and eliminate the vast majority of the pain points we faced in the past. It became beneficial, especially in remote and distributed design work, and speed up all our design-related processes. In addition to its real-time design and collaboration capabilities, Figma also offers an extensive, community-backed plugin collection and a robust API that helps to improve the DesignOps processes.
\\n","featured":true,"flag":"default","tags":["frontend","ux/ui","agile"],"position":[509,485]},{"id":"flamingo","release":"2019-11-01","title":"Flamingo","ring":"adopt","quadrant":"languages-and-frameworks","body":"Flamingo is a high productivity go based framework for rapidly building fast and pluggable web projects.\\nIt is used to build scalable and maintainable (web)applications.
\\nFlamingo is:
\\nGo as simple, powerful and typesafe language is great to implement and scale serverside logic.\\nFlamingo has a clean architecture with clear dependencies in mind and offers a typical features and support for nowadays web applications:
\\nFlamingo itself does not contain ORM Mapper or libraries - instead it emphasizes "ports and adapters" architecture - so that you have a technology free (domain) model and any possible (and replaceable) persistence behind it.\\nThat makes Flamingo useful to build microservices and applications - especially to build "frontends" or portals that require interaction with other (micro) services in a distributed architecture. \\nWhen sticking to the architectural recommendation, you can build modular applications with replaceable adapters that gives you independent testability.
\\nWith "Flamingo Commerce" there is an additional active projects that offer rich and flexible features to build modern e-commerce applications.
\\n","featured":true,"flag":"default","tags":["coding"],"position":[358,289]},{"id":"flow","release":"2018-03-01","title":"Flow","ring":"hold","quadrant":"languages-and-frameworks","body":"Flow is a PHP web application framework developed for the Neos project.
\\nWe used Flow in a couple of projects and decided to put it on hold for the following reasons:
\\nAlthough it could be that some of the above-mentioned aspects have improved in the past, we decided to use other PHP frameworks such as Symfony or other Languages (See Go; Play Framework; Spring Boot)
\\n","featured":false,"flag":"default","position":[65,258]},{"id":"flowtype","release":"2021-07-01","title":"Flow","ring":"hold","quadrant":"tools","body":"With a much larger community, better support from frameworks (React, Angular, Vue) and IDEs and a similar feature set, Typescript is the better choice instead of Flow.
\\n","featured":false,"flag":"default","revisions":[{"release":"2019-11-01","ring":"assess","body":"Flow is a static type checker for JavaScript code. Its goal is to make code faster, smarter, \\nmore confidently, and to a bigger scale.
\\n"}],"position":[633,683]},{"id":"fluentd","release":"2023-11-01","title":"Fluentd","ring":"hold","quadrant":"tools","body":"Fluentd remains a great tool for collecting logs, transforming them into any required format, and distributing them to various logging backends. However, in recent years, we have often transitioned to Grafana Loki and Promtail for several reasons.
\\nWe've also learned that extensive upfront log parsing carries a risk of losing logs and requires significant effort. This doesn't fit well with most projects.
\\n","featured":true,"flag":"changed","tags":["devops"],"revisions":[{"release":"2021-07-01","ring":"assess","body":"Fluentd is a great tool to gather logs, transform them into any required format and distribute them to any logging backend.
\\nAt AOE we use fluentd in different contexts, but mostly to gather logs from kubernetes clusters into data backends like Elasticsearch.
\\n"}],"position":[696,626]},{"id":"flutter","release":"2023-02-23","title":"Flutter","ring":"trial","quadrant":"languages-and-frameworks","body":"Flutter is an open-source SDK developed by Google that allows you to write native applications\\nfor different platforms with a single code base in Dart.
\\nFlutter provides stable platform implementations for both major mobile platforms iOS and Android. Besides the mobile\\nplatforms, it also supports stable builds for Web with multiple rendering engines (DOM and canvas-render). Flutter also\\nsupport builds for all Desktop environments, including Mac, Windows and Linux.
\\nThe compilation into native platform code prevents from bottleneck-issues due context switching and runtime bridging,\\nwhich can be found in other cross-platform frameworks like React Native.
\\nFlutter is using a reactive programming model, where widgets rebuild when their state changes. Based on a declarative\\napproach like SwiftUI it is really easy to build UI components (widgets). Meanwhile, Flutter has a big community with a\\nlot of support and pre-build widgets.
\\nFlutter has made significant improvements and is becoming more and more popular in recent years. Big companies,\\nincluding Alibaba, Tencent and BMW adopted Flutter to develop their apps. This is also shown in\\na blog post by Stackoverflow\\nwhere it shows the increase in popularity in comparison to React Native
\\nBased on these facts, we decided to get a deeper look on Flutter. We were able to prove that Flutter is more performant\\nthan, React Native by building an identical Prototype application with both Frameworks.
\\nIn addition to the Framework itself, Flutter does a lot to improve the developer experience (DX) due to its hot reload\\nand various debugging tools which are very handy and missing in other Frameworks like React Native. There are also a lot\\nof plugins for WebStorm and Visual Studio Code which also improves the DX a lot.
\\n","featured":true,"flag":"default","tags":["coding","frontend","ux/ui"],"revisions":[{"release":"2021-07-01","ring":"assess","body":"Flutter allows writing native applications for different platforms with a single code base in Dart.
\\nIt provides stable platform implementations for both major mobile platforms iOS and Android.\\nWith Flutter on the Web it is possible to build single-page applications (SPA) out of the same code with full support for service workers.\\nThe Desktop (Windows, Mac, Linux) platform is currently still in beta (as of mid 2021).
\\nThe 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.
\\nComparing to a Javascript-based PWA, Flutter's approach promises a better performance and energy-efficiency.
\\nWe 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.
\\n"}],"position":[326,166]},{"id":"flux","release":"2023-11-01","title":"Flux","ring":"hold","quadrant":"methods-and-patterns","body":"In the early days of React, Flux was introduced by Facebook as an architectural pattern for managing global state. Later, it evolved into a library, with contributions from the community.
\\nToday, there are numerous libraries that offer the Flux pattern or similar approaches to state management. These include framework-agnostic solutions like Redux or MobX, as well as framework-specific options like Pinia for Vue and Zustand for React, among many others.
\\nOne of the most popular solutions to date is Redux, which is why we use it in several projects.
\\n","featured":false,"flag":"changed","tags":["frontend"],"revisions":[{"release":"2019-11-01","ring":"assess","body":"Flux is an application architecture for building client-side web applications,\\nwhich is based on React's composable view components.
\\n"}],"position":[746,265]},{"id":"galen","release":"2019-11-01","title":"Galen","ring":"assess","quadrant":"tools","body":"With Galen Framework, 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.
\\nSo, 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.
\\nWhenever 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.
\\nAt AOE, the Galen Framework helps us to continuously test the UI for potential regression bugs introduced by new features.
\\n","featured":false,"flag":"default","position":[500,707]},{"id":"gatling","release":"2021-07-01","title":"Gatling","ring":"adopt","quadrant":"tools","body":"Gatling is still a valid tool which is widely used in our teams.\\nOther alternatives like Locust exist and fill the same niche but Gatling is a better fit for our toolstack.
\\n","featured":false,"flag":"default","revisions":[{"release":"2018-03-01","ring":"adopt","body":"Gatling is now the de-facto tool of choice for load testing in all of our projects, having superseded JMeter completely.\\nWe therefore moved it to the Adopt level.
\\n"},{"release":"2017-03-01","ring":"trial","body":"Gatling is a highly capable load testing tool. It is designed for ease of use, maintainability and high performance.
\\nOut 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.
\\nGatling is built with Scala Lang and 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.
\\nThis 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.
\\nBesides the very good performance, we definitely like the pure code-based approach. Gatling creates HTML-based reports with nice graphs and metrics about how and what was tested.
\\nWe use Gatling as an alternative to Jmeter with success in some of our projects. We encourage teams to try Gatling for future load testing. There is an integrated test recorder similiar to what other test frameworks have to get you started with a basic test case.
\\n"}],"position":[509,528]},{"id":"gitflow","release":"2019-11-01","title":"GitFlow","ring":"hold","quadrant":"methods-and-patterns","body":"Ever since there are recurring discussions about the version control strategy that a team should use.
\\nWe have also made the experience when new teams start off with using blocking or long-lived feature branches (merge late once all review comments are done) it has a negative impact on team performance.
\\nWe recommend to use trunk based development with short-lived (<1day) feature branches, because this has shown to support continuous integration and team collaboration the best. However, we do accept teams choices to use GitFlow, we just do not try to encourage them in the first place.
\\nSee also:
\\nWe merged GitLab and GitLab CI, because we use the whole tool as one, with all the integrations between the different sections. CI is just one of them.
\\n","featured":false,"flag":"changed","tags":["ci/cd","coding"],"revisions":[{"release":"2019-11-01","ring":"adopt","body":"Moved to "adopt": GitLab has proven to be a very useful tool for code and the collaboration around it.\\nWith GitLab CI there is also a powerful tool to automate continuous integration and delivery.
\\n"},{"release":"2018-03-01","ring":"trial","body":"GitLab provides nearly the same feature set as GitHub, but at a lower price. It also provides the possibility of hosting internally, which is essential for us.
\\nWe are migrating more and more repositories from gitolite, even from SVN to GitLab, as it provides a more stable and user-friendly interface.
\\nGitLab also makes user/permission handling easier than our old gitolite. We don't need the IT team every time a new repository needs to be set up.
\\n"}],"position":[444,569]},{"id":"gitlab-ci","release":"2022-03-28","title":"GitLab CI","ring":"adopt","quadrant":"tools","body":"We merged "GitLab CI" and GitLab
\\n","featured":false,"flag":"default","revisions":[{"release":"2019-11-01","ring":"adopt","body":"Moved to "adopt".
\\n"},{"release":"2018-03-01","ring":"assess","body":"Until now, we have been using Jenkins for almost every single task that we have automated. With GitLab CI on the market, we have a number of new possibilities.
\\nSome highlights are:
\\nWe have moved Go to "adopt".
\\n","featured":true,"flag":"default","tags":["coding"],"revisions":[{"release":"2018-03-01","ring":"trial","body":"We have moved Go to Trial because multiple teams have used Go with success for different services and tools.\\nThe learning curve and productivity have proven to be immense and we are convinced that this language will find more adoption in other teams.
\\n"},{"release":"2017-03-01","ring":"assess","body":"2016 was the year of Go, with a lot of Open Source projects gaining a lot of attention and many companies started to use it.
\\nGo went from #54 to #13 on the TIOBE index in January 2017, and it became the TIOBE programming language of the year 2016.
\\nHere at AOE, we use several services written in Go on a daily basis, such as Mattermost, Docker, Consul and Kubernetes. Also, more and more applications, such as GitLab, incorporate Go-based services to "off load" heavy work.
\\nGo, as a programming language, has some very interesting features such as native support for concurrency (go routines), static compiled binaries with a very small memory footprint, cross compiling and much more. A big advantage of Go is the very flat learning curve, which allows developers from more dynamic languages such as PHP to be proficient in a very short time.
\\nIf you want to get a feeling for Go, you should start with the online tour, within a day you'll have a good understanding of the core concepts, syntax, etc. - that is also because the language often tries to provide only one simple way of doing things; an example for this is that code formatting and styling is defined (yet not enforced as in Python). Part of this is also that Go itself is very opinionated: So, for example, for object oriented programming in Go, composition is the preferred way of defining data structures, and some might miss advanced concepts such as inheritance.
\\nWe currently use Go for projects and microservices where we need flexibility and performance.
\\n"}],"position":[268,282]},{"id":"graalnaative","release":"2021-07-01","title":"Graal Native Image","ring":"trial","quadrant":"tools","body":"Native Image is a technology to ahead-of-time compile Java code to a standalone executable, called a native image.\\nIn the process of building a native image all library dependencies, including those from the JDK will be packed in the native image.\\nThe application created as a native image can be run without a JDK.\\nThe natively compiled applications require generally less memory and have shorter start up times.
\\nWe at AOE have already running microservices written in Scala with Graal Native Image.
\\n","featured":true,"flag":"default","tags":["coding"],"position":[535,620]},{"id":"gradle","release":"2023-11-01","title":"Gradle","ring":"adopt","quadrant":"tools","body":"Gradle is a build automation tool originating in the Java space, providing declarative dependency management (like Maven) and support for custom functionality (like Ant). It has superb multi-project support and is extremely extensible via third-party plugins and also via self-written extensions and plugins that make it outstanding in its area.
\\nIt uses a Groovy-based DSL to declaratively model your problem domain (Build automation) and provides a rich object model with extension points to customize the build logic. Because it is extremely easy to extend this DSL, you can easily provide a declarative interface to your customizations and add-ons.
\\nWhile 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++.
\\nAt AOE, it is used in various places already: to build Anypoint- and Spring Boot- 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.
\\n","featured":false,"flag":"changed","tags":["ci/cd","coding"],"position":[479,475]},{"id":"graphql","release":"2023-02-23","title":"GraphQL","ring":"adopt","quadrant":"methods-and-patterns","body":"For Spring Boot based backends DGS provides\\na nice framework featuring:
\\nGraphQL is a query language for your API, and a server-side runtime for executing queries by\\nusing a type system you define for your data. It isn't tied to any specific database or storage engine and is instead\\nbacked by your existing code and data.
\\nGraphQL was developed by Facebook around 2010 and released 2015.\\nThe main challenge it solves is to improve communication between browser and server on high dynamic web apps.
\\nKey advantages are:
\\nClient side integration can be achieved using the Apollo Client Framework which easily\\nintegrates into React.js based frontends.
\\nThe Flamingo framework offers support for GraphQL\\nwhile Flamingo Commerce provides a full-featured GraphQL API for e-commerce:\\nExample GraphQL Console for Commerce.
\\n"}],"position":[476,239]},{"id":"green-it","release":"2023-11-01","title":"Green IT","ring":"assess","quadrant":"methods-and-patterns","body":"In an age of ever-increasing digitalization, the energy consumption of data centers and the Internet continues to rise, raising concerns about the environmental impact of our digital activities. In response, the concept of "Green IT" has emerged, emphasizing the need for eco-friendly software development and operational practices. By highlighting key architectural patterns, development practices, and operational strategies for reducing the carbon footprint of IT applications, it challenges software vendors and developers to explore how they can contribute to greater sustainability.
\\nWell-architected software plays a pivotal role in reducing the environmental impact of digital systems. Sustainability in software development involves the consideration of various factors throughout the entire lifecycle:
\\nSoftware applications, especially those hosted in data centers, have a substantial environmental footprint as they require significant amounts of energy to operate. In addition, their development and use often necessitate the production of hardware devices such as servers, laptops, and smartphones.
\\nAssessing the carbon emissions throughout an application's lifecycle enables developers and enterprises to make informed decisions that reduce emissions, lower costs, and ensure compliance with environmental regulations. Measuring energy consumption highlights areas where software can be optimized for improved efficiency. Environmental metrics support sustainability reporting, showcasing an organization's commitment to eco-friendly practices.
\\nEfficiency improvements often lead to time and cost savings, which can paradoxically lead to more workload and less energy savings - a rebound effect. Finding a balance between efficiency gains and sustainable growth is critical to sustainable software development.
\\nThe environmental impact of digitalization is a nuanced interplay between its potential for energy consumption and its ability to promote sustainability.
\\nBlockchain technology utilizing energy-intensive mining processes of proof-of-work consensus mechanisms demands immense computational power, resulting in substantial carbon emissions. Machine learning, a cornerstone of AI, requires vast amounts of data and computational resources.
\\nHowever, digitalization also emerges as a champion of environmental stewardship in several areas: Demand-driven production optimizes inventory, reduces waste, and curtails unnecessary production, ultimately minimizing energy consumption and emissions. The digital product passport introduces traceability and transparency throughout a product's lifecycle, promoting sustainability and empowering consumers to make eco-conscious choices.
\\nSustainable software development is not only an ethical imperative but also a competitive advantage. However, achieving comprehensive sustainability is a complex task. More than just minimizing energy consumption, Green IT compels us to make conscientious choices at every stage of the software development lifecycle. By adopting architectural patterns that prioritize sustainability, optimizing code, and embracing best practices in operations, we can contribute to a more eco-friendly digital future.
\\n","featured":true,"flag":"new","tags":["architecture","coding"],"position":[685,263]},{"id":"groovy","release":"2022-03-28","title":"Groovy","ring":"hold","quadrant":"languages-and-frameworks","body":"Since the rise of Kotlin, we seen no need why to still use Groovy as an alternative to Java running on the JVM.
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"Groovy is a dynamically typed compiled language running on the JVM. It is easy to learn as it provides a familiar syntax for Java programmers, but also offers advanced features such as closures and makes some mandatory Java syntax requirements optional to enhance the conciseness of the code. These features make Groovy especially well-suited for scripting and domain-specific languages. This is used by popular tools such as Gradle or Spock.
\\nAt AOE, Groovy is used in many projects and areas. We use Gradle as a build system, we carry out unit and integration testing with Spock and Geb, we generate Jenkins jobs with JobDSL and we implement complete services with Groovy and Spring Boot.
\\n"}],"position":[244,58]},{"id":"grpc","release":"2019-11-01","title":"GRPC","ring":"adopt","quadrant":"languages-and-frameworks","body":"We adopted GRPC, because it is used on multiple places within our microservice oriented architectures for internal communication.
\\n","featured":true,"flag":"default","tags":["architecture","coding"],"revisions":[{"release":"2018-03-01","ring":"assess","body":"gRPC, "A high-performance, Open Source, universal RPC framework," is a framework to easily connect clients and servers in an RPC setup.\\ngRPC was initially built at Google, and uses protobuf service definitions for method and payload specification.\\nEssentially, this makes it possible to define methods that a server exposes, with either a single payload or an incoming stream - either as a single response or a stream of responses.\\nThe definition itself is carried out with the help of protobuf to define message types and method signatures, and then client and server interfaces are compiled for the language(s) you want. Currently, there is support for languages such as C++, Java, Python, Go and many more.\\nThe shared language-neutral protobuf definition allows you to create all code for all languages automatically and helps with the interoperability of different systems.
\\nFrom a technical point of view, gRPC uses HTTP/2 as a transport, directly benefitting from the default TLS encryption.\\nBesides gRPC, other frameworks also use protobuf RPC definitions. These frameworks include twirp from twitch, which makes it easy to change the transport/control layer with only very small changes to the application code.
\\nWe at AOE plan to assess gRPC for microservice architectures which are more RPC style and less REST style.
\\n"}],"position":[350,265]},{"id":"grunt","release":"2019-11-01","title":"Grunt","ring":"hold","quadrant":"tools","body":"Grunt is a JavaScript task runner that automates repetitive tasks. While Grunt served us well for a good amount of projects,\\nother alternatives such as Gulp emerged in the meantime and proved to be a better pick for the\\nmajority of our teams.
\\nWe have two main reasons for discarding Grunt in favor of other tools:
\\nIf a decent amount of tasks is reached, Grunt is known to run slower than other tools, because it heavily relies on I/O operations and\\nalways stores the result of one task as files on the disk.
\\nOn large projects where a lot of automation is required, it can get very tedious to maintain complex and parallel running tasks.\\nThe grunt configuration files sometimes simply don\xb4t gave us the flexibility that we needed.
\\nCurrently, our preferred way to go is either simply use npm scripts or rely on Webpack loaders for file preprocessing. For non-webpack projects we also utilize Gulp.
\\n","featured":false,"flag":"default","position":[602,720]},{"id":"gulp","release":"2018-03-01","title":"Gulp","ring":"adopt","quadrant":"tools","body":"Gulp is a JavaScript task runner much like Grunt. The tasks are written in JavaScript code.
\\nIt is a tool that helps you automate numerous tasks surrounding web development.\\nA typical use is to configure preprocessors for Sass, to compile CSS or to optimize CSS, JavaScript and Images.
\\nWith Gulp and its many plugins you can also do stuff such as start a web server and reload the browser if changes happen.
\\nTo get started you need to install Gulp on your machine via npm.
\\nnpm install gulp -g\\nYou also need it locally in your project, so you have to install it as a dependency in your project .
\\nnpm install gulp --save-dev\\nYou can split your tasks into various smaller sub-tasks and even split it up into smaller files.
\\nA basic Gulp task can look like this:
\\nconst gulp = require('gulp');\\n// Requires the gulp-sass plugin\\nconst sass = require('gulp-sass');\\nconst autoprefixer = require('gulp-autoprefixer');\\nconst cssnano = require('gulp-cssnano');\\n\\ngulp.task('sass', function(){\\n return gulp.src('app/scss/**/*.scss') // tell gulp where your source files are\\n .pipe(sass()) // Converts sass into css with the help of a gulp plugin called gulp-sass\\n .pipe(autoprefixer({browsers: ['last 2 versions']})) // auto prefixes the css for the last 2 versions of browser, like ie9 specific css\\n .pipe(cssnano()) // minify the css\\n .pipe(gulp.dest('app/css')) // tell gulp where to put the converted file. this is the first time where a file is written\\n});\\nYou can now run this task simply by executing the following command in your terminal:
\\ngulp sass\\nWe use HAL in cases where we need to link resources in payloads.\\nHATEOAS has not proven to be very useful in our projects.
\\n","featured":false,"flag":"default","revisions":[{"release":"2018-03-01","ring":"trial","body":"We still recommend the usage of HAL and HATEOAS.
\\nBut, depending on the resource structure, there are some pitfalls to be aware of:
\\nHypermedia As The Engine Of Application State or in short HATEOAS is a pattern that helps to organize dependencies and resources in a RESTful API. The basic idea of HATEOAS is that an API consumer do not have to know how dependencies of resources are connected and how to get them. A consumer must only be familiar with the basics of hypermedia.
\\nLet's assume we have a bank account and an action to deposit money on that account. Everything you need to know is that the account resource has an action for a deposit. The URL of that action can then fetched from the link attribute with the corresponding relation.
\\n<account>\\n <account_number>12345</account_number>\\n <balance currency="usd">-25.00</balance>\\n <link rel="deposit" href="https://bank.example.com/account/12345/deposit" />\\n</account>\\nBesides from HATEOAS there is an alternative implementation called Hypertext Application Language, in short HAL, which has much more features than the basic HATEOAS.
\\nWith HAL you are allowed to also define parametrized links, embedded resources and documentation relations (which are called curies). You can find the specification here.\\nhttp://stateless.co/hal_specification.html
\\nIf you want to link different api endpoints or resource locations in your API responses you should use this standard.
\\n"}],"position":[637,347]},{"id":"hotchocolate","release":"2023-02-23","title":"Hot Chocolate","ring":"assess","quadrant":"languages-and-frameworks","body":"Hot Chocolate is an open-source GraphQL server for .NET. \\nIt is compatible to many GraphQL clients and tools and is really easy to set up and use. We assess it in one of our\\nprojects as an alternative to GraphQL .NET.
\\n","featured":true,"flag":"default","tags":["coding"],"position":[144,201]},{"id":"hystrix","release":"2019-11-01","title":"Hystrix","ring":"assess","quadrant":"tools","body":"Hystrix is not longer actively maintained and some of its goals can now be handled with service meshs.
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"assess","body":"Hystrix is a very powerful library for handling failures, fallbacks and latency management within complex distributed environments. Netflix developed it and after years of experience, they are using it in almost each of their microservices. It evolved to a great library for handling resilience in complex architectures and covers solutions for the most common resilience patterns like:
\\nBeside from that purposes Hystrix also offers some helpful features like parallel and asynchronous execution, In-Request-Caching and other useful features for working with distributed systems.
\\nAnother useful component that you are able to use with Hystrix is his dashboard that give you the ability of real time monitoring of external dependencies and how they behave. Alerting is also able via the dashboard.
\\n"}],"position":[691,524]},{"id":"inner-source","release":"2022-03-28","title":"Inner Source","ring":"assess","quadrant":"methods-and-patterns","body":"Inner Source is a strategy to frictionless cross-team collaboration in software development inside an organization. \\nBased on Open Source methodologies, it provides an adaptable set of tools and practices for contributing to code \\ndeveloped by other teams. By fostering transparency and openness, it lowers the hurdle to get involved into \\ndecision-making throughout the corporation.
\\nCore principles of Inner Source include:
\\nAs AOE strives for a high involvement of every employee into decision processes and organizational development, Inner\\nSource seems an ideal fit to our company culture.
\\n","featured":true,"flag":"default","tags":["agile"],"position":[572,132]},{"id":"invision","release":"2018-03-01","title":"Invision","ring":"trial","quadrant":"tools","body":"Invision is an online tool used to work and collaborate on design and prototypes and to share them between clients and the team.
\\nWe use it in many projects now to present prototypes and designs and it helps in understanding the planned user experience.\\nAlso, we use this directly as a reference from the user stories to help the development teams in understanding and implementing the right frontend and backend functionalities.
\\n","featured":true,"flag":"default","tags":["ux/ui"],"position":[463,647]},{"id":"java","release":"2023-02-23","title":"Java","ring":"adopt","quadrant":"languages-and-frameworks","body":"Java is a versatile and widely-used programming language.
\\nIt is scalable and platform-independent, making it the ideal choice for businesses looking to streamline their\\noperations and reach a wider audience. With its broad library of tools, frameworks and modules, Java provides developers\\nwith the resources they need to create dynamic, feature-rich applications that can be easily integrated into existing\\nsystems. Additionally, Java has a large community of developers, ensuring that support and resources are available when\\nneeded.
\\nWith an extensive expertise at AOE we successfully run lots of Java projects in production. As it is very stable, has\\ngreat support from the open source community and lots of other big advantages, we often we use\\nSpring Boot combined with the strengths of java to develop web services that\\nfits the needs of our customers.
\\n","featured":true,"flag":"default","tags":["coding","backend"],"position":[269,335]},{"id":"jest","release":"2023-11-01","title":"Jest","ring":"adopt","quadrant":"tools","body":"Updated to "adopt".
\\n","featured":false,"flag":"changed","tags":["frontend","quality assurance"],"revisions":[{"release":"2017-03-01","ring":"assess","body":"Jest is a JavaScript testing framework by facebook to test JavaScript code and React applications / components.
\\nWe started using Jest (and watchmen) instead of Karma because it:
\\nIt is easy to set up.\\nAnd even if you have a running setup with Karma/Chai you can easily replace Karma with Jest.\\nWith a small workaround, Chai and Jest test matchers work fine together.
\\n"}],"position":[548,511]},{"id":"job-dsl","release":"2019-11-01","title":"Job DSL (Jenkins)","ring":"trial","quadrant":"tools","body":"The Job DSLis 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.
\\nThe 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.
\\nThe 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 feature - but still we see the need of Job DSL seeder jobs to seed the Jenkins pipeline jobs themselves and any additional jobs.
\\n","featured":false,"flag":"default","position":[591,562]},{"id":"k6","release":"2022-03-28","title":"K6","ring":"trial","quadrant":"tools","body":"At AOE, we need to have to run load tests against services.
\\nGrafana K6 is an open-source load testing tool with a quick and lightweight setup and provides
\\nallowing us to pinpoint performance issues.
\\n","featured":false,"flag":"default","revisions":[{"release":"2021-07-01","ring":"assess","body":"Load Testing is a testing process in which the performance of a software application or system is tested under a specific expected load.\\nIt determines how the system behaves while being accessed by multiple users simultaneously.\\nThe goals of Load Testing is to improve performance bottlenecks and to ensure stability under high traffic.\\nWhen done regularly, it provides confidence in the system, its reliability and performance, helps identify the bottlenecks in the system under heavy user stress scenarios before they happen in a production environment, and gives protection against poor user experience when using the system.
\\nK6 is a developer-centric, free and open-source load testing tool.\\nThe command line runner executes scripts written in JavaScript and allows to configure the execution time and the number of virtual users.\\nThe tool can be used for load testing and performance testing.\\nHowever, it can not be used to run tests that rely only on the browser, making it more suitable for testing of APIs.
\\n"}],"position":[534,583]},{"id":"kafka","release":"2021-07-01","title":"Kafka","ring":"trial","quadrant":"tools","body":""Apache Kafka is an open-source distributed event streaming platform used by thousands of companies for high-performance data pipelines, streaming analytics, data integration, and mission-critical applications." (See http://kafka.apache.org/)
\\nIn comparison with other messaging solutions (such as RabbitMQ - Apacha Kafka persist the messages (instead of routing them to subscribers). It is written in Scala and Java, and follows the idea of a “distributed log” where messages are appended to the end (like in a log) - and that log is persisted to disk. Clients can choose where they begin reading from that log - often Kafka Streams is used for this.
\\nWe are using Kafka in data heavy projects - for example in data analytics use cases.
\\n","featured":false,"flag":"default","position":[559,606]},{"id":"keycloak","release":"2018-03-01","title":"Keycloak","ring":"adopt","quadrant":"tools","body":"Most distributed systems still face a growing demand for user management, authentication, authorization and Single sign-on. In light of a growing security demand and specialization, the Open Source project JBoss Keycloak is a perfect match.
\\nKeycloak has been a growing project from the outset and has a strong community. Keycloak is based on standards such as OAuth2, OIDC and SAML2. Securing a distributed system is supported by adapters, which are provided by Keycloak developers for different technology stacks. If there is no adapter for your technology stack, an integration on the protocol level with a library is simple. Many configurable features require no coding in the integrated projects. The required configuration is managed via code and promoted as usual.
\\nWe 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. In addition, Keycloak is part of the AOE infrastructure and helps in securing the various services to support employees and customers.
\\n","featured":true,"flag":"default","tags":["security"],"revisions":[{"release":"2017-03-01","ring":"trial","body":"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.
\\nAs 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.
\\nKeycloak 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.
\\nBy 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.
\\nKeycloak normally runs standalone and can use various database products. A docker image is available to start in a containerized environment.
\\nKeycloak 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.
\\n"}],"position":[467,569]},{"id":"kotlin","release":"2019-11-01","title":"Kotlin","ring":"adopt","quadrant":"languages-and-frameworks","body":"Kotlin is used successfully in production by multiple teams.
\\nKotlin is 100% interoperable with Java. It means the code can live side-by-side in one code base and interact.\\nFrom the beginning it was designed with practical thought in mind. So the IDE Support in IntelliJ is really great.
\\nThe Spring Framework Developer put a lot of effort that Springs play well together with Kotlin.
\\nWith its concise syntax, null safety, \\nDue to its explicit type system, this language is also great replacement for Groovy usage with Gradle.
\\n","featured":true,"flag":"default","tags":["coding"],"position":[233,329]},{"id":"kubernetes-operators","release":"2023-11-01","title":"Kubernetes Operators","ring":"trial","quadrant":"methods-and-patterns","body":"We've faded out Kubernetes Operators as a standalone recommendation because they are such a central part of Kubernetes that their use appears self-evident.
\\n","featured":false,"flag":"changed","tags":["devops"],"revisions":[{"release":"2021-07-01","ring":"trial","body":"The Kubernetes Operators allow to manage application configuration within Kubernetes through custom resources.\\nThe operators are implemented as Kubernetes controllers and all interaction happens through the Kubernetes API.\\nThis allows to manage application deployment and configuration with the same toolset, it also allows to create another abstraction layer to describe the desired application state and let the operator decide how this state should be reached.
\\nKubernetes Operators are widely available for many community projects.\\nThese can be shared and found on operatorhub.io.\\nImplementing custom operators is greatly simplified through the Operators SDK which is used as base for many existing implementations.
\\nWe use operators in most projects and prefer them to custom management code.\\nWe encourage teams to try the existing community operators for e.g. observability and operations tasks.
\\n"}],"position":[456,161]},{"id":"lighthouse-ci","release":"2022-03-28","title":"Lighthouse CI","ring":"assess","quadrant":"tools","body":"At AOE, we want to keep a permanent eye on the metrics of the Web Vitals for our projects.
\\nLighthouse CI is a collection of free tools that facilitate the use of Lighthouse for performance monitoring. With Lighthouse CI we get a history of evaluation results and can compare them over time. It is also possible to set performance budgets to ensure that a website's performance does not deteriorate through regression.
\\nAlthough performance monitoring is the most common use case for Lighthouse CI, other aspects of Lighthouse can also be monitored, such as SEO or accessibility. Thus, the use of Lighthouse CI can help ensure an overall good user experience.
\\n","featured":true,"flag":"default","tags":["ci/cd","frontend"],"position":[625,590]},{"id":"micro-frontends","release":"2023-11-01","title":"Micro Frontends","ring":"adopt","quadrant":"methods-and-patterns","body":"While Micro Frontends have gained significant attention as a software architectural approach that mirrors the principles of microservices at the frontend level, it's crucial to recognize that they are not a universal remedy for all frontend development challenges. The decision to implement Micro Frontends should be made thoughtfully, taking into account the project's specific requirements.
\\nUltimately, the decision of whether to choose Micro Frontends or other architectural approaches should align with the project's goals, team expertise, and scalability requirements. Individual teams working on well-defined, independently deployable features of a large application may benefit from using Micro Frontends. However, for smaller applications or teams with limited resources, a traditional monolithic approach might be more efficient.
\\n","featured":true,"flag":"changed","tags":["architecture","frontend"],"revisions":[{"release":"2021-07-01","ring":"adopt","body":"The Micro Frontends approach continues to prove to be a valuable pattern for large-scale systems developed by several teams.\\nTherefore, we moved this pattern to "adopt".
\\nWe use page composing as one implementation of this pattern.
\\n"},{"release":"2019-11-01","ring":"trial","body":"When deciding on a system architecture we are always striving for technology neutralism.\\nThis is to allow us to stay flexible with future decisions.\\nMicro Frontends can be a tool to support us with this goal.\\nWe favor protocols and methods, such as plain HTML and HTTP, over specific technologies when designing Micro Frontends.
\\nSince Micro Frontends have proven to allow use move fast and agile, we moved this pattern to "trial".
\\n"},{"release":"2018-03-01","ring":"assess","body":"We see many benefits in Microservices – especially in large teams – but often this architecture \\ndoes not involve the user interface. Instead, you might end up maintaining a frontend monolith. With Micro Frontends \\nyou enable your frontend developers to gain the same benefits that we have grown accustomed to in a Microservice architecture: \\nDecoupled components, which are developed and deployed by independent teams. But what sounds reasonable comes with \\nchallenges. Integrating different Frontends on the client- or server-side can be tricky, as well as keeping the overall \\nUser Experience consistent.
\\nDespite the challenges, Micro Frontends help us to develop large applications across multiple teams. Developers can\\nwork more independently without having too much trouble maintaining a large codebase. Being able to update or \\nreplace Frontend libraries in some parts of the application is yet another benefit in the fast-moving world of \\nfrontend development.
\\n"}],"position":[435,226]},{"id":"microservices","release":"2023-11-01","title":"Microservices","ring":"adopt","quadrant":"methods-and-patterns","body":"We continue to belief in the microservices concept and its related patterns and best practices. However, it's worth mentioning that we had to learn some lessons when it came to resilient thinking and deployment-related dependencies between microservices.
\\nWe feel that our microservice-based applications are more robust than monolithic ones have been. Thanks to the \\nsplit of the overall complexity into multiple services, new employees or team members are becoming productive within days or a few weeks.
\\nIn order to get microservices right and to benefit from the advantages, there is a lot more required.\\nThe following "pyramid of need" for microservices shows this:\\n![\\"microservices](\\"/digital_xp_techradar/images/microservices-pyramid.png\\")
Microservices as an architecture style is getting very popular recently. At AOE, more and more teams are adding microservices to their existing application architecture or designing applications with microservices.
\\nWe also like the term "self-contained systems" instead of microservices.
\\nThe benefits we see are:
\\nRelated patterns are Strategic Domain Driven Design as an approach to wisely cut your architecture according to useful bounded contexts and decide on the relevant communication and "translation" between the services.\\nIn case you are looking for a small visualisation tool for your microservice architecture you might find vistecture useful.
\\nAlso Resilience thinking is especially important when designing an application as a suite of microservices.
\\n"}],"position":[450,256]},{"id":"mlops","release":"2023-11-01","title":"MLOps","ring":"assess","quadrant":"methods-and-patterns","body":"After spending some time diving into the world of data science and machine learning we're realizing our existing DevOps best practices aren't a perfect fit for the specific workflows we're seeing here.\\nData science is not only about code but also all about managing large datasets and models.\\nData is being analyzed, models are being trained in many iterations and then software needs to be deployed that does the actual prediction/inference.\\nAnd this circle (see: CRISP-DM) will repeat over and over again during the development phase and after the first production release.\\n"MLOps" extends the DevOps best practices in order to cover these new scenarios specific to machine learning workflows.
\\nDVC helps dealing with large data sets and models by connecting external storage to your Git repositories and CML helps integrating the CI/CD into your GitHub or GitLab workflows. \\nSince we're already using Kubernetes extensively we're exploring Kubeflow for running the full machine learning workflow on Kubernetes clusters.
\\n","featured":false,"flag":"changed","tags":["devops"],"position":[511,96]},{"id":"mob-programming","release":"2022-03-28","title":"Mob Programming","ring":"assess","quadrant":"methods-and-patterns","body":"While practising pair programming for several years now at AOE, we have started using\\nremote mob programming extensively when \\nswitching to remote work during the COVID-19 pandemic.
\\nMob programming brings the driver/navigator pattern to another level by adding a group\\nof navigators into the game. With the whole development team focussing on a single\\ntopic, a lot of common understanding and shared knowledge are being generated during\\neach session as everyone is involved in the development process. The result will be\\nless controversial code reviews (which might even be completely omitted) and the\\nevolution of a team coding style in favor of individual ways of problem-solving.
\\nIn practice, we found the Git-based mob\\nas an easy-to-use tool for remote mob programming. It provides a fast and simple way\\nfor initiating a mob session, handing over changes to the next person and committing\\nthe outcome.
\\n","featured":true,"flag":"default","tags":["agile","coding"],"position":[633,197]},{"id":"monorepo","release":"2023-11-01","title":"Monorepo","ring":"adopt","quadrant":"methods-and-patterns","body":"Adopting a monorepo approach for our React and Next.js-based projects offers several benefits, although it may not be\\nthe best fit for every project.
\\nHowever, it is important to note that monorepos are not a one-size-fits-all solution. They can introduce complexity,\\nespecially in very large projects, and may not be suitable for all team sizes or development workflows. The decision to\\nadopt a monorepo should be based on a careful consideration of your project's specific requirements, team size, and\\ndevelopment practices.
\\n","featured":true,"flag":"changed","tags":["coding"],"revisions":[{"release":"2022-03-28","ring":"trial","body":"A monorepo is a single repository containing multiple projects and shared libraries with their relationships.
\\nAt AOE, we are using a monorepo that is home to both our React and Next.js based frontends and \\nour Go / Flamingo based backends, \\nas well as shared libraries we use in all of our projects.
\\nThe main benefits in that approach are:
\\nIf you take the monorepo approach, of course you want to have a tool to manage it. There are a lot of them on the market \\nand at AOE we have decided to go with Nx.
\\n"}],"position":[478,383]},{"id":"nats","release":"2023-11-01","title":"NATS","ring":"assess","quadrant":"tools","body":"NATS is a cloud native messaging and stream-data system for modern distributed software systems.\\nTwo design-goals were simplicity and performance.\\nThese are adopted by selecting golang for the server implementation and reducing the memory footprint for both: server- and client-side.\\nThe server-side provides simple and efficient horizontal scaling (e.g. deploying it inside Kubernetes) and the small client-footprint allows us to use it in embedded-systems, edge-computing and IoT devices e.g. for command and controll use-cases.\\nAlso, the long list of existing integrations and the plugin-systems bring a great flexibility.
\\n","featured":false,"flag":"changed","tags":["architecture","devops"],"position":[714,461]},{"id":"next-js","release":"2023-11-01","title":"Next.js","ring":"adopt","quadrant":"languages-and-frameworks","body":"We are convinced that Next.js is one of the go-to frameworks for React, and we're excited about the features that version 13 has brought with it. During the Next.js Conf 2022, the team announced some exciting adaptations in this release, but the most interesting one is the new "app" router. In collaboration with the React team, this new routing architecture brings some of the newest and most promising features of React 18 to life.
\\nWhen using the app router, every component, by default, becomes a React Server Component, making it one of the first real integrations of this pattern in a framework. The goal is to build complex interfaces while minimizing the amount of JavaScript shipped to the client. Another exciting feature is Streaming, which allows incremental transfer of parts of the UI to the client as they become ready. For example, immediately showing some fallback UI until an asynchronous action is completed, and then streaming the final UI to the client. With the app router, it's also possible to easily create shared layouts that preserve state during navigation and remain interactive.
\\nThe good thing is that this new architecture can coexist alongside the old page router, giving us the flexibility to incrementally adapt to the new features in existing projects.
\\n","featured":true,"flag":"changed","tags":["coding","frontend"],"revisions":[{"release":"2021-07-01","ring":"adopt","body":"Next.js claims itself as the React framework for production.\\nIt comes with first-class developer experience and many features for example: hybrid static & server-side rendering, TypeScript support, image optimization, code splitting & much more.
\\nWe at AOE are already using Next.js for some big projects.\\nThe main reason for that is the modern stack (React with TypeScript) and the possibility to render on the server (static pre-rendering or dynamic SSR) to be able to get crawled by search engines and stay SEO relevant.
\\n"},{"release":"2019-11-01","ring":"trial","body":"Next.js is a JavaScript and React based framework which makes use of server side rendering.
\\n"}],"position":[291,358]},{"id":"nocode-lowcode","release":"2022-03-28","title":"No-Code / Low-Code","ring":"assess","quadrant":"methods-and-patterns","body":"No-code or low-code refers to tools that allow application software to be created via graphical user interfaces and\\nconfiguration - instead of (classic) text-based programming.\\nLow-code platforms additionally supports certain scripting possibilities.
\\nNo-code and low-code platforms have raised a lot of funding and the ecosystem is growing fast. There are more than 400\\nplatforms listed on software selection websites like g2.\\nThe promise of this ecosystem sounds logical: there is a growing demand for digital products and solutions in all\\nsectors - and skilled teams of developers are scarce.\\nThat's why platforms\\nlike bubble.io, airtable,\\nappsheet, bryter, ninox\\nand co promise to build digital products faster and better.
\\nAnd the platforms have developed and the ecosystem is emerging. AI technics are being used to improve the creation\\nprocess and modern low-code platforms also come with built-in release and operations support. We have used some low-code\\nplatforms for internal tools, for example to help organise events or onboarding activities.
\\nHere are our thoughts on this:
\\nWe see opportunities to improve communication and collaboration between developers on such platforms and non-technical\\nprofessionals (domain experts), as they can collaborate on the platform directly during the process of creating the\\ndigital product.
\\nIf the use case fits into the sweet spot of the platform, the results are very fast and surprising.
\\nThere is a logical trade-off between simplicity and flexibility: platforms with a high level of abstraction and a low\\nlearning curve can deliver good results very quickly. However, if you have requirements that do not fit into the\\n"standard" of the platform, it becomes difficult to customise. On the other hand, platforms that allow a lot of\\nconfiguration and scripting come with a higher learning curve. And in some respects it may end being similar to using\\na programming framework.
\\nOperating costs can become a relevant factor - especially if you pay for high performance and higher utilisation.
\\nYou have to realise that with complex applications there is much more to do than "just" writing code. Test\\narchitecture, api design, integrations, careful design of the solution, proper testing, CI/CD strategy etc. So\\nthere is still a need for skilled (development) teams to do this work.
\\nThinking about the different aspects, we will not consider low-code platforms as the core technology in complex software\\ndevelopment projects - but we think that even in larger IT projects or organisations there are valid use cases or\\ncertain "bounded contexts" where using a low-code platform is a proper choice and helps to deliver results faster.
\\n","featured":true,"flag":"default","tags":["coding"],"position":[458,107]},{"id":"node-js","release":"2021-07-01","title":"node.js","ring":"adopt","quadrant":"languages-and-frameworks","body":"Node.js is a no- browser JavaScript execution runtime. Its basis is Google's V8 engine. Node is event-driven and follows a non-blocking I/O model.
\\nIt’s a good choice for restful APIs, realtime purposes or situations where many concurrent connections are expected, where each connection has a lightweight memory footprint.
\\nNode allows separation of concerns by using its package manager npm, which is also the largest ecosystem of Open Source libraries (modules).
\\nModules are added as dependencies and offer a wide range of functionalities in a range from simple helper functions to mature web frameworks such as express.js.
\\nMany PaaS providers (AWS, Google Cloud Platform, Azure) support node, including deployment and monitoring services out of the box for scalable stateless applications.
\\nAt AOE, we successfully use node.js-based applications for smaller services or internal tools such dashboards.
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"Node.js is a no- browser JavaScript execution runtime. Its basis is Google's V8 engine. Node is event-driven and follows a non-blocking I/O model.
\\nIt’s a good choice for restful APIs, realtime purposes or situations where many concurrent connections are expected, where each connection has a lightweight memory footprint.
\\nNode allows separation of concerns by using its package manager npm, which is also the largest ecosystem of Open Source libraries (modules).
\\nModules are added as dependencies and offer a wide range of functionalities in a range from simple helper functions to mature web frameworks such as express.js.
\\nMany PaaS providers (AWS, Google Cloud Platform, Azure) support node, including deployment and monitoring services out of the box for scalable stateless applications.
\\nAt AOE, we successfully use node.js-based applications for smaller services or internal tools such dashboards.
\\n"}],"position":[346,364]},{"id":"nosql","release":"2019-11-01","title":"NoSQL","ring":"trial","quadrant":"methods-and-patterns","body":"NoSQL technologies are established solutions that allows for scaling and handling big datasets.\\nWe use Technologies like Redis, Elasticsearch and Neo4J but there are many others that are powering the NoSQL space.
\\n","featured":false,"flag":"default","position":[541,209]},{"id":"npm","release":"2019-11-01","title":"NPM","ring":"adopt","quadrant":"tools","body":"npm 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.
\\nInstead of other package managers such as bower, you have to write your packages as modules. This unifies the way you have to use, test and, of course, understand dependencies.
\\nnpm 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.
\\nWith shrinkwrap you have a robust tool to lock down and manage the versions of your dependencies - following the Pin (external) dependencies approach.
\\nFor each package you have to classify your dependencies:
\\nWith scripts you get support for the most common build lifecycle steps, e.g. build, start, test ...
\\nOther useful features:
\\nNx is now a daily used tool in our Monorepo setup. It takes care of everything from app creation to \\nrunning development environments and tests to code generation.
\\n","featured":false,"flag":"changed","tags":["coding","ci/cd"],"revisions":[{"release":"2021-07-01","ring":"assess","body":"Nx is a suite of powerful, extensible dev tools to help you architect, test, and build at any scale.\\nIt is mainly applicable in the environment of React, Angular and Node.js and tries to simplify and streamline the work in a mono repo.
\\nAt AOE, we are currently taking our first steps with NX in a mono repo that is home to both our React and Next.js based frontend and our Go / Flamingo based backend.
\\nThe integration with the Node.js components (React, Next.js, Cypress) works smoothly and brings the expected benefits such as faster build times through intelligent caching.\\nSupport for Go is currently only rudimentary, which is why NX still has to prove itself in this area.
\\nEspecially in the environment of Node.js in combination with the use of a mono repo, NX is worth a look.
\\n"}],"position":[454,482]},{"id":"open-api","release":"2019-11-01","title":"Open API","ring":"adopt","quadrant":"tools","body":"The OpenAPI Specification is becoming a broadly adopted industry standard for describing modern REST APIs.\\nOther initiatives like RAML have joined the OpenAPI Initiative.
\\nOpenAPI v2 version is basically the former Swagger - and Swagger provides useful tools for OpenAPI like the online editor and viewer http://editor.swagger.io/\\nWe have also found that this version currently have a good tool support across languages, so you will find API client and server generation tools for a lot of languages, which makes it quite easy to connect to an API that is described in OpenAPI standard.
\\nOpenAPI v3
\\nOpenAPI v3 adds more features to the specification - for example the ability to describe APIs supporting request/callback pattern.
\\nThere is a very good api designer https://www.apicur.io/ and a good mock generator http://microcks.github.io/index.html
\\nThe general tool support is excellent. See https://openapi.tools/
\\n","featured":true,"flag":"default","tags":["architecture"],"position":[489,417]},{"id":"open-digital-architecture","release":"2023-02-23","title":"Open Digital Architecture","ring":"assess","quadrant":"methods-and-patterns","body":"TM Forum Open Digital Architecture (ODA) provides architectural blueprints for\\ncommunication service providers (CSPs), based on modern patterns and technologies such as microservices or\\ncloud-native solutions. It offers a number of benefits, including:
\\nAs a TM Forum member, AOE has signed both the Open API and\\nthe ODA Manifesto and is\\nstrongly committed to the values and visions behind these open standards.
\\n","featured":true,"flag":"default","tags":["architecture"],"position":[668,274]},{"id":"open-policy-agent","release":"2023-11-01","title":"Open Policy Agent","ring":"assess","quadrant":"tools","body":"We have been transitioning away from using Open Policy Agent at AOE. For alternative solutions, please refer to Policy as Code.
\\n","featured":false,"flag":"changed","tags":["security","architecture"],"revisions":[{"release":"2021-07-01","ring":"assess","body":"Open Policy Agent (OPA) is a framework which allows modelling and evaluating policy access services.\\nThe underlying expression language Rego is purpose-built for the policy evaluations and implements the Policy As Code pattern.
\\nThis allows to decouple policy from the service's code, so you can release, and review policies separately.
\\nThe benefits of using OPA and Rego comes from the various available integrations into other cloud-native services and tools.\\nIt can be used with the "Kubernetes Admission Controller", to authorize decisions within a Service Mesh or as part of infrastructure evaluation pipelines.
\\nWe 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.
\\nWe have also evaluated OPA as part of permission management in distributed architectures.\\nThe concept promises to provide value especially for distributed enterprise architectures.
\\n"}],"position":[686,488]},{"id":"oro-platform","release":"2018-03-01","title":"Oro Platform","ring":"assess","quadrant":"tools","body":"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.
\\nOne 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.
\\nAs 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.
\\nOn the other hand, OroPlatform gives you a good head start 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 or OroCRM use OroPlatform with success.
\\nSince the project is still young, the future development and improvements need to be watched. We classified the Framework as Assess.
\\n","featured":false,"flag":"default","position":[555,671]},{"id":"pact","release":"2021-07-01","title":"PACT","ring":"trial","quadrant":"tools","body":"At AOE we continue to use PACT but would like to use it even more.\\nIt therefore remains in the trial ring but was faded out from the overview page.
\\n","featured":false,"flag":"default","revisions":[{"release":"2018-03-01","ring":"trial","body":"PACT (http://pact.io/) is a family of frameworks that provides support for Consumer Driven Contract testing across different languages and frameworks.
\\nConsumer Driven Contract testing is a pattern for testing interfaces/boundaries between services.
\\nIt allows "consumers" to run tests against a defined Mock and record the defined interactions (=PACT).\\nIt puts "providers" in the position to run the PACT tests inside their Continuous Integration Pipelines, so that the provider knows if he might break any consumers.
\\nThis approach makes sense in organisations where teams collaborate more closely (See Strategic Domain Driven Design ), e.g. to build Microservice oriented architectures
\\nConsumer Driven Contract Testing and how it can be conducted with PACT is documented very nicely on the official PACT website: https://docs.pact.io/.
\\n"}],"position":[625,513]},{"id":"page-composing","release":"2021-07-01","title":"Page Composing","ring":"trial","quadrant":"methods-and-patterns","body":"Page composing is a way to aggregate multiple independent page fragments into one combined web page.\\nAs an implementation of Micro Frontends, this approach supports to deploy and run services agnostic to the technologies used per team.
\\nThe concept builds upon the fact that all involved services deliver valid HTML as their output.\\nOur solution is a small application which takes care of gathering the page fragments from all services and composing each into a defined HTML template.\\nA configuration layer further allows controlling which fragment gets pulled from the serving instance.
\\nWith 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.
\\nMartin Fowler et al. described this as Server-side template composition.
\\n","featured":true,"flag":"default","tags":["architecture"],"position":[477,156]},{"id":"pair-working","release":"2018-03-01","title":"Pair Working","ring":"trial","quadrant":"methods-and-patterns","body":"We summarized the practices of pair programming and administrating as pair working.
\\nDerived as a practice from eXtreme Programming (XP), pair programming is a method/pattern that aims for fine-scaled feedback within a team.
\\nAt AOE, some developers and operators work in pairs, not constantly, but from time to time. Most teams have positive experiences using this method, but not all teams tried the by-the-book-approach (driver and navigator principle). Especially for non-trivial tasks, pair working results in rapid knowledge exchange and better results with fewer bugs. We encourage the teams to try this approach more often.
\\n","featured":false,"flag":"default","position":[632,289]},{"id":"phan","release":"2018-03-01","title":"phan","ring":"assess","quadrant":"tools","body":"Phan is a static code analyzer for PHP7, which is very fast, since it uses the PHP 7 AST (abstract syntax tree). Phan basically offers some of the safety that otherwise only compiled type-safe languages have - such as checking function references and return types.
\\nWe expect at least the following benefits:
\\nWe 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.
\\n","featured":false,"flag":"default","position":[595,626]},{"id":"php7-over-php5","release":"2018-03-01","title":"PHP7 over PHP5","ring":"adopt","quadrant":"languages-and-frameworks","body":"PHP 5 has been around for a very long time, and can be considered as the PHP version that defined where PHP wants to go in the future.\\nWith proper OOP, support for clojures and a steadily improving type system, it has become a very mature language.\\nHowever, in the past 3 years, Facebook introduced HHVM, which became a major influence on PHP 7 and eventually brought a lot of improvements not only for the execution speed, but also with proper type hints and other features.
\\nHere at AOE, we have numerous PHP projects, and we often kept it backwards-compatible to make sure that it will run on older systems. This is comparable to the procedure most frameworks (Magento, OroPlatform and derived projects) use.
\\nNow, PHP 5 has reached its end--of-life, and it is time to discontinue the backwards-compatibility in favor of better and more stable applications.\\nEven though we can use the PHP 7 runtime while being PHP 5-compatible, it is not considered good practice anymore, as we can now rely on the PHP 7 features and use all of its advantages.
\\nOne of the major points PHP 7 supports is proper type hinting and return types (apart from PhpDocs), which makes static analysis much easier and can improve the overall code quality significantly.
\\n","featured":false,"flag":"default","position":[360,345]},{"id":"pin-external-dependencies","release":"2021-07-01","title":"Pin external dependencies","ring":"adopt","quadrant":"methods-and-patterns","body":"A lot of applications have dependencies on other modules or components. We have\\nused different approaches regarding how and when these dependencies are resolved\\nand have agreed on using a method we call "Pin (External) dependencies".
\\nThis is especially relevant for script languages, where the dependency\\nmanagement references the code and not immutable prebuild binaries - and\\ntherefore resolves the complete transient dependencies on the fly.
\\nMost of these package- or dependency management solutions support two artefacts:
\\nWe suggest the following:
\\nFor updating of dependencies define a process in the team. This can either be\\ndone on the dev-system or in a separate automated CI job - both resulting in\\nupdated dependency definitions in the applications VCS.
\\n","featured":false,"flag":"default","position":[563,364]},{"id":"pipeline-as-code","release":"2023-11-01","title":"Pipeline as Code","ring":"adopt","quadrant":"methods-and-patterns","body":"In the past years many tools have evolved and especially Gitlab CI,\\nGitHub Actions and AWS CodeDeploy\\nmatured or became available and widely used across many teams.
\\nContinuous Integration and Delivery is an important part in every project. Pipelines which are maintained as code, can\\nnow be handled like most other parts of your software. The pipeline configuration can run through lint checks, or a test\\nsuite before the configuration is shared across teams in your organisation.
\\nUsing container based builds is now\\nalso the de facto standard. Combining these two techniques enables running isolated builds in an easily reproducible\\nenvironment so teams can get quick feedback on every change.
\\n","featured":false,"flag":"changed","tags":["devops"],"revisions":[{"release":"2018-03-01","ring":"adopt","body":"We moved this pattern to adopt, because it is used by nearly every team and project now and is an important part of our automation.
\\nFor Jenkins, we often use a mix of Job DSL and Jenkins Pipelines and recently also used GitLab Pipelines.
\\n"},{"release":"2017-03-01","ring":"assess","body":"Continuous Integration and Delivery is a critical part of our development and deployment process at AOE. Using Jenkins for many years the "instructions" how to build, test and deploy applications were scattered between many custom scripts and the pipeline was often maintained by manual maintenance of Jenkins jobs. Soon, we realized that we need a more native way to express the full CI/CD pipeline process in code and manage it in version control.
\\nBeing an important part of each project, the pipeline configuration should be managed as code and rolled out automatically - this also allows us to manage the pipeline itself applying the same standards that apply to application code.
\\nWhile some teams started using Jenkins' JobDSL plugin, others explored the new Jenkins Pipeline - in both ways, the build artifacts should be published to an artifact repository such as Artifactory.
\\n"}],"position":[502,262]},{"id":"plant-uml","release":"2021-07-01","title":"Plant UML","ring":"adopt","quadrant":"tools","body":"PlantUML is an open source project that allows to create UML diagrams in a text-based and declarative way.
\\nSince it is integrated in tools like Confluence, IntelliJ and GitLab we use it a lot to quickly document results of software design sessions.
\\nAnother similar tools that use just plain JavaScript to render the diagrams is mermaid
\\n","featured":false,"flag":"default","revisions":[{"release":"2019-11-01","ring":"trial","body":"PlantUML is an open source project that allows to create UML diagrams in a text-based and declarative way.
\\nSince it is integrated in tools like Confluence, IntelliJ and GitLab we use it a lot to quickly document results of software design sessions.
\\nAnother similar tools that use just plain JavaScript to render the diagrams is mermaid
\\n"}],"position":[425,468]},{"id":"play-framework","release":"2019-11-01","title":"Play Framework","ring":"adopt","quadrant":"languages-and-frameworks","body":"The Play Framework is a lightweight (web)application framework for Java and Scala programmers.
\\nA developer can choose from different modules to include necessary functionality such s accessing http resources, databases, and so on. As a consequence, the developer can choose, and is not distracted by or clobbered with irrelevant things. This approach is considered as minimalistic, but it is easy to include necessary functionality.
\\nRegarding the architecture, Play is stateless and built on Akka. As a consequence, Play applications have much lower resource consumption regarding CPU und memory and can scale easily. Play manages concurrency without binding a request to a thread until the response is ready.
\\nWith the use of "Futures" in your code you can turn synchronous tasks (such as IO or API call to another service) into asynchronous and you can build non-blocking applications. It is recommended to understand the principles Play uses to achieve performance and scalability.
\\nPlay can act as backend service delivering JSON, for example. For building web applications. The Twirl template engine enables server-side rendering of HTML pages. These HTML pages can include CSS and JavaScript parts of your own choice.
\\n","featured":false,"flag":"default","position":[331,312]},{"id":"playwright","release":"2023-11-01","title":"Playwright","ring":"adopt","quadrant":"tools","body":"Playwright is a versatile tool for creating reliable end-to-end tests across different browsers, platforms, and languages. It's easy to get started with and comes with a wide range of built-in features. Playwright works on Windows, macOS, and Linux and seamlessly integrates with popular testing frameworks like Jest, Mocha, and Jasmine.
\\nPlaywright's configuration offers valuable options, including native mobile emulation for Chrome on Android and Safari on iOS. It can also be extended using BDD tools like Cucumber or SpecFlow, allowing non-technical contributors to collaborate.
\\nPlaywright tests are robust, as they wait for elements before taking actions to eliminate timeouts, a common cause of unreliable tests.
\\nIn contrast to Cypress, Playwright excels at interacting with different origins and multiple tabs in tests. You can create scenarios with distinct contexts to handle various users within a test, saving authentication states for reuse in other tests, thus eliminating repetitive log-in operations.
\\nDeveloped and maintained by Microsoft, Playwright benefits from extensions for Visual Studio Code, streamlining test development, execution, and debugging.
\\nIn summary, Playwright is a versatile testing tool offering compatibility, integration with testing frameworks, and advanced features like multi-origin interactions. Its robustness, ability to handle diverse scenarios, and close ties with Visual Studio Code make it an exceptional choice for end-to-end testing.
\\n","featured":true,"flag":"changed","tags":["coding","frontend","quality assurance"],"revisions":[{"release":"2023-02-23","ring":"trial","body":"Playwright is a cross browser/platform/language tool to write reliable end-to-end tests. It's\\neasy to get started with and offers a broad variety of functionalities out of the box. Playwright supports Windows,\\nmacOS and Linux and works with the most popular testing frameworks such as Jest, Mocha and Jasmine.\\nThe playwright configuration offers plenty of helpful options, for instance native mobile emulation of Chrome for\\nAndroid and Safari for iOS. If needed playwright can be extended by BDD tools like Cucumber or SpecFlow to enable\\nnon-technical contributors to collaborate.
\\nPlaywright test are resilient. It waits for elements before performing any actions which eliminates the need for\\ntimeouts - the primary cause of flaky tests.
\\nOther than Cypress Playwright can interact with different origins and multiple tabs. Also, you can create scenarios with\\ndifferent contexts to handle multiple users within one test. Contexts allow saving an authentication state to reuse it\\nin other tests. By isolating tests within a separate browser context for each test, the tests are fully independent,\\nalthough reusing an authentication state. This prevents you from performing repetitive log-in operations in each test.
\\nAs Playwright is developed and maintained by Microsoft there are some great extensions for Visual Studio Code to\\ndevelop, run and debug tests.
\\n"},{"release":"2022-03-28","ring":"assess","body":"Playwright is a cross browser/platform/language tool to write reliable end-to-end tests. It waits for elements before performing any actions which eliminates the need for timeouts - the primary cause of flaky tests.
\\n"}],"position":[521,455]},{"id":"pnpm","release":"2023-11-01","title":"pnpm","ring":"adopt","quadrant":"tools","body":"pnpm is an alternative tool to manage your frontend dependencies. Unlike yarn 1 it manages\\nall packages in a central place and creates symbolic links only inside the npm_modules of a project. This results in\\nconsiderably less usage of disk space and reduces build-times, when a package is already available.
\\nAdditionally, a cache server can be setup and used during pipeline builds to decrease network traffic and build times.
\\n","featured":false,"flag":"changed","tags":["coding","frontend"],"revisions":[{"release":"2023-02-23","ring":"assess","body":"pnpm is an alternative tool to manage your frontend dependencies. Unlike yarn 1 it manages\\nall packages in a central place and creates symbolic links only inside the npm_modules of a project. This results in\\nconsiderably less usage of disk space and reduces build-times, when a package is already available.
\\nAdditionally, a cache server can be setup and used during pipeline builds to decrease network traffic and build times.
\\n"}],"position":[571,468]},{"id":"policy-as-code","release":"2023-02-23","title":"Policy as Code","ring":"trial","quadrant":"methods-and-patterns","body":"With the rise of cloud infrastructure and DevOps practices, traditional methods of policy enforcement such as manual\\nreviews and audits are no longer sufficient. By using code to express policies for the entire infrastructure and\\napplication stack, automated compliance checks become a natural part of the software development lifecycle,\\ne.g. via integration into a projects' CI/CD pipeline and could even prevent a configuration change or deployment\\nif a critical issue was found.
\\nOne of the key benefits of Policy as Code is the ability to catch potential issues before they become risks. For\\nexample, a policy could be defined to ensure that all S3 buckets are encrypted, or that all EC2 instances have a\\nspecific set of tags.
\\nThere are a number of tools and frameworks available for implementing Policy as Code. At AOE, we are mainly relying on\\nCheckov, Kyverno and AWS Config\\nat the time of writing. Each tool provides a way to define policies in code and then automate policy enforcement.\\nThey also provide visibility into the compliance status of infrastructure and application configurations.
\\nBy defining policies as code, development teams can ensure that policies are version-controlled, easily auditable,\\nand consistent across all environments.
\\n","featured":true,"flag":"default","tags":["devops","ci/cd"],"position":[616,344]},{"id":"ports-and-adapters","release":"2019-11-01","title":"Ports and Adapters","ring":"adopt","quadrant":"methods-and-patterns","body":"Updated to "adopt"
\\n","featured":true,"flag":"default","tags":["architecture"],"revisions":[{"release":"2018-03-01","ring":"trial","body":"Ports and Adapters is an architecture or layering approach for software design. As with other layering approaches, it separates different concerns in different layers, where dependencies are only allowed from the outside to the inside.
\\nWe use "ports and adapters" with success for (larger) applications, which contain certain business logic and/or provide several ways to access the services.\\nWe often use the approach hand-in-hand with Domain Driven Design. In comparison with other layering patterns (e.g. layered architecture) it allows you to have a true technology-free core (domain) model. Why? Because, with the concept of "secondary ports" (=interfaces), it inverts the control and allows outer layers to provide adapters (=implementations of the defined interface).\\nIt also defines clear boundaries regarding where to put what logic of your application.
\\nYou can find out more about the details and its origins in well-known blog posts such as The Clean Architecture or Hexagonal architecture
\\nIn short, here is how we often layer such applications:
\\nThese layers belong to every bounded context (modules) inside the application.
\\nAre you searching for a potential timeless architecture for your critical application? Try implementing a potent technology-free domain model in the core layer and use ports and adapters to layer your application.
\\n"}],"position":[545,335]},{"id":"postcss","release":"2022-03-28","title":"PostCSS","ring":"adopt","quadrant":"tools","body":"PostCSS is a tool for transforming stylesheets with JavaScript plugins. It comes with a parser that reads your CSS file into an AST, pipes it through the loaded plugins and finally stringifies it back into a (transformed) CSS output file.
\\nWe at AOE love PostCSS because it gives us the power to use CSS Modules, which finally ends the curse of global CSS.
\\nIt also has a huge list of more than 350 other available plugins.\\nSure, not all of them are useful, but the sheer number of plugins shows how easy it is to write your own plugin for it.\\nIn fact, it\xb4s just a matter of writing a single JS function.
\\nFinally, PostCSS is very fast and easy to setup because it runs 100% in JavaScript.\\nCompared to Sass as a preprocessor, it feels much more powerful but at the same time less bloated with superfluous functionality because everything comes in its own little plugin
\\n","featured":false,"flag":"default","position":[427,492]},{"id":"postgres","release":"2019-11-01","title":"PostgreSQL","ring":"adopt","quadrant":"tools","body":"PostgreSQL is a powerful, open source object-relational database system with over 30 years of active development that has earned it a strong reputation for reliability, feature robustness, and performance.
\\n","featured":false,"flag":"default","position":[465,453]},{"id":"postman","release":"2021-07-01","title":"Postman","ring":"adopt","quadrant":"tools","body":"Postman is now the tool of choice for API testing and widely used in our projects.\\nWe therefore moved it to the Adopt level.
\\n","featured":false,"flag":"default","revisions":[{"release":"2019-11-01","ring":"trial","body":"Postman is an API testing and documentation tool.\\nRequests can be bundled into folders and easily be configured to be executed against multiple environments.\\nResponses can be evaluated using the "test" feature.
\\nEven automated testing is possible using Newman as an addition to Postman.
\\n"}],"position":[436,547]},{"id":"protobuf","release":"2021-07-01","title":"Protobuf","ring":"adopt","quadrant":"languages-and-frameworks","body":"In an increasingly microservice-oriented environment, it is crucial that all parties agree on a common language and wire format for data exchange.
\\nJSON and XML are two well-known formats for serialization of data; however, they come with a few drawbacks. JSON is completely dynamic without any validation (though there is json-schema) and XML uses an extremely heavyweight syntax, which carries a huge overhead, so parsing and transport becomes quite slow.
\\nProtobuf, amongst others, is an approach to solving this problem by using well-defined schemas to create language-specific code, which serializes/marshals and deserializes/unmarshals data. One of the key features is the built-in support for evolving schemas; it is easily possible to incrementally extend the definition while staying backwards-compatible and compose messages consisting of several sub-messages.
\\nIf you are looking for a way to have different systems agree on a common protocol on top of a transport layer (such as AMQP or HTTP), Protobuf is definitely worth examining more closely and should be assessed.
\\n","featured":false,"flag":"default","revisions":[{"release":"2019-11-01","ring":"assess","body":""},{"release":"2017-03-01","ring":"assess","body":"In an increasingly microservice-oriented environment, it is crucial that all parties agree on a common language and wire format for data exchange.
\\nJSON and XML are two well-known formats for serialization of data; however, they come with a few drawbacks. JSON is completely dynamic without any validation (though there is json-schema) and XML uses an extremely heavyweight syntax, which carries a huge overhead, so parsing and transport becomes quite slow.
\\nProtobuf, amongst others, is an approach to solving this problem by using well-defined schemas to create language-specific code, which serializes/marshals and deserializes/unmarshals data. One of the key features is the built-in support for evolving schemas; it is easily possible to incrementally extend the definition while staying backwards-compatible and compose messages consisting of several sub-messages.
\\nIf you are looking for a way to have different systems agree on a common protocol on top of a transport layer (such as AMQP or HTTP), Protobuf is definitely worth examining more closely and should be assessed.
\\n"}],"position":[379,298]},{"id":"rabbitmq","release":"2022-03-28","title":"RabbitMQ","ring":"adopt","quadrant":"tools","body":"RabbitMQ has proven to work very well for messaging in our projects, that is why we updated it to "adopt".
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"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.
\\nThere are several alternative solutions to RabbitMQ, e. g. the free Apache ActiveMQ, which is integrated in Anypoint platform. 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.
\\nWe use RabbitMQ internally for transferring messages safely in our logging ecosystem between Logstash 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.
\\nRabbitMQ is rated "Trial". It fits into our approach to build robust, resilient systems and use asynchronous messages 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.
\\n"}],"position":[503,442]},{"id":"raml","release":"2022-03-28","title":"RAML","ring":"hold","quadrant":"languages-and-frameworks","body":"Since the RAML project has decided to join the OpenAPI initiative and the RAML ecosystem lacks further development and additional tools, we decided to use and recommend using "OpenAPI specification (OAS)" as description standard instead.
\\nRAML still provides advantages in modeling an API through it's more expressive modeling language and can produce OAS
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"adopt","body":"RAML (the RESTful API Modelling Language) is a YAML-based API specification language. It's now available in version 1.0. The philosophy behind it is to specify the API before implementation.
\\nIf 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 provides a beautiful online documentation with "try it" features for your raml definition.
\\nThe RAML ecosystem provides a rich toolset for code generation (e.g. online editor; api-workbench), automatically generated documentation, code generation (e.g. go-raml), mocking, testing and much more. We prefer RAML over Swagger because of this.
\\n"}],"position":[133,154]},{"id":"react-native","release":"2023-11-01","title":"React Native","ring":"assess","quadrant":"languages-and-frameworks","body":"React Native is an open-source UI software framework used to build applications for Android, Android TV, iOS, macOS, tvOS, Web, Windows, and UWP. It enables developers to utilize the React framework alongside native platform features.
\\nDeveloping applications with a single codebase can help ensure consistent user experiences across platforms, while also delivering the performance advantages of native code.
\\n","featured":true,"flag":"new","tags":["coding","frontend"],"position":[211,138]},{"id":"react-server-components","release":"2023-11-01","title":"React Server Components","ring":"assess","quadrant":"methods-and-patterns","body":"Shortly after releasing React 17 in October 2020, the team introduced React Server Components (RSC) as a working draft in December 2020. RSCs represent a new application architecture paradigm within React designed to reduce the amount of JavaScript sent to the client. The ultimate goal is to enhance performance, user experience, and maintainability.
\\nThis new feature enables the creation of components that exclusively run on the server. As a result, there is no impact on the bundle size downloaded by the client. For instance, libraries used in server components are not shipped to the client. RSCs also have the capability to access server-side resources, such as databases and the file system, directly.
\\nIn addition to server components, there are client components, which are essentially the classic components everyone is familiar with. The only distinction is that client components need to be explicitly declared using a directive. Determining which components should be client or server can be one of the more challenging aspects, especially when the goal is to migrate existing applications.
\\nRSCs appear to be most effective when used with Server Side Rendering, although it is possible to use them without it. RSCs and Server Side Rendering complement each other well, as server components are only rendered once on the server and do not need to be sent to the client. Client components are still rendered on the server and then hydrated on the client side. However, with a well-structured application that minimizes client-side code and in combination with React 18's Suspense and Selective Hydration features, a performance boost is expected. To test this hypothesis, the React team has collaborated with Vercel, the maintainer of NextJS, to integrate RSCs into a suitable environment early.
\\nOverall, we recognize the potential of this new approach, even though there are several steps to take, particularly for meta-frameworks to achieve production readiness. It appears to be only a matter of time before adoption of React Server Components becomes widespread. This is why we have placed it in the assess ring, keeping a watchful eye on this evolving technology.
\\n","featured":true,"flag":"new","tags":["frontend","coding"],"position":[702,341]},{"id":"react","release":"2023-11-01","title":"React.js","ring":"adopt","quadrant":"languages-and-frameworks","body":"React today is the most widely used frontend library within our company, employed in various forms. Whether it's integrated into frameworks like NextJS and Remix or utilized for client-side-only applications, React plays a significant role in many of our ongoing projects. Over time, a community of experts has emerged within the company.
\\nWe firmly believe that React 18, with its range of new features, will further enhance its popularity within our company and the broader community.
\\nWhile not an entirely new feature, Suspense was initially introduced in a basic version back in 2018. However, it had certain limitations. Its first official use case was code splitting with React.lazy, but this feature was only available on the client side, not during server rendering. The primary goal has always been to enhance the loading experience both on the client and server. With React 18, Suspense now enables Streaming server rendering, a new feature that allows React to send the HTML of the loading fallback first and then, after loading completes, send the actual HTML content to the client. The React team continues to work on improving Suspense, particularly to enable data fetching libraries to use it. They are collaborating with authors of some of the most prominent libraries like TanStack Query, SWR, and Apollo.
Server Components represent a new paradigm in React application architecture with the goal of minimizing the amount of JavaScript sent to the client. This approach introduces a new type of component that operates exclusively on the server. It shows great promise, which is why we have given React Server Components a dedicated entry on our Tech Radar.
\\nThis is a fundamental update to React's rendering model, primarily occurring under the hood. It introduces the ability to create multiple versions of a user interface concurrently. With concurrent React, rendering can be interrupted, abandoned, and resumed, allowing the application to respond to user interactions immediately, even if it's currently in the middle of rendering.
\\nThe React team is collaborating closely with some of the major players in the React ecosystem to stabilize and enhance the library. They are also experimenting with new features, ensuring that React remains as exciting as ever.
\\n","featured":true,"flag":"changed","tags":["coding","frontend"],"revisions":[{"release":"2018-03-01","ring":"adopt","body":"The past months have shown that React is still a great fit for us for frontend-heavy applications. \\nWith its rewritten core in version 16, Facebook shows how important this framework is for them. \\nTherefore, Facebook is investing a lot of effort into React and a healthy community. \\nIn addition, we REALLY enjoy writing React components – so much so, that we have to move this library into adopt!
\\n"},{"release":"2017-03-01","ring":"trial","body":"React claims to be "the V in MVC". But for us it is much more than that. React\\nimproved the way we approach frontend applications as we build them. Its\\nfunctional way of writing components and its declarative JSX syntax help us to\\nbuild interactive UIs very efficiently. React's one-way data flow keeps\\neverything modular and fast and makes even large applications more readable.
\\nComponents are the central point of React - once we fully started\\nthinking in react,\\nour components became smaller, more reusable and better testable.
\\nAfter some 1.5 years of experience with React and the steady growth of the\\ncommunity and ecosystem around it, we can confidently say that we still see\\ngreat potential to build upcoming projects with React.
\\n"}],"position":[308,282]},{"id":"reactive-programming","release":"2022-03-28","title":"Reactive Programming","ring":"adopt","quadrant":"methods-and-patterns","body":"The reactive style of programming promotes event-based thinking and modeling - and by that assists in creating more decoupled solutions.
\\nSynergies arise, when people understand the concepts of this pattern: by using marble diagrams, which are a de-facto standard in visualizing algorithms in a reactive style, a common ground for communication is available regardless of the programming language used.
\\nWhen appropriate, we choose more explicitly the Reactive Programming pattern and therefore moved this to "adopt".
\\n","featured":false,"flag":"default","revisions":[{"release":"2018-03-01","ring":"trial","body":"Classic (web-)applications typically consist of transactions that submit large forms to the server side, which then processes these and, in response, returns HTML for the browser to render. \\nToday's applications have more and more fine-grained 'real-time'-like aspects: A simple modification of a form field could trigger a complete round trip to the server including other services and persistence. \\nNaturally, all of these transactions should respect the expectations of a user who wants a highly interactive application.
\\n"Reactive Programming" tries to provide an answer to the challenges mentioned above by raising the level of abstraction. \\nThis allows you to focus on the stream of events that make up your business logic in a responsive, asynchronous fashion.
\\nThere are various descriptions of what Reactive Programming actually is - at the most general level it is programming with asynchronous data streams and contains tools to create, manipulate, combine and filter these streams. \\nUnder the term "Reactive Programming", we summarize the principles and implementations that underlie ReactiveX and the Reactive Manifesto.
\\n"Reactive Programming" is employed in many of our services – frontend and backend – but not always as an explicitly chosen pattern. \\nAs different platforms have different means to tackle this style of programming, we choose to include "Reactive Programming" as a general Method and Patterns Item in addition to concrete libraries and APIs such as Rx.JS or Akka Streams to highlight the importance of the approach in general.
\\n"}],"position":[470,264]},{"id":"redux","release":"2021-07-01","title":"Redux","ring":"trial","quadrant":"languages-and-frameworks","body":"Redux helps us to maintain state in our frontend applications in a more predictable and clearer way. It is extendable though middleware, it has a great documentation and some awesome devtools that are especially helpful when you are new to Redux.
\\nThe functional concepts for updating the state, combined with immutable data, lead to extremely easy and enjoyable unit tests - this is maybe the biggest plus for us developers.
\\nThe official react-redux bindings also made it straightforward to weave Redux into our React applications. For asynchronous actions we use redux-sagas which has proven itself as a better alternative for redux-thunk.
\\nCurrently, we use Redux only in our React projects, but we are evaluating it together with other frameworks such as Angular or Vue.js, as well.
\\n","featured":false,"flag":"default","position":[232,254]},{"id":"remix","release":"2023-02-23","title":"Remix","ring":"adopt","quadrant":"languages-and-frameworks","body":"Updated to "adopt"
\\n","featured":true,"flag":"default","tags":["coding","frontend"],"revisions":[{"release":"2022-03-28","ring":"trial","body":"Remix is a full stack web framework that lets us focus on the user interface and work with web standards.
\\nOne of Remix biggest features is the availability of nested routes. Through nested routes, Remix can eliminate nearly\\nevery loading state.
\\nMost web apps fetch inside of components, creating request waterfalls which leads to slower page loads. Remix loads data\\nin parallel on the server and sends a fully formed HTML document
\\nAt AOE we use Remix for our enterprise web applications to provide a first class UX and fast page loads.
\\n"}],"position":[367,238]},{"id":"renovate","release":"2022-03-28","title":"Renovate","ring":"adopt","quadrant":"tools","body":"At AOE, we rely on Renovate CLI tool in the CI pipelines for most of our projects.
\\n","featured":true,"flag":"default","tags":["ci/cd"],"revisions":[{"release":"2021-07-01","ring":"trial","body":"Renovate is an automated dependency update tool.\\nIt vastly reduces the time and effort spent on keeping a project's dependencies up-to-date by automatically creating merge requests whenever a dependency needs to be updated.\\nThe tool is easy to set up and configure, offers built-in support for monorepo architectures and works with various programming languages and package managers, e.g.
\\nAt AOE, we use the Renovate CLI tool in the CI pipelines of a constantly growing number of projects.
\\n"}],"position":[448,412]},{"id":"resilience-thinking","release":"2022-03-28","title":"Resilience Thinking","ring":"adopt","quadrant":"methods-and-patterns","body":"Resilience is the capability of an application or service to resist different error scenarios. Especially for\\ndistributed systems - where a lot of communication between different services happen - it's very important to explicitly\\nthink of implementing resilience.
\\nThere are a lot of different resilience patterns, and it is also a matter of the overall software design. Typical\\npatterns and methods used are:
\\n"Embrace Errors" should be the mindset - because it is not a question if errors appear - it's just a question of when.
\\n","featured":true,"flag":"default","tags":["architecture"],"revisions":[{"release":"2017-03-01","ring":"trial","body":"Resilience is the capability of an application or service to resist different error scenarios. Especially for distributed systems - where a lot of communication between different services happen - it's very important to explicitly think of implementing resilience.
\\nThere are a lot of different resilience patterns and it is also a matter of the overall software design. Typical patterns and methods used are:
\\n"Embrace Errors" should be the mindset - because it is not a question if errors appear - it's just a question of when.
\\n"}],"position":[527,280]},{"id":"rest-assured","release":"2022-03-28","title":"REST Assured","ring":"assess","quadrant":"tools","body":"REST Assured is a Java DSL for simplifying testing of REST-based services built on top of HTTP Builder.\\nIt supports the most important HTTP request methods and can be used to validate and verify the response of these requests.
\\nAt AOE, we use REST Assured with Spock to automate our API testing.\\nWe appreciate the easy-to-use DSL, which uses the Given-When-Then template (also known as Gherkin language).\\nThis template helps other project members to understand the code/test easily.
\\nBecause of the seamless integration with Spock and our positive experience in one of our major projects, we classify REST Assured as assess.
\\n","featured":false,"flag":"default","position":[583,667]},{"id":"rust","release":"2022-03-28","title":"Rust","ring":"assess","quadrant":"languages-and-frameworks","body":"Rust is a young and modern programming language initially developed by Mozilla Research.
\\nIt provides a strict type system, compile-time memory-safety, excellent package manager, object-oriented & functional programming, task-based concurrency, good readability and maintainability and many more.\\nIt has a C/C++ comparable efficiency and helps the programmer to avoid unnecessary security-relevant memory-related bugs during compile-time.\\nSince every memory-allocation is directly released after it can't be used anymore (owner deletion), no garbage collection is needed.
\\nC/C++ code/libraries can be integrated by its binding generator tool.
\\nAt stackoverflow it is votes 5 years in a row (2016, 2017, 2018, 2019, 2020) for the most loved programming-language by programmers.\\nThe popularity is growing continuous.
With it's memory-safety/efficiency and energy-efficiency it helps to save money for bug-fixing, energy and cloud-computing.
\\n","featured":false,"flag":"default","position":[189,163]},{"id":"rxjava","release":"2017-03-01","title":"RxJava","ring":"trial","quadrant":"tools","body":"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 underlying data layer.
\\n","featured":true,"flag":"default","tags":["coding","architecture"],"position":[644,483]},{"id":"rxjs","release":"2022-03-28","title":"RxJs","ring":"adopt","quadrant":"languages-and-frameworks","body":"RX/JS aka reactive streams
\\nRxJS is an implementation for the reactive programming paradigm which implements mostly the observer and iterator pattern and follows the functional programming ideas.\\nThe pattern actually got a renaissance because it's not completely new but has new implementations in many frameworks and languages like Angular, Akka, Spring and many more.\\nReason for that attention actually is (in the JavaScript world), that observables can be cancelled (by rules too) and observables can pass (stream) data on multiple events.\\nBoth aspects are not well realizable using promises e.g. and both were also detected as a huge limitation in the JavaScript community — and so it's worth to get an understanding for reactive programming in general.
\\nWe at AOE actually use RxJS in combination with Angular and can fully recommend the approach of observables.
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"RX/JS aka reactive streams
\\nRxJS is an implementation for the reactive programming paradigm which implements mostly the observer and iterator pattern and follows the functional programming ideas.\\nThe pattern actually got a renaissance because it's not completely new but has new implementations in many frameworks and languages like Angular, Akka, Spring and many more.
\\nReason for that attention actually is (in the JavaScript world), that observables can be cancelled (by rules too) and observables can pass (stream) data on multiple events.\\nBoth aspects are not well realizable using promises e.g. and both were also detected as a huge limitation in the JavaScript community — and so it's worth to get an understanding for reactive programming in general.
\\nWe at AOE actually use RxJS in combination with Angular and think that it's worth to dive deeper into this paradigm.
\\n"}],"position":[366,392]},{"id":"sass","release":"2022-03-28","title":"Sass","ring":"hold","quadrant":"languages-and-frameworks","body":"Since the heydays of Sass, the requirements for styling solutions have changed.
\\nWith modern solutions like CSS-in-JS,\\nTailwind or PostCSS, you get scoped CSS out of the\\nbox and can get rid of the manual and therefore error-prone BEM methodology. Furthermore, mapping class names to\\nelements is no longer necessary.
\\nIn general the modern solutions bring a better and more robust developer experience. Therefore, we put Sass on hold.
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"adopt","body":"Sass (Syntactically Awesome Style-Sheets) is an extension to native CSS, which, as a preprocessor, simplifies the generation of CSS by offering features that enable developers to more efficiently write robust, better readable and maintainable CSS.
\\nCore features of Sass are:
\\nSass has been widely adopted for many years and has evolved to an industry-standard backed by an active community since 2006.
\\nThe learning curve is very smooth as Sass is fully compatible to CSS, meaning that all features are optional:\\nStarting with Sass is as easy as renaming .css-files to .scss in a first step and then refactoring it step-by-step with the use of Sass features.
\\nAt AOE, Sass has been recommended by the frontend COI and is used in nearly every current project.
\\nMore information:
\\n\\n"}],"position":[179,96]},{"id":"scala3","release":"2022-03-28","title":"Scala 3","ring":"adopt","quadrant":"languages-and-frameworks","body":"Following up on the previous 'trial' we will move our existing Scala codebase to\\nScala 3 where possible. Some Frameworks like Play will need some time to allow\\nus moving but for our smaller services a migration is possible.
\\n","featured":true,"flag":"default","tags":["coding"],"revisions":[{"release":"2021-07-01","ring":"trial","body":"Scala 3 is the successor of the Scala 2.x series programming language.
\\nIt's not just a small iteration on Scala 2 but a complete overhaul of the language trying to improve in several areas like:
\\nif, while and fornew operatorimplicits - see belowusinggivenextension (s: String) def pirate: String = s"$s arr!"enums Even with these big changes Scala 3 provides a great compatibility story supporting Scala >2.13.5 libraries in Scala 3 projects and vice versa.
\\nAlthough slowly we will update our existing Scala 2 codebase to Scala 3 over the next months and years to take advantage of the improvements made.
\\n"}],"position":[288,255]},{"id":"scala-lang","release":"2022-03-28","title":"Scala Lang","ring":"adopt","quadrant":"languages-and-frameworks","body":"Scala is used in many projects at AOE. We have therefore moved it to the adopt level.
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"Besides Java, Scala is the most mature language on the Java Virtual Machine. Its unique blend of object-oriented and functional language features and rich type system with advanced type inference enables one to write concise code.
\\nIt is fully interoperable with Java but has a big ecosystem of tools and frameworks on its own.
\\nScala provides one of the best high-level concurrency- and async features on the language level as well as on the framework level, making it the default choice of twitter and the like.
\\nAt AOE, we already use Scala in various projects to create scalable backend systems (Play, Akka) or for batch processing (Spark).
\\n"}],"position":[234,370]},{"id":"semver2","release":"2021-07-01","title":"Semantic Versioning 2.0","ring":"adopt","quadrant":"methods-and-patterns","body":"Semantic Versioning 2.0 is a scheme for specifying a software's version.\\nAs the de facto standard, this is widely used and established in all areas of software development.\\nIt offers a clear way of communicating changes over the lifetime of the software being developed.
\\nEspecially in large-scale projects with many components being dependent on each other, it is important to use unambiguous communication across teams.
\\n","featured":false,"flag":"default","position":[418,328]},{"id":"semanticore","release":"2023-02-23","title":"Semanticore","ring":"adopt","quadrant":"tools","body":"Updated to adopt.
\\n","featured":true,"flag":"default","tags":["ci/cd","documentation","quality assurance"],"revisions":[{"release":"2022-03-28","ring":"trial","body":"Semanticore is an open source tool fulfilling our needs for managing\\nchangelogs and semantic releases.
\\nBuild upon git histories and conventional commits, Semanticore creates and maintains changelogs using Gitlab or GitHub\\nmerge requests, and, once merged, creates appropriate tags and releases. Automating this workflow improves our daily\\nwork a lot, and always gives us a clear view on outstanding changes as well as a proper-maintained changelog.
\\nCheck out our Semanticore repository at https://github.com/AOEpeople/semanticore or run it locally for testing purposes:
\\n$ cd ~/path/to/my/repository\\n$ go run github.com/aoepeople/semanticore@v0\\nThe serverless pattern, also referred to as Function as a Service (FaaS), represents a paradigm shift in cloud computing. It enables developers to focus solely on writing code, which is executed in response to events without having to manage the underlying servers or infrastructure. Serverless applications are composed of multiple individual functions or microservices that automatically scale in response to demand.
\\nAt AOE, we encourage our development teams to adopt the serverless pattern for its increased scalability, reduced operational overhead, and cost-effectiveness.
\\nEmbracing the Serverless pattern can significantly enhance development speed, scalability, and cost-effectiveness in modern software architectures. For example:
\\nWhile 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.
\\nThese 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, kubernetes (with configMaps and secrets) or YAD.
\\nIn this manner, the build package can be independent of the environment it's being deployed to - making it easier to follow the "Build once, deploy often" CI/CD principle.
\\n","featured":false,"flag":"default","position":[497,303]},{"id":"shared-responsibility","release":"2021-07-01","title":"Shared Responsibility Model","ring":"trial","quadrant":"methods-and-patterns","body":"Since introducing "Platform Engineering Team" who build, maintain and operate our Kubernetes clusters and other related platform services, the question occurs who is in charge of the various tasks like keeping things up and running, applying critical security fixes, update software in general, keeping an eye on the bill and many more topics.\\nWe're not proposing a solution on how to split responsibilities here, but we want to raise awareness for bringing everybody together and formally discuss all responsibilities and write them down similar to (and possibly extending) AWS's shared responsibility model.\\nSome topics are 24/7 on-call support, broken deployment pipelines, and vulnerability scans.
\\n","featured":true,"flag":"default","tags":["devops"],"position":[586,229]},{"id":"sitespeed","release":"2022-03-28","title":"Sitespeed.io","ring":"assess","quadrant":"tools","body":"Web Performance Monitoring is the process of measuring a Web service’s ability to respond efficiently to user interactions.\\nData gathered through monitoring helps analyze performance bottlenecks, plan improvements, and measure a site's responsiveness.
\\nSitespeed.io is a set of Open Source tools that makes it easy to monitor and measure the performance of a website.\\nIt tests websites using real (or headless) browsers, simulating users connectivity and collecting important user-centric metrics.\\nThe tools are packaged as a docker image that can be easily deployed.\\nData collected can be saved to different locations for later analysis which makes it easy to track changes.\\nLast, Sitespeed.io can be used as part of a continuous integration pipeline or as part of a monitoring solution.
\\n","featured":false,"flag":"default","position":[622,635]},{"id":"sketch","release":"2023-11-01","title":"Sketch","ring":"adopt","quadrant":"tools","body":"Sketch is no longer used by Team XD as we have moved to Figma and just finished the last project done in Sketch.
\\n","featured":false,"flag":"changed","tags":["ux/ui"],"revisions":[{"release":"2021-07-01","ring":"adopt","body":"Figma is a vector graphics editor and primarily web-based prototyping tool, with additional offline features enabled by desktop applications for macOS and Windows. The Figma Mirror companion apps for Android and iOS allow viewing Figma prototypes on mobile devices. The next step in our toolchain development comes right after the Sketch+Abstract approach. Figma enabled the next level of collaboration between designers, stakeholders, and frontend engineers.
\\n"}],"position":[527,515]},{"id":"sonarqube","release":"2023-11-01","title":"SonarQube","ring":"adopt","quadrant":"tools","body":"SonarQube remains a good choice for checking your code quality. However, when using GitLab pipelines, it can be replaced with the built-in functionality provided by GitLab.
\\n","featured":false,"flag":"changed","tags":["ci/cd","quality assurance"],"revisions":[{"release":"2022-03-28","ring":"adopt","body":"To track code quality of our projects and check for security issues (Static Application Security Testing), we recommend \\nSonarQube. At AOE we use it in CI pipelines to scan our code against the quality gate. If possible we \\neven check each merge request to prevent degrading code quality before adding it to our code basis.
\\n"},{"release":"2019-11-01","ring":"trial","body":"At AOE, we are using SonarQube to get a historical overview of the code quality in our Projects.\\nWith SonarQube, you can get a quick insight into the condition of your code.\\nIt analyzes many languages and provides numerous static analysis rules.\\nSonarQube is also being used for Static Application Security Testing (SAST) which scans our code for potential security vulnerabilities and is an essential element of our Secure Software Development Lifecycle.
\\n"},{"release":"2018-03-01","ring":"assess","body":"At AOE, we're evaluating SonarQube to get an historical overview of the code quality of our Projects. With SonarQube, you can get a quick hint about the condition of your code. It analyzes many languages and provides numerous static analysis rules.
\\n"}],"position":[529,490]},{"id":"specflow","release":"2023-11-01","title":"SpecFlow","ring":"assess","quadrant":"languages-and-frameworks","body":"SpecFlow is a free and open source BDD-framework for .NET
\\nBDD frameworks in general enable teams to better collaborate on test automation by using for instance the Gherkin syntax\\nto make tests readable to everyone. SpecFlow is the most popular BDD framework for .NET projects.
\\n","featured":false,"flag":"changed","tags":["coding","quality assurance"],"position":[332,91]},{"id":"spock_geb","release":"2023-11-01","title":"Spock + Geb","ring":"hold","quadrant":"languages-and-frameworks","body":"Most projects at AOE have transitioned away from Groovy, and other testing frameworks for JVM languages are more advanced and user-friendly. Consequently, mentioning Spock no longer seems relevant.
\\n","featured":false,"flag":"changed","tags":["coding","quality assurance"],"revisions":[{"release":"2022-03-28","ring":"hold","body":"spockframework.org - Spock is a testing and specification framework for Java and Groovy\\napplications.
\\nFor the most parts we switched from Groovy to Java or Kotlin with JUnit 5. In this regard we think that the active\\ncommunity and regular updates and extension libraries of JUnit 5 cover everything we want or need.
\\ngebish.org - Geb is a browser automation solution.
\\nUI testing with Geb is replaced by Cypress or Playwright.
\\n"},{"release":"2017-03-01","ring":"adopt","body":"spockframework.org - Spock is a testing and specification framework for Java and Groovy applications. What makes it stand out from the crowd is its beautiful and highly expressive specification language. Thanks to its JUnit runner, Spock is compatible with most IDEs, build tools and continuous integration servers. Spock is inspired from JUnit, jMock, RSpec, Groovy, Scala, Vulcans, and other fascinating life forms.
\\ngebish.org - Geb is a browser automation solution. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language. It can be used for scripting, scraping and general automation or as a functional/web/acceptance testing solution via integration with testing frameworks such as Spock, JUnit & TestNG.
\\nAt AOE, we use Spock in combination with Geb in various projects for black-box testing. Mainly, we implement our functional integration and acceptance testing automation with these frameworks, which work together seamlessly. And, we also like the convenience of extending the tests with Groovy built-ins or custom extensions.
\\nBecause of the successful use in two of our large projects and the wide range of opportunities within the testing domain with Spock and Geb, we classify this combo with adopt.
\\n"}],"position":[26,318]},{"id":"spring-boot","release":"2019-11-01","title":"Spring Boot","ring":"adopt","quadrant":"languages-and-frameworks","body":"We now have several years of experiences with Spring Boot, and a big projects Microservice Environment runs completely on Spring Boot, so it's time to update it to "adopt".
\\n","featured":true,"flag":"default","tags":["coding"],"revisions":[{"release":"2018-03-01","ring":"trial","body":"We have had good experiences with Spring Boot, and already have several Spring Boot-based services running in \\nproduction. We like the ease of kick-starting new services and the variety of tools in the Spring ecosystem.
\\n"},{"release":"2017-03-01","ring":"assess","body":"With Spring Boot you create standalone Spring Applications with minimum configuration. Spring Boot rapidly gets you up and running for production.
\\nWith an embedded Tomcat, Jetty and Undertow you have everything you need to deploy your application out-of-the-box.
\\nThe Spring Cloud ecosystem also gives you a lot of extension points for developing, deploying and running cloud applications.
\\nIt's based on the rock-solid Spring framework and provides excellent documentation.
\\nAt AOE, we use Spring Boot in a microservice architecture. Together with Groovy as the implementation Language, and some other Tools (Spring Security, Cloud, HATEOAS, Data, Session) from the Spring environment, we are able to create complex and powerful applications in no time.
\\n"}],"position":[280,375]},{"id":"spring-rest-docs","release":"2022-03-28","title":"Spring REST Docs","ring":"hold","quadrant":"tools","body":"Spring REST Docs auto generates Asciidoctor snippets with the help of Spring MVC Test or RestAssured.\\nSo you can be sure that your tests are inline with the documentation.
\\nWe now use an Api First approach in conjunction with Open API. We see an active community there and a lot of support with this approach.
\\n","featured":true,"flag":"default","tags":["documentation"],"revisions":[{"release":"2017-03-01","ring":"assess","body":"Spring REST Docs auto generates Asciidoctor snippets with the help of Spring MVC Test or RestAssured.\\nSo you can be sure that your tests are inline with the documentation.
\\nAt AOE, we use Spring REST Docs to document our Rest Services and Hal Resources.\\nWe also use it to auto generate WireMock Stubs, so the consumer of the service can test against the exact API of the service.
\\n"}],"position":[725,606]},{"id":"state-management-pattern","release":"2023-11-01","title":"State Management Pattern","ring":"adopt","quadrant":"methods-and-patterns","body":"State Management is a design pattern with the goal of efficiently sharing state data across components while separating domain representation from state management. This pattern is widely used in many popular web frameworks such as Vuex or Redux.
\\nEspecially in reactive systems, this pattern helps in maintaining decoupled, stateless components with immutable data. The implementation of state management varies and depends on the specific requirements of the application at hand.
\\nFor distributed backend systems, one might consider utilizing Akka's cluster sharding module to elastically manage domain object states.
\\nWe employ various state management patterns across most Vue and React projects that require them.
\\n","featured":true,"flag":"changed","tags":["architecture","coding"],"revisions":[{"release":"2021-07-01","ring":"adopt","body":"State Management is a design pattern with the goal of properly sharing state data across components and separating domain representation from state management.\\nThis pattern is applied by many popular web frameworks such as Vuex, Redux or Flux.
\\nEspecially in reactive systems, this pattern helps to solve the task of maintaining decoupled, stateless components with immutable data.\\nThe ways of implementing state management differs and depends on the specific requirements of the application at hand.
\\nFor distributed backend systems one might want to utilize Akka's cluster sharding module to elastically manage domain object states.
\\nWe use the various state management patterns across most Vue and React projects that warrant them.
\\n"}],"position":[456,227]},{"id":"stitches","release":"2023-11-01","title":"Stitches","ring":"hold","quadrant":"languages-and-frameworks","body":"Stitches is no longer actively maintained due to compatibility issues with CSS-in-JS runtime injection and React 18 Server Components. Therefore, we do not recommend using it for new projects.
\\n","featured":true,"flag":"changed","tags":["coding","frontend"],"revisions":[{"release":"2022-03-28","ring":"trial","body":"Stitches is a lightweight & performant CSS-in-JS styling library with a focus on component architecture and developer\\nexperience.
\\nUnlike most CSS-in-JS libraries, Stitches promises near-zero runtime costs. This is possible by avoiding unnecessary\\nprop interpolations and defining variants upfront.
\\nStitches has a fully typed API to provide an awesome developer experience. It comes with built-in theme support,\\nserver-side rendering & much more.
\\nAt AOE we use Stitches when we want to write performant and scalable CSS, but don't want to give up the flexibility and\\ndeveloper experience of React components.
\\n"}],"position":[164,113]},{"id":"storybook","release":"2021-07-01","title":"Storybook","ring":"adopt","quadrant":"tools","body":"In recent years, Storybook has become the de facto standard for creating UI components in isolation.\\nWe have been using Storybook in many projects for quite some time now and really loving the approach.
\\nWith version 6, the config has been greatly simplified to achieve the goal of a zero-config approach in the future.
\\nStorybook is a user interface development environment and playground for UI components.\\nThe tool enables developers to create components independently and showcase components interactively in an isolated development environment.\\nStorybook runs outside the main app so users can develop UI components in isolation without worrying about app specific dependencies and requirements.
\\n"}],"position":[428,527]},{"id":"strapi","release":"2021-07-01","title":"Strapi","ring":"trial","quadrant":"tools","body":"Strapi is a headless CMS built with Javascript on Node.js.\\nIts data-centered approach offers great flexibility for many use cases by integrating with the available APIs.
\\nStrapi's API comes in a RESTful and GraphQL variant.\\nBoth perfectly support the API-first design approach.
\\nEver since the stable release version 3.0.0 from mid-2020, the CMS reached market maturity and offers a good choice for scalable headless CMSs.\\nAs of the 3.6 release in April 2021, Strapi features full internationalization support, making it a viable candidate to be evaluated toe to toe with solutions like Drupal.
\\nAt AOE we are evaluating Strapi for various projects, appreciating its straightforward installation, setup, and use by editors in lieu of more heavy-weight solutions used in the past.
\\n","featured":true,"flag":"default","tags":["frontend"],"position":[476,616]},{"id":"strategic-domain-driven-design","release":"2017-03-01","title":"Strategic Domain Driven Design","ring":"adopt","quadrant":"methods-and-patterns","body":"Design of distributed applications need to be done wisely. Strategic Domain Driven Design is an approach for modelling large-scale applications and systems and is introduced in the last part of Eric Evans' book Domain Driven Design.
\\nDomain driven design is a well-known pattern family and has been established at AOE for quite some time now. Unlike Domain Driven Design, which focuses on the tactical design in an application, strategic domain driven design is an approach that is very helpful for the high-level strategic design of an application and distributed software architecture.
\\nIt is a pattern family focused on using and defining Bounded Context and thinking explicitly of the different relationship patterns and the required "translation" of similar "concepts" between the bounded contexts. It is helpful to argue and find a good strategic architecture in alignment with the requirements, the domain and by considering Conway's Law.\\nA context map and a common conceptional core help to understand and improve the overall strategic picture. Especially with the Microservice approach, it is important to define and connect services following the low coupling - high cohesion principles by idendifying fitting bounded contexts.
\\nThe following chart gives an overview of possible relationships between bounded contexts:\\n![\\"strategic-domain-driven-design-relationships\\"](\\"/digital_xp_techradar/images/strategic-domain-driven-design-relationships.png\\")
While we have found that this approach is especially useful in designing distributed systems and applications with microservices, we have also extended this approach to provide guidelines for general enterprise architectures.
\\n","featured":true,"flag":"default","tags":["architecture"],"position":[501,379]},{"id":"stride-threat-modeling","release":"2019-11-01","title":"STRIDE Threat Modeling","ring":"trial","quadrant":"methods-and-patterns","body":"STRIDE is a model of threat groups that helps to identify security threats to any application, component or infrastructure.
\\nThe acronym stands for:
\\nAOE is applying the threat model in collaborative sessions using the Elevation of Privilege Card Game which helps to spark imagination and makes threats more tangible.
\\n","featured":true,"flag":"default","tags":["security"],"position":[611,271]},{"id":"styleguide-driven-development","release":"2019-11-01","title":"Styleguide Driven Development","ring":"adopt","quadrant":"methods-and-patterns","body":"Updated to "adopt".
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"The goal of Styleguide Driven Development is to develop your application user Interface independently and reusable in a Pattern Library.
In the old days, the frontend was developed based on page-centric Photoshop files which made it hard to change things afterwards. With styleguide driven development you build smaller elements, which are reusable in all of your frontends.
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 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.
\\n"}],"position":[566,332]},{"id":"svelte","release":"2023-11-01","title":"Svelte","ring":"trial","quadrant":"languages-and-frameworks","body":"We have some smaller Svelte projects at AOE, and there are some features we would like to further explore, such as:
\\nSvelte is neither a language nor a framework, but actually a compiler. It compiles HTML templates\\nto specialized code that manipulates the DOM directly, which may reduce the size of transferred files and give better\\nclient performance.
\\nIt is surprisingly easy to work with, and we currently assess it in an internal project.
\\n"}],"position":[202,251]},{"id":"symfony-components","release":"2019-11-01","title":"Symfony Components","ring":"trial","quadrant":"languages-and-frameworks","body":"Symfony Components are part of the Symfony Framework and they are designed as decoupled and reusable PHP components.
\\nTheir use cases vary from simple little helpers such as a beautified var_dump to more complex ones such as access control, list-based security mechanisms and an easy-to-integrate console component to give your already existing applications some CLI capabilities. They are used by a lot of PHP-based projects such as Typo3, Magento, Composer, PHPUnit and Doctrine, with contributions continually taking place. If you are planning the next project with PHP components, you should have a look at the Symfony Components list, which includes a lot of well-designed, decoupled Open Source pieces of PHP code.
\\n","featured":false,"flag":"default","position":[359,185]},{"id":"tailwindcss","release":"2022-03-28","title":"Tailwind CSS","ring":"adopt","quadrant":"languages-and-frameworks","body":"At AOE we use Tailwind now on several projects. From fast prototyping, over marketing websites to enterprise applications.
\\n","featured":true,"flag":"default","tags":["coding","frontend"],"revisions":[{"release":"2021-07-01","ring":"trial","body":"Tailwind CSS is a framework that heavily utilizes CSS classes.\\nWhat 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.\\nCSS classes are entirely generated based on a configuration file that outlines the entire design system including states, nuances, etc.\\nTailwind'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.\\nColours, sizes, spaces etc. can have meaningful names that are easy to remember and shared between developers and designers.\\nIn turn, this results in a shared language with less explanation required.\\nSupport for deep integration into the development and build processes ensure optimized build times with incremental rebuilds only on parts really necessary.\\nThis obviously leads to very small build sizes with nearly 100% CSS coverage.
\\nThe 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.\\nThese projects have a huge demand on a variety of interaction forms.
\\nTailwind helps us to fulfil modern user expectations by reducing the complexity of sophisticated industrial processes with a multi-device approach.
\\nThis is an unspoken expectation of today's operators of industrial processes.\\nThe 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.
\\n"}],"position":[357,319]},{"id":"team-start-page","release":"2023-11-01","title":"Team Start Page","ring":"adopt","quadrant":"methods-and-patterns","body":"A team start page helps (new) members to orientate themselves. \\nIt normally displays all team members with their roles and contact data as well as a collection of links to the necessary tools, e.g.
\\nSimply things, everyone should know.
\\nAt AOE we care to have a team start page for each team in our wiki.
\\n","featured":false,"flag":"changed","tags":["quality assurance","documentation"],"position":[442,380]},{"id":"temporal-modeling","release":"2019-11-01","title":"Temporal Modeling","ring":"assess","quadrant":"methods-and-patterns","body":"Temporal Modeling is way of modeling software systems and components by putting events first.
\\nThe usual way of modeling software is to find structures, things and relations.\\nWe try to find the relevant aspects of a domain and put all properties into an object-oriented model.\\nTrying to create a second model for a related business process, having the structural model already in place, might result in a process representation that is tightly coupled with the assumptions built up from the structural model and too far away from reality.
\\nBy focusing on the domain processes first, one can visualize all aspects of a process over time.\\nHaving the process visualized, allows to see potential pitfalls or forgotten aspects.\\nWith a temporal model at hand, it is easy to create an object-oriented or structural model that perfectly represents all required information.
\\nWe tried this method when tackling big or complex domains.
\\n","featured":true,"flag":"default","tags":["architecture"],"position":[700,287]},{"id":"trivy","release":"2023-02-23","title":"Trivy","ring":"adopt","quadrant":"tools","body":"Trivy is an open-source vulnerability scanner for containers and other targets. It utilizes\\nan extensive vulnerability database to scan for CVEs, software dependencies in use and common misconfigurations.
\\nTrivy is lightweight and has no external dependencies, making it suitable for use in CI/CD pipelines. Additionally,\\nit can support developers by providing actionable remediation advice, making it easier to fix vulnerabilities.
\\nAs it has proven to be a good fit for both our needs and into our development pipelines, we strongly recommend to\\ngive it a try in your own projects.
\\n","featured":true,"flag":"default","tags":["ci/cd","devops","security"],"position":[521,430]},{"id":"turborepo","release":"2023-02-23","title":"Turborepo","ring":"trial","quadrant":"tools","body":"Turborepo is a build system for JavaScript and TypeScript project,\\nwhich uses a Monorepo structure for their codebase.
\\nIt helps to build projects efficiently by clever caching and resolving dependencies.\\nAt the same time, Turborepo is very easy and fast to use and doesn't get in the way.
\\n","featured":true,"flag":"default","tags":["build","frontend"],"position":[569,568]},{"id":"typescript","release":"2023-11-01","title":"TypeScript","ring":"adopt","quadrant":"languages-and-frameworks","body":"TypeScript has become more widely used and is now considered the industry standard for most JavaScript projects and provides the means to prevent errors during development, refactor code, scale projects, and enhance code collaboration.
\\nIts widespread adoption and the support of a large community contribute to further improving and documenting the language.
\\nTypeScript is our language of choice for both existing and future projects, allowing us to write robust and clean JavaScript code.
\\n","featured":true,"flag":"changed","tags":["coding","frontend"],"revisions":[{"release":"2019-11-01","ring":"adopt","body":"As writing frontend applications becomes more complex, TypeScript allows us to scale client side code easily, even with large code bases.\\nWe use Typescript successfully at production for many projects and we are only going to use it even more in the future.\\nWe highly recommend using Typescript over JavaScript, therefore we have decided to move it to adopt.
\\n"},{"release":"2017-03-01","ring":"assess","body":"TypeScript is a language that gets transpiled to native JavaScript code.
\\nIt offers support for the latest EcmaScript features and has strict typing and support for interfaces built in.
\\nJavaScript scoping, which led into recurring workarounds such as **var self = this, myFunc.bind(this),**was eliminated in TypeScript.
\\nIn TypeScript this stays this, which leads to more readable and understandable code from an OOP perspective.
\\nTypeScript continues to be actively developed by Microsoft and is well-Integrated in today's IDEs.
\\nThe excellent structure and the possibilities for extension make it a good choice to consider for larger JavaScript projects.
\\nTypescript was the choice for Angular and one can assume that it will get more traction with the success of Angular in the future.
\\nThere are also projects that support Typescript „code execution“ on the server such as ts-node.
\\n"}],"position":[330,346]},{"id":"typo3-as-a-framework","release":"2018-03-01","title":"TYPO3 as a Framework","ring":"hold","quadrant":"tools","body":"We should avoid building new projects around TYPO3 by default. A lot of past projects started with CMS-only features in the beginning, and, for example, developed toward highly customized E-Commerce platforms. Instead of rearranging the architecture in a useful way, functionality was built on top of TYPO3's core and its extension framework Extbase. In the context of larger projects, this lead to deployment monoliths and the inability to integrate new technologies.
\\nWhile in the past it was easy to kickstart a TYPO3 project with AOE's custom-tailored kickstarter, we now have a lot of knowledge and tools available to start projects with a much smarter architecture.\\nThis does not mean you shouldn't use TYPO3 anymore, but use it as the tool it is: a content management system.
\\n","featured":false,"flag":"default","position":[657,686]},{"id":"unleash","release":"2022-03-28","title":"Unleash","ring":"adopt","quadrant":"languages-and-frameworks","body":"Unleash is a feature (toggle / flag) management service written in Node.js. \\nYou can enable/disable features independent of deployment schedules. For larger projects with many feature flags \\nyou can benefit from usage statistics and metrics which are collected for each flag.
\\n\\n\\nA lot of activation strategies are provided by Unleash out of the box, like Boolean On/Off, Gradual Rollout, \\nIPs, and so on, while allowing you to add custom strategies.
\\nTo evaluate the feature flag you can choose one of the official SDKs \\nor use the REST-API directly.
\\n","featured":true,"flag":"default","tags":["coding","frontend","devops"],"position":[339,282]},{"id":"vistecture","release":"2022-03-28","title":"Vistecture","ring":"assess","quadrant":"tools","body":"Vistecture is a tool for the visualization and analysis of distributed\\nand/or microservice-oriented software architectures of any scale. It can be integrated in a projects\\nCI pipeline for the automated generation of up-to-date documentation.
\\nWith projects at AOE reaching a certain threshold of size and complexity, we started struggling\\nwith keeping documentation up to date manually, especially with regard to e.g. architecture diagrams\\nor API request/response flows. Thus, we have developed a tool for the rendering of various kinds\\nof documentation and visualizations based on a single architecture description file.
\\nApplications (microservices) and dependencies are defined using a simple, YAML-based syntax. This\\nservice definition can then be converted to the desired output formats or browsed in the Vistecture\\nonline viewer.
\\n","featured":true,"flag":"default","tags":["documentation","architecture"],"position":[478,694]},{"id":"vite","release":"2023-11-01","title":"Vite","ring":"adopt","quadrant":"tools","body":"As modern browsers now support the native usage of ES Modules, it's possible to use them to enhance frontend development, which is the goal of Vite.
\\nSince its announcement in 2020, Vite has garnered significant attention and has grown a large community that provides pluggable features. Vite offers two key components: a native ESM-based development server and a bundler for production builds.
\\nThe development server boasts improved performance during development, as modules are loaded and transpiled only on demand. This leads to faster cold-start times and quicker Hot Module Replacement (HMR) support.
\\nWe consider Vite to be a stable and production-ready tool, and we would recommend it for upcoming projects.
\\n","featured":true,"flag":"new","tags":["frontend","coding"],"position":[542,441]},{"id":"vue","release":"2023-11-01","title":"Vue.js","ring":"adopt","quadrant":"languages-and-frameworks","body":"Vue is a progressive and incrementally adoptable framework for building user interfaces, renowned for its simplicity and flexibility. The core library focuses on views, making it easy to integrate with other libraries and existing projects. It excels in powering single-page applications when combined with supporting libraries like Pinia, vue-router, and VueUse. However, it's also versatile enough to build server-side rendered and statically generated web applications using the Nuxt framework.
\\nVue's HTML-based template syntax enables declarative binding of the rendered DOM to the underlying Vue instance's data. This, in conjunction with the reactivity system, ensures high performance by intelligently determining the minimal components to re-render and applying the minimal DOM manipulations when the app-state changes. Furthermore, applications can be organized into Single File Components, each containing the template (HTML), style (CSS), and functionality (JS). The Composition API and 'script setup' syntax further enhance code readability and modularity, promoting reusability and maintainability throughout the development process.
\\nVue introduces powerful features like Teleport, which enables components to render at any position on the page, and Fragment, removing the requirement for a single root element in a template. Additionally, Vue enhances performance through Tree-Shaking, reducing bundle size, and Compiler-informed Virtual DOM optimizations, resulting in faster initial renders and updates while consuming less memory.
\\n","featured":true,"flag":"changed","tags":["coding","frontend"],"revisions":[{"release":"2021-07-01","ring":"adopt","body":"Updated to "adopt".
\\n"},{"release":"2018-03-01","ring":"trial","body":"Updated to "trial".
\\n"},{"release":"2017-03-01","ring":"assess","body":"Vue is a progressive, incrementally adoptable framework for building user interfaces maintained by Evan You. Unlike other monolithic frameworks, the core library is focused on the view layer only and is very easy to pick up and integrate with other libraries or existing projects. Vue is also perfectly capable of powering sophisticated single-page applications when used in combination with modern tooling and supporting libraries such as vuex and vue-router.
\\nVue uses an HTML-based template syntax that allows you to declaratively bind the rendered DOM to the underlying Vue instance’s data. Under the hood, Vue compiles the templates into Virtual DOM render functions. Combined with the reactivity system Vue is able to intelligently figure out the minimal amount of components to re-render and apply the minimal amount of DOM manipulations when the app state changes, which provides for very high performance.
\\nApplications can be split into Single File Components - a single file containing the template (HTML), style (CSS) and functionality (JS) - which simplifies maintainability and testability of the code and promotes reusability across other projects.
\\n"}],"position":[324,369]},{"id":"vuex","release":"2021-07-01","title":"Vuex","ring":"assess","quadrant":"languages-and-frameworks","body":"Vuex is a state management pattern + library for Vue.js applications.
\\n","featured":false,"flag":"default","position":[106,309]},{"id":"webpack","release":"2023-11-01","title":"Webpack","ring":"adopt","quadrant":"tools","body":"Webpack remains one of the, if not the most, widely used bundlers. The team behind it is continually fixing bugs and adding new features, which are released in major version updates. Despite the emergence of new bundlers in recent years, we still recommend using Webpack.
\\n","featured":false,"flag":"changed","tags":["frontend","coding"],"revisions":[{"release":"2018-03-01","ring":"adopt","body":"In the last few years, Webpack has grown to become the de-facto standard for Web bundling in the JavaScript-Ecosystem. \\nWith Version 3, Webpack is a more robust and better documented bundler with nice new features such as scope hoisting. \\nBecause of this, and because of the continuously growing community, we have adopted Webpack for nearly every single-page application we have.
\\n"},{"release":"2017-03-01","ring":"trial","body":"Webpack is a web bundler for JavaScript applications. Instead of writing scripts to build and bundle your app like you would with Gulp, you just define what files you want to load into your bundle.
\\nIn 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. You can find the right loader in npm.
\\n{\\n test: /\\\\.js$/,\\n loader: 'babel-loader',\\n exclude: /node_modules/,\\n}\\nOn top of that you can use plugins to optimize your bundle like uglifying your code or put your common libraries in a separate file.
\\nUnder the hood, you've got nice features such as:
\\nThe configuration is simple and there is excellent and extensive documentation.
\\n"}],"position":[498,467]},{"id":"wiremock","release":"2021-07-01","title":"WireMock","ring":"adopt","quadrant":"tools","body":"Updated to "adopt".
\\n","featured":false,"flag":"default","revisions":[{"release":"2017-03-01","ring":"trial","body":"WireMock is an HTTP mock server - it can be used to mock APIs for testing.
\\nAt its core, it is a web server that can be prepared to serve canned responses to particular requests (stubbing), and that captures incoming requests so that they can be checked later (verification). It also has an assortment of other useful features including record/playback of interactions with other APIs, injection of faults and delays, simulation of stateful behavior.
\\nIt can be used as a library by any JVM application, or run as a standalone process either on the same host as the system under test or a remote server. All of WireMock's features are accessible via its REST (JSON) interface and its Java API. Additionally, the mock server can be configured via JSON files.
\\nAt AOE, we use WireMock as a standalone server to mock APIs that are outside our system context to get a stable environment for testing and rapid feedback. Besides the decoupled test and development advantages, the mocked APIs can also be used in contract-based tests. We also use embedded WireMock in functional tests to stub external services. The explicit test of faults are especially helpful in building and testing the resilience of your application.
\\nBecause of the features such as flexible deployment, powerful request matching and record/payback interactions, as well as the fact that the server runs stable in our project environments, we classify WireMock as trial.
\\n"}],"position":[412,451]},{"id":"xmlunit","release":"2019-11-01","title":"XMLUnit","ring":"assess","quadrant":"tools","body":"XMLUnit is a Java and .NET testing framework for XML documents. It is very useful for performing contract tests with SOAP interfaces or other XML-based message types.
\\nComparing strings of XML can lead to unstable tests because of the changing order of elements or changed values, etc. XMLUnit provides features to address these issues. It is possible to validate against an XML Schema, use XPath queries or compare against expected outcomes. It also comes with a nice diff-engine which makes it easy to check the parts of an XML document that are important.
\\n","featured":false,"flag":"default","position":[564,650]},{"id":"yarn","release":"2023-11-01","title":"Yarn","ring":"adopt","quadrant":"tools","body":"We have decided to move Yarn into the "adopt" ring as it has continued to establish itself in recent years and has proven to be successful in many of our projects.
\\nYarn consistently offers better performance than npm and, in addition, provides both offline installation and the Plug'n'Play approach. With Plug'n'Play mode, Yarn replaces the node_modules directory with a virtual file system to enhance performance and save disk space.
\\nYarn is an excellent choice for monorepos, thanks to its support for workspaces, and is highly recommended as a package manager.
\\n","featured":false,"flag":"changed","tags":["frontend","coding"],"revisions":[{"release":"2019-11-01","ring":"trial","body":""},{"release":"2018-03-01","ring":"trial","body":"Yarn is a dependency management tool for frontend (node) projects similar to npm. It also uses the npm registry and \\ninfrastructure. According to Yarn, the benefits are that Yarn is much faster, automatically writes a .lock file and \\nbuilds up a local cache to be even faster when installing packages again.
\\nAt AOE, we started using Yarn in different projects to evaluate if we can switch to Yarn for all projects.
\\n"}],"position":[495,509]},{"id":"zero-trust","release":"2023-02-23","title":"Zero Trust","ring":"adopt","quadrant":"methods-and-patterns","body":"Because this approach is more and more used and especially useful for distributed architectures, we updated this item to "adopt" and recommend using it in relevant problem areas.
\\n","featured":false,"flag":"default","tags":["security","architecture"],"revisions":[{"release":"2019-11-01","ring":"trial","body":"Zero Trust is a security model where no trust is assumed within a known network.
\\nWith Zero Trust, there are no assumptions made about the level of trust, and everything is considered untrusted by default. Authentication and authorization occur continuously, rather than just once.
\\nFrameworks like Google's BeyondCorp are built upon that pattern.
\\nClassical security paradigms traditionally safeguard a particular network perimeter, such as a company intranet.
\\nOnce a person is "inside" – for example, by working within the company network or connecting to it through VPN – they are generally deemed trustworthy.
\\nHowever, with the rise of cloud technologies and microservices, and the fact that people are working from various locations, this security model is insufficient. The network perimeter is constantly evolving and expanding.
\\nThis presents challenges for authenticating subjects that previously relied heavily on network segments.
\\nZero Trust assumes that no user, service, or device is trusted by default, regardless of location or network. It requires continuous verification of identity, strict access controls, and consistent monitoring of network activity.
\\nBasic Principles:
\\nIt involves many areas and aspects, including:
\\nIn 2009 Google implemented a zero trust architecture referred to as BeyondCorp. It utilizes OAuth and OpenID standards for implementing Authn and Authz, and has influenced the development of modern Zero Trust architectures.
\\nTypical implementations involve using standards and tools for IAM and SSO, such as Keycloak.
\\nWhile network segments and VPN connections may still be relevant in specific areas, AOE is increasingly implementing a Zero Trust approach in all solutions, components, and services.
\\nWe are currently adopting best practices for Zero Trust, which align with the BeyondCorp framework and utilize the OAuth and OpenID Connect standards.
\\nDCX Technology RadarTechnology RadarDCX Technology RadarEdit this file to your needs to provide an introduction to the technology radar. Explain the purpose of the radar and how it is created. This is a good place to explain the quadrants and rings, too.
Contributions and source code of the AOE Tech Radar are on GitHub: AOE Tech Radar on GitHub
-<<<<<<< HEAD -DCX Technology RadarA selection of programming languages, alongside essential frameworks for building a variety of custom software.
Key software development methods and design patterns, covering everything from continuous integration and testing to architecture.
Technologies and tools for software and infrastructure operations, including platforms and services for managing and scaling applications.
A range of software tools, from simple productivity enhancers to comprehensive project solutions, catering to various project needs.
Technology RadarA selection of programming languages, alongside essential frameworks for building a variety of custom software.
Key software development methods and design patterns, covering everything from continuous integration and testing to architecture.
Technologies and tools for software and infrastructure operations, including platforms and services for managing and scaling applications.
A range of software tools, from simple productivity enhancers to comprehensive project solutions, catering to various project needs.
DCX Technology RadarA selection of programming languages, alongside essential frameworks for building a variety of custom software.
Key software development methods and design patterns, covering everything from continuous integration and testing to architecture.
Technologies and tools for software and infrastructure operations, including platforms and services for managing and scaling applications.
A range of software tools, from simple productivity enhancers to comprehensive project solutions, catering to various project needs.
DCX Technology RadarUpdated to "adopt"
-======= -Technology RadarUpdated to "adopt"
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarIn our backend services, we frequently encounter the task to transform data coming from and uploading to external sources and services.
Building more complex data transformation processes with Akka Actors has proven very difficult for us in the past.
Seeing this data as a stream of elements could allow handling them piece by piece and only keeping as much of the data in-process as can currently be handled.
@@ -10,12 +6,6 @@ It uses the Akka Actor Framework to execute these streams in an asynchronous and parallel fashion exploiting today's multi-core architectures without having the user to interact with Actors directly. It handles things such as message resending in failure cases and preventing message overflow. It is also interoperable with other Reactive Streams implementations.Our first trials with Akka Streams were promising but we haven't yet implemented complex services with it.
-<<<<<<< HEADWe will continue looking into it together with the Alpakka Connectors for integration work.
-We will continue looking into it together with the Alpakka Connectors for integration -work.
-DCX Technology RadarWith the growing adoption of microservice-based architectures, the interest in frameworks and tools that make building systems that follow the reactive manifesto possible has increased.
-======= -Technology RadarWith the growing adoption of microservice-based architectures, the interest in frameworks and tools that make building systems that follow the reactive manifesto possible has increased.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarWith the growing adoption of microservice-based architectures, the interest in frameworks and tools that make building systems that follow the reactive manifesto possible has increased.
Akka provides you a toolkit and runtime based on the Actor model known from Erlang to reach this goal.
It's one of the most-adopted toolkits in its space with its key contributors being heavily involved in the overall movement of the reactive community as well. At AOE, we use Akka when we need high-performance, efficient data processing or where its finite state machine plays nicely with the domain of the application. It is worth mentioning that the actor model might come with extra complexity and therefore should be used in problem spaces where the advantages of this approach bring enough value and no accidental complexity.
@@ -10,8 +6,4 @@Akka provides you a toolkit and runtime based on the Actor model known from Erlang to reach this goal.
It's one of the most-adopted toolkits in its space with its key contributors being heavily involved in the overall movement of the reactive community as well. At AOE, we use Akka when we need high-performance, efficient data processing or where its finite state machine plays nicely with the domain of the application. It is worth mentioning that the actor model might come with extra complexity and therefore should be used in problem spaces where the advantages of this approach bring enough value and no accidental complexity.
-<<<<<<< HEAD -DCX Technology RadarUpdated to "adopt"
+DCX Technology RadarWhen using Akka Streams to build reactive data transformation services you usually need to connect to several services such as FTP, S3 buckets, AMQP brokers or different databases.
Alpakka provides integration building blocks for Akka Streams to access these services in a reactive fashion and contains transformations for working with XML, CSV or JSON structured data.
Combined, Akka Streams and Alpakka enable us to build small reactive integration services with minimal resource consumption and good performance, and are a good alternative to larger ESB solutions or integration tools.
-Technology RadarWhen using Akka Streams to build reactive data transformation services you usually need to connect to several services such as FTP, S3 buckets, AMQP brokers or different databases.
-Alpakka provides integration building blocks for Akka Streams to access these services in a reactive fashion and contains transformations for working with XML, CSV or JSON structured data.
-Combined, Akka Streams and Alpakka enable us to build small reactive integration services with minimal resource consumption and good performance, and are a good alternative to larger ESB solutions or integration tools.
-DCX Technology RadarAngular, now in version 15, remains a robust and well-maintained front-end framework that continues to build new features on its solid foundation. Angular offers excellent tools for building large-scale applications.
-======= -Technology RadarAngular, now in version 15, remains a robust and well-maintained front-end framework that continues to build new features on its solid foundation. Angular offers excellent tools for building large-scale applications.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarAngular, now in version 15, remains a robust and well-maintained front-end framework that continues to build new features on its solid foundation. Angular offers excellent tools for building large-scale applications.
For instance, it includes built-in capabilities for setting up and managing a monorepo, simplifying the sharing of components across multiple projects. As a framework, Angular takes an opinionated approach to solving various problems, reducing the need for extensive decision-making while maintaining consistency, yet still providing flexibility where necessary. Angular 15 further stabilizes standalone components, a feature introduced in Angular 14, with the aim of simplifying Angular applications and reducing module complexity, addressing a common criticism of Angular.
The ease of upgrading to new versions has improved significantly due to the framework's stability and the detailed migration guides provided by the maintainers.
Actually in version 11 Angular has become an adult SPA framework with much faster build time and significant smaller production builds. @@ -23,8 +19,4 @@
It supports DI (dependency injection), it has a clean inheritance and a good separation of concerns. Angular follows the web component standards to avoid negative side effects between components.
We think that Angular is well-structured on both a development and an application level.
When talking about Angular, we must consider the angular.cli as well, which provides a huge level of intelligent automation along the development process and project setup.
-<<<<<<< HEAD -DCX Technology Radar"Camel" is an open source integration framework that empowers you to quickly and easily integrate various systems consuming or producing data.
+DCX Technology Radar"Camel" is an open source integration framework that empowers you to quickly and easily integrate various systems consuming or producing data.
Our teams are using Apache Camel as API Gateway that offers APIs and takes care of Federation to various Backends as well as Authorisation tasks.
-Technology Radar"Camel" is an open source integration framework that empowers you to quickly and easily integrate various systems consuming or producing data.
-Our teams are using Apache Camel as API Gateway that offers APIs and takes care of Federation to various Backends as well as Authorisation tasks.
-DCX Technology RadarWe have been using babel for some time now. Since we have started using it, we don't have to struggle with unimplemented features of ECMAScript. -======= -
Technology RadarWe have been using babel for some time now. Since we have started using it, we don't have to struggle with unimplemented features of ECMAScript. ->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +
DCX Technology RadarWe have been using babel for some time now. Since we have started using it, we don't have to struggle with unimplemented features of ECMAScript. In this regard, JavaScript is JavaScript, no matter what browser you are using. We strongly recommend using Babel or similar solutions (e.g. TypeScript).
Babel gives you the possibility to use the latest features from JavaScript (ECMAScript) in the browser of your choice.
Without Babel you had to use the feature set of your oldest browser or use feature detections such as modernizr or write polyfills on your own.
@@ -32,10 +28,5 @@To know what you need you can practice ECMAScript 6 by doing it with es6katas and ask caniuse.
-<<<<<<< HEADIf you are using TypeScript, Babel is not necessary since you already get the new features with TypeScript.
-If you are using TypeScript, Babel is not necessary since you already get the new features with TypeScript.
-DCX Technology RadarC# is a statically, strongly typed and object-oriented language.
+DCX Technology Radar> 'node'.split('').sort().join('')
-=======
-Deno | Languages & Frameworks | Technology Radar Technology Radar Deno
codingAssess> 'node'.split('').sort().join('')
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3
+Deno | Languages & Frameworks | DCX Technology Radar DCX Technology Radar Deno
codingAssess> 'node'.split('').sort().join('')
> 'deno'
Deno is a secure, modern JavaScript and TypeScript runtime built on the V8 JavaScript engine. It was developed as a more secure and developer-friendly alternative to Node.js by Ryan Dahl, the core author of Node.js.
Deno prioritizes security by default, enforcing strict permissions for file system access, network access, and environment variable usage. It also offers improved performance, thanks to its utilization of the latest JavaScript features and optimizations. Deno supports TypeScript out of the box, allowing developers to take advantage of static type checking and other TypeScript features. It incorporates a built-in module system, reducing dependency conflicts and simplifying module management.
With its streamlined developer experience, which includes a standard library and support for modern language features, Deno offers a compelling option for JavaScript and TypeScript developers.
-<<<<<<< HEAD
-
Flamingo is a high productivity go based framework for rapidly building fast and pluggable web projects. -======= -
Technology RadarFlamingo is a high productivity go based framework for rapidly building fast and pluggable web projects. ->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +
DCX Technology RadarFlamingo is a high productivity go based framework for rapidly building fast and pluggable web projects. It is used to build scalable and maintainable (web)applications.
Flamingo is:
Flamingo itself does not contain ORM Mapper or libraries - instead it emphasizes "ports and adapters" architecture - so that you have a technology free (domain) model and any possible (and replaceable) persistence behind it. That makes Flamingo useful to build microservices and applications - especially to build "frontends" or portals that require interaction with other (micro) services in a distributed architecture. When sticking to the architectural recommendation, you can build modular applications with replaceable adapters that gives you independent testability.
With "Flamingo Commerce" there is an additional active projects that offer rich and flexible features to build modern e-commerce applications.
-Flamingo itself does not contain ORM Mapper or libraries - instead it emphasizes "ports and adapters" architecture - so that you have a technology free (domain) model and any possible (and replaceable) persistence behind it. -That makes Flamingo useful to build microservices and applications - especially to build "frontends" or portals that require interaction with other (micro) services in a distributed architecture. -When sticking to the architectural recommendation, you can build modular applications with replaceable adapters that gives you independent testability.
-With "Flamingo Commerce" there is an additional active projects that offer rich and flexible features to build modern e-commerce applications.
-DCX Technology RadarFlow is a PHP web application framework developed for the Neos project.
-======= -Technology RadarFlow is a PHP web application framework developed for the Neos project.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarFlow is a PHP web application framework developed for the Neos project.
We used Flow in a couple of projects and decided to put it on hold for the following reasons:
Although it could be that some of the above-mentioned aspects have improved in the past, we decided to use other PHP frameworks such as Symfony or other Languages (See Go; Play Framework; Spring Boot)
-Although it could be that some of the above-mentioned aspects have improved in the past, we decided to use other PHP frameworks such as Symfony or other Languages (See Go; Play Framework; Spring Boot)
-DCX Technology RadarFlutter is an open-source SDK developed by Google that allows you to write native applications -======= -
Technology RadarFlutter is an open-source SDK developed by Google that allows you to write native applications ->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +
DCX Technology RadarFlutter is an open-source SDK developed by Google that allows you to write native applications for different platforms with a single code base in Dart.
Flutter provides stable platform implementations for both major mobile platforms iOS and Android. Besides the mobile platforms, it also supports stable builds for Web with multiple rendering engines (DOM and canvas-render). Flutter also @@ -28,8 +24,4 @@
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.
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.
-<<<<<<< HEAD -DCX Technology RadarWe have moved Go to "adopt".
-======= -Technology RadarWe have moved Go to "adopt".
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology Radar2016 was the year of Go, with a lot of Open Source projects gaining a lot of attention and many companies started to use it.
@@ -11,8 +7,4 @@Go, as a programming language, has some very interesting features such as native support for concurrency (go routines), static compiled binaries with a very small memory footprint, cross compiling and much more. A big advantage of Go is the very flat learning curve, which allows developers from more dynamic languages such as PHP to be proficient in a very short time.
If you want to get a feeling for Go, you should start with the online tour, within a day you'll have a good understanding of the core concepts, syntax, etc. - that is also because the language often tries to provide only one simple way of doing things; an example for this is that code formatting and styling is defined (yet not enforced as in Python). Part of this is also that Go itself is very opinionated: So, for example, for object oriented programming in Go, composition is the preferred way of defining data structures, and some might miss advanced concepts such as inheritance.
We currently use Go for projects and microservices where we need flexibility and performance.
-<<<<<<< HEAD -DCX Technology RadarSince the rise of Kotlin, we seen no need why to still use Groovy as an alternative to Java running on the JVM.
+DCX Technology RadarGroovy is a dynamically typed compiled language running on the JVM. It is easy to learn as it provides a familiar syntax for Java programmers, but also offers advanced features such as closures and makes some mandatory Java syntax requirements optional to enhance the conciseness of the code. These features make Groovy especially well-suited for scripting and domain-specific languages. This is used by popular tools such as Gradle or Spock.
At AOE, Groovy is used in many projects and areas. We use Gradle as a build system, we carry out unit and integration testing with Spock and Geb, we generate Jenkins jobs with JobDSL and we implement complete services with Groovy and Spring Boot.
-Technology RadarGroovy is a dynamically typed compiled language running on the JVM. It is easy to learn as it provides a familiar syntax for Java programmers, but also offers advanced features such as closures and makes some mandatory Java syntax requirements optional to enhance the conciseness of the code. These features make Groovy especially well-suited for scripting and domain-specific languages. This is used by popular tools such as Gradle or Spock.
-At AOE, Groovy is used in many projects and areas. We use Gradle as a build system, we carry out unit and integration testing with Spock and Geb, we generate Jenkins jobs with JobDSL and we implement complete services with Groovy and Spring Boot.
-DCX Technology RadarWe adopted GRPC, because it is used on multiple places within our microservice oriented architectures for internal communication.
-======= -Technology RadarWe adopted GRPC, because it is used on multiple places within our microservice oriented architectures for internal communication.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadargRPC, "A high-performance, Open Source, universal RPC framework," is a framework to easily connect clients and servers in an RPC setup. gRPC was initially built at Google, and uses protobuf service definitions for method and payload specification. Essentially, this makes it possible to define methods that a server exposes, with either a single payload or an incoming stream - either as a single response or a stream of responses. @@ -11,8 +7,4 @@
From a technical point of view, gRPC uses HTTP/2 as a transport, directly benefitting from the default TLS encryption. Besides gRPC, other frameworks also use protobuf RPC definitions. These frameworks include twirp from twitch, which makes it easy to change the transport/control layer with only very small changes to the application code.
We at AOE plan to assess gRPC for microservice architectures which are more RPC style and less REST style.
-<<<<<<< HEAD -DCX Technology RadarHot Chocolate is an open-source GraphQL server for .NET. +
DCX Technology RadarHot Chocolate is an open-source GraphQL server for .NET. It is compatible to many GraphQL clients and tools and is really easy to set up and use. We assess it in one of our projects as an alternative to GraphQL .NET.
-Technology RadarHot Chocolate is an open-source GraphQL server for .NET. -It is compatible to many GraphQL clients and tools and is really easy to set up and use. We assess it in one of our -projects as an alternative to GraphQL .NET.
-DCX Technology RadarTechnology RadarDCX Technology RadarDCX Technology RadarJava is a versatile and widely-used programming language.
-======= -Technology RadarJava is a versatile and widely-used programming language.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarJava is a versatile and widely-used programming language.
It is scalable and platform-independent, making it the ideal choice for businesses looking to streamline their operations and reach a wider audience. With its broad library of tools, frameworks and modules, Java provides developers with the resources they need to create dynamic, feature-rich applications that can be easily integrated into existing @@ -12,8 +8,4 @@ great support from the open source community and lots of other big advantages, we often we use Spring Boot combined with the strengths of java to develop web services that fits the needs of our customers.
-<<<<<<< HEAD -DCX Technology RadarKotlin is used successfully in production by multiple teams.
-======= -Technology RadarKotlin is used successfully in production by multiple teams.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarKotlin is used successfully in production by multiple teams.
Kotlin is 100% interoperable with Java. It means the code can live side-by-side in one code base and interact. From the beginning it was designed with practical thought in mind. So the IDE Support in IntelliJ is really great.
The Spring Framework Developer put a lot of effort that Springs play well together with Kotlin.
With its concise syntax, null safety, Due to its explicit type system, this language is also great replacement for Groovy usage with Gradle.
-<<<<<<< HEAD -DCX Technology RadarWe are convinced that Next.js is one of the go-to frameworks for React, and we're excited about the features that version 13 has brought with it. During the Next.js Conf 2022, the team announced some exciting adaptations in this release, but the most interesting one is the new "app" router. In collaboration with the React team, this new routing architecture brings some of the newest and most promising features of React 18 to life.
+DCX Technology RadarWe are convinced that Next.js is one of the go-to frameworks for React, and we're excited about the features that version 13 has brought with it. During the Next.js Conf 2022, the team announced some exciting adaptations in this release, but the most interesting one is the new "app" router. In collaboration with the React team, this new routing architecture brings some of the newest and most promising features of React 18 to life.
When using the app router, every component, by default, becomes a React Server Component, making it one of the first real integrations of this pattern in a framework. The goal is to build complex interfaces while minimizing the amount of JavaScript shipped to the client. Another exciting feature is Streaming, which allows incremental transfer of parts of the UI to the client as they become ready. For example, immediately showing some fallback UI until an asynchronous action is completed, and then streaming the final UI to the client. With the app router, it's also possible to easily create shared layouts that preserve state during navigation and remain interactive.
-======= -Technology RadarWe are convinced that Next.js is one of the go-to frameworks for React, and we're excited about the features that version 13 has brought with it. During the Next.js Conf 2022, the team announced some exciting adaptations in this release, but the most interesting one is the new "app" router. In collaboration with the React team, this new routing architecture brings some of the newest and most promising features of React 18 to life.
-When using the app router, every component, by default, becomes a React Server Component, making it one of the first real integrations of this pattern in a framework. The goal is to build complex interfaces while minimizing the amount of JavaScript shipped to the client. Another exciting feature is Streaming, which allows incremental transfer of parts of the UI to the client as they become ready. For example, immediately showing some fallback UI until an asynchronous action is completed, and then streaming the final UI to the client. With the app router, it's also possible to easily create shared layouts that preserve state during navigation and remain interactive.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3The good thing is that this new architecture can coexist alongside the old page router, giving us the flexibility to incrementally adapt to the new features in existing projects.
Next.js claims itself as the React framework for production. It comes with first-class developer experience and many features for example: hybrid static & server-side rendering, TypeScript support, image optimization, code splitting & much more.
We at AOE are already using Next.js for some big projects. The main reason for that is the modern stack (React with TypeScript) and the possibility to render on the server (static pre-rendering or dynamic SSR) to be able to get crawled by search engines and stay SEO relevant.
Next.js is a JavaScript and React based framework which makes use of server side rendering.
-<<<<<<< HEAD -DCX Technology RadarNode.js is a no- browser JavaScript execution runtime. Its basis is Google's V8 engine. Node is event-driven and follows a non-blocking I/O model.
-======= -Technology RadarNode.js is a no- browser JavaScript execution runtime. Its basis is Google's V8 engine. Node is event-driven and follows a non-blocking I/O model.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarNode.js is a no- browser JavaScript execution runtime. Its basis is Google's V8 engine. Node is event-driven and follows a non-blocking I/O model.
It’s a good choice for restful APIs, realtime purposes or situations where many concurrent connections are expected, where each connection has a lightweight memory footprint.
Node allows separation of concerns by using its package manager npm, which is also the largest ecosystem of Open Source libraries (modules).
Modules are added as dependencies and offer a wide range of functionalities in a range from simple helper functions to mature web frameworks such as express.js.
@@ -14,8 +10,4 @@Modules are added as dependencies and offer a wide range of functionalities in a range from simple helper functions to mature web frameworks such as express.js.
Many PaaS providers (AWS, Google Cloud Platform, Azure) support node, including deployment and monitoring services out of the box for scalable stateless applications.
At AOE, we successfully use node.js-based applications for smaller services or internal tools such dashboards.
-<<<<<<< HEAD -DCX Technology RadarPHP 5 has been around for a very long time, and can be considered as the PHP version that defined where PHP wants to go in the future. -======= -
Technology RadarPHP 5 has been around for a very long time, and can be considered as the PHP version that defined where PHP wants to go in the future. ->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +
DCX Technology RadarPHP 5 has been around for a very long time, and can be considered as the PHP version that defined where PHP wants to go in the future. With proper OOP, support for clojures and a steadily improving type system, it has become a very mature language. However, in the past 3 years, Facebook introduced HHVM, which became a major influence on PHP 7 and eventually brought a lot of improvements not only for the execution speed, but also with proper type hints and other features.
Here at AOE, we have numerous PHP projects, and we often kept it backwards-compatible to make sure that it will run on older systems. This is comparable to the procedure most frameworks (Magento, OroPlatform and derived projects) use.
Now, PHP 5 has reached its end--of-life, and it is time to discontinue the backwards-compatibility in favor of better and more stable applications. Even though we can use the PHP 7 runtime while being PHP 5-compatible, it is not considered good practice anymore, as we can now rely on the PHP 7 features and use all of its advantages.
-<<<<<<< HEADOne of the major points PHP 7 supports is proper type hinting and return types (apart from PhpDocs), which makes static analysis much easier and can improve the overall code quality significantly.
-One of the major points PHP 7 supports is proper type hinting and return types (apart from PhpDocs), which makes static analysis much easier and can improve the overall code quality significantly.
-DCX Technology RadarThe Play Framework is a lightweight (web)application framework for Java and Scala programmers.
-======= -Technology RadarThe Play Framework is a lightweight (web)application framework for Java and Scala programmers.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarThe Play Framework is a lightweight (web)application framework for Java and Scala programmers.
A developer can choose from different modules to include necessary functionality such s accessing http resources, databases, and so on. As a consequence, the developer can choose, and is not distracted by or clobbered with irrelevant things. This approach is considered as minimalistic, but it is easy to include necessary functionality.
Regarding the architecture, Play is stateless and built on Akka. As a consequence, Play applications have much lower resource consumption regarding CPU und memory and can scale easily. Play manages concurrency without binding a request to a thread until the response is ready.
With the use of "Futures" in your code you can turn synchronous tasks (such as IO or API call to another service) into asynchronous and you can build non-blocking applications. It is recommended to understand the principles Play uses to achieve performance and scalability.
Play can act as backend service delivering JSON, for example. For building web applications. The Twirl template engine enables server-side rendering of HTML pages. These HTML pages can include CSS and JavaScript parts of your own choice.
-<<<<<<< HEAD -DCX Technology RadarIn an increasingly microservice-oriented environment, it is crucial that all parties agree on a common language and wire format for data exchange.
-======= -Technology RadarIn an increasingly microservice-oriented environment, it is crucial that all parties agree on a common language and wire format for data exchange.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarIn an increasingly microservice-oriented environment, it is crucial that all parties agree on a common language and wire format for data exchange.
JSON and XML are two well-known formats for serialization of data; however, they come with a few drawbacks. JSON is completely dynamic without any validation (though there is json-schema) and XML uses an extremely heavyweight syntax, which carries a huge overhead, so parsing and transport becomes quite slow.
Protobuf, amongst others, is an approach to solving this problem by using well-defined schemas to create language-specific code, which serializes/marshals and deserializes/unmarshals data. One of the key features is the built-in support for evolving schemas; it is easily possible to incrementally extend the definition while staying backwards-compatible and compose messages consisting of several sub-messages.
If you are looking for a way to have different systems agree on a common protocol on top of a transport layer (such as AMQP or HTTP), Protobuf is definitely worth examining more closely and should be assessed.
@@ -10,8 +6,4 @@JSON and XML are two well-known formats for serialization of data; however, they come with a few drawbacks. JSON is completely dynamic without any validation (though there is json-schema) and XML uses an extremely heavyweight syntax, which carries a huge overhead, so parsing and transport becomes quite slow.
Protobuf, amongst others, is an approach to solving this problem by using well-defined schemas to create language-specific code, which serializes/marshals and deserializes/unmarshals data. One of the key features is the built-in support for evolving schemas; it is easily possible to incrementally extend the definition while staying backwards-compatible and compose messages consisting of several sub-messages.
If you are looking for a way to have different systems agree on a common protocol on top of a transport layer (such as AMQP or HTTP), Protobuf is definitely worth examining more closely and should be assessed.
-<<<<<<< HEAD -DCX Technology RadarSince the RAML project has decided to join the OpenAPI initiative and the RAML ecosystem lacks further development and additional tools, we decided to use and recommend using "OpenAPI specification (OAS)" as description standard instead.
+DCX Technology RadarSince the RAML project has decided to join the OpenAPI initiative and the RAML ecosystem lacks further development and additional tools, we decided to use and recommend using "OpenAPI specification (OAS)" as description standard instead.
RAML still provides advantages in modeling an API through it's more expressive modeling language and can produce OAS
RAML (the RESTful API Modelling Language) is a YAML-based API specification language. It's now available in version 1.0. The philosophy behind it is to specify the API before implementation.
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 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; api-workbench), automatically generated documentation, code generation (e.g. go-raml), mocking, testing and much more. We prefer RAML over Swagger because of this.
-Technology RadarSince the RAML project has decided to join the OpenAPI initiative and the RAML ecosystem lacks further development and additional tools, we decided to use and recommend using "OpenAPI specification (OAS)" as description standard instead.
-RAML still provides advantages in modeling an API through it's more expressive modeling language and can produce OAS
-RAML (the RESTful API Modelling Language) is a YAML-based API specification language. It's now available in version 1.0. The philosophy behind it is to specify the API before implementation.
-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 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; api-workbench), automatically generated documentation, code generation (e.g. go-raml), mocking, testing and much more. We prefer RAML over Swagger because of this.
-DCX Technology RadarReact Native is an open-source UI software framework used to build applications for Android, Android TV, iOS, macOS, tvOS, Web, Windows, and UWP. It enables developers to utilize the React framework alongside native platform features.
+DCX Technology RadarReact Native is an open-source UI software framework used to build applications for Android, Android TV, iOS, macOS, tvOS, Web, Windows, and UWP. It enables developers to utilize the React framework alongside native platform features.
Developing applications with a single codebase can help ensure consistent user experiences across platforms, while also delivering the performance advantages of native code.
-Technology RadarReact Native is an open-source UI software framework used to build applications for Android, Android TV, iOS, macOS, tvOS, Web, Windows, and UWP. It enables developers to utilize the React framework alongside native platform features.
-Developing applications with a single codebase can help ensure consistent user experiences across platforms, while also delivering the performance advantages of native code.
-DCX Technology RadarReact today is the most widely used frontend library within our company, employed in various forms. Whether it's integrated into frameworks like NextJS and Remix or utilized for client-side-only applications, React plays a significant role in many of our ongoing projects. Over time, a community of experts has emerged within the company.
-======= -Technology RadarReact today is the most widely used frontend library within our company, employed in various forms. Whether it's integrated into frameworks like NextJS and Remix or utilized for client-side-only applications, React plays a significant role in many of our ongoing projects. Over time, a community of experts has emerged within the company.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3 +DCX Technology RadarReact today is the most widely used frontend library within our company, employed in various forms. Whether it's integrated into frameworks like NextJS and Remix or utilized for client-side-only applications, React plays a significant role in many of our ongoing projects. Over time, a community of experts has emerged within the company.
We firmly believe that React 18, with its range of new features, will further enhance its popularity within our company and the broader community.
While not an entirely new feature, Suspense was initially introduced in a basic version back in 2018. However, it had certain limitations. Its first official use case was code splitting with React.lazy, but this feature was only available on the client side, not during server rendering. The primary goal has always been to enhance the loading experience both on the client and server. With React 18, Suspense now enables Streaming server rendering, a new feature that allows React to send the HTML of the loading fallback first and then, after loading completes, send the actual HTML content to the client. The React team continues to work on improving Suspense, particularly to enable data fetching libraries to use it. They are collaborating with authors of some of the most prominent libraries like TanStack Query, SWR, and Apollo.
Server Components represent a new paradigm in React application architecture with the goal of minimizing the amount of JavaScript sent to the client. This approach introduces a new type of component that operates exclusively on the server. It shows great promise, which is why we have given React Server Components a dedicated entry on our Tech Radar.
-======= -Server Components represent a new paradigm in React application architecture with the goal of minimizing the amount of JavaScript sent to the client. This approach introduces a new type of component that operates exclusively on the server. It shows great promise, which is why we have given React Server Components a dedicated entry on our Tech Radar.
->>>>>>> 37a86c988738beca3cf9da4ce3f17673fe89c6c3This is a fundamental update to React's rendering model, primarily occurring under the hood. It introduces the ability to create multiple versions of a user interface concurrently. With concurrent React, rendering can be interrupted, abandoned, and resumed, allowing the application to respond to user interactions immediately, even if it's currently in the middle of rendering.
The React team is collaborating closely with some of the major players in the React ecosystem to stabilize and enhance the library. They are also experimenting with new features, ensuring that React remains as exciting as ever.
@@ -30,8 +22,4 @@After some 1.5 years of experience with React and the steady growth of the community and ecosystem around it, we can confidently say that we still see great potential to build upcoming projects with React.
-<<<<<<< HEAD -DCX Technology RadarRedux helps us to maintain state in our frontend applications in a more predictable and clearer way. It is extendable though middleware, it has a great documentation and some awesome devtools that are especially helpful when you are new to Redux.
+DCX Technology RadarRedux helps us to maintain state in our frontend applications in a more predictable and clearer way. It is extendable though middleware, it has a great documentation and some awesome devtools that are especially helpful when you are new to Redux.
The functional concepts for updating the state, combined with immutable data, lead to extremely easy and enjoyable unit tests - this is maybe the biggest plus for us developers.
The official react-redux bindings also made it straightforward to weave Redux into our React applications. For asynchronous actions we use redux-sagas which has proven itself as a better alternative for redux-thunk.
Currently, we use Redux only in our React projects, but we are evaluating it together with other frameworks such as Angular or Vue.js, as well.
-Technology RadarRedux helps us to maintain state in our frontend applications in a more predictable and clearer way. It is extendable though middleware, it has a great documentation and some awesome devtools that are especially helpful when you are new to Redux.
-The functional concepts for updating the state, combined with immutable data, lead to extremely easy and enjoyable unit tests - this is maybe the biggest plus for us developers.
-The official react-redux bindings also made it straightforward to weave Redux into our React applications. For asynchronous actions we use redux-sagas which has proven itself as a better alternative for redux-thunk.
-Currently, we use Redux only in our React projects, but we are evaluating it together with other frameworks such as Angular or Vue.js, as well.
-