GROUP9 Tech Radar 2023

This year, like the previous years, we held another Tech Radar. The Tech Radar tells us which new technologies, frameworks, languages and tools we should use in production, which we should start investigating or execution proof-of-concepts with, and which we should abandon, all according to our consultants. 

Tech Radar for visualising Technology Strategy. What is it and how to build  it? - DEV Community

A Tech Radar, an approach started by Thoughtworks, consists out of 4 quadrants and 4 rings. The Quadrants are:

  • Platforms: The basic platform to build software upon. Examples from the Java world of course include Jakarta EE and SpringBoot, from an infrastructure perspective, Kubernetes is a good example.
  • Languages and Frameworks: The programming languages and frameworks used to build software, like of course Java itself, but also Kotlin.
  • Tools: Tools we use to build software with. Jetbrains IntelliJ comes to mind, but also Atlassian Jira.
  • Techniques: The "rest": methodologies, process approaches, etc. 
Technologies fall into one of these Quadrants to categorize them. Then, during the creation of the Tech Radar, you assign a Ring to each of these Technologies:
  • Assess: The first step in the lifecycle. Start assessing whether these technologies are worth investigating for your company. Most of these might not yet be production ready.
  • Trial: The second phase: products are more mature, and you can actually start using them in small and non-critical projects of PoCs to verify their value
  • Adopt: The production phase: these are mature products, with a proven track record, which you should be using in production (where applicable) as your go-to choice.
  • Hold: The end-of-life phase: although mature, these products have probably reached their end-of-life and should be replaced with better products (of course if this brings a competitive advantage). New projects shouldn't normally use products in this category.

The TL;DR version

There were three clear winners to focus on:

  • Artificial Intelligence (Trial)
  • Quarkus (Adopt)
  • KNative (Trial)
ChatGPT Logo PNG Images With Transparent Background

AI (in the form of ChatGPT) is of course a no-brainer these days, and should be something you should be experimenting with soon if you haven't started already. We see Quarkus, the blazing fast Jakarta EE/Reactive based platform for developing applications and a big, production ready contender for SpringBoot. Finally, KNative, the Kuberbetes technology to run serverless functions is slowly gaining more traction and can be an interesting add-on for running small tasks on your existing Kubernetes clusters.

Other interesting technologies to use right now (Adopt): CamundaDevOpsGitOpsCloud Cost Awareness. For those more daring or looking into the future, start assessing Firebase FirestoreJetbrains SpacesReactive programmingWeb Assembly and GraalVM.

The process

This year, we decided to not focus on updating the full list in the company gathering, but instead focus on the big changes and really interesting topics. Running through 200-300 technologies can be quite a tedious task, where most change only slightly. So we wanted to focus the brain power of our consultants on those few technologies which can really make a change for you.

We started out in various groups, did brainstorm sessions on the most interesting topics, and afterwards used a lot of discussions, clarifications and finally dot voting to come up with the most interesting or noteworthy topics per group. 

Those results were then merged across the groups, which resulted in the final list you see presented today.

The results: most interesting new topics

As indicated in the TL;DR version, ChatGPT, Github CoPilot and alike technologies (in general, the large language models and developer-assisting-AI) are popping up everywhere. Almost everyday we see new possibilities of these technologies, but also a lot of questions. Currently, ChatGPT and alike technologies are racing to the top of the hype-cycle. Our current expectations are:

  • We will see a lot of interesting new possibilities to drive developer productivity
  • There are still a lot of questions to be answered on how to best use it.
  • There are quite some risks involved if these tools are used in an irresponsible way.
  • We will see quite a disillusionment when people find out the limitations of these technologies. Compare AI to a growing up child right now: it has an enormous potential, but you really need to hold its hand because it can and will get you into trouble otherwise.
Gartner hype cycle - Wikipedia

Quarkus has matured into the big contender for Spring Boot in the application platform area for Java based applications. We welcome this change, as the Java ecosystem has always been known to see the largest influx of innovations when there are multiple platforms competing for the top spot, where each is able to learn from the others innovations. Also, using Quarkus allows more traditional organizations to leverage existing Java EE knowledge, while still running on modern platforms.

Finally KNative provides the standardization of various serverless functions platforms like AWS Lambda and GCP Functions. Best of all, you can run these workloads on your Kubernetes clusters, giving developers more options in selecting the best tools for the smaller pieces of logic needed in your application, while reducing the vendor lock-in for the products this technology originated from. 

These are the technologies you currently should be using:

  • Camunda (Adopt) - Best in class currently for supporting BPMN, the change they made with Camunda 8 might be interesting and needs some Trial work first.
  • DevOps (Adopt) - In you're not yet doing DevOps these days, you're missing out. In practice though, we still see a lot of value to be gained in optimizing DevOps within various organizations. 
  • GitOps (Adopt) - Managing your infrastructure as code in version control and directly rolling out changes based on that can greatly reduce risk, outages, etc. 
  • Cloud Cost Awareness (Adopt) - Cloud is great, but can incur a lot of costs if used incorrectly. To avoid a hefty bill, you should be doing this.

And for the new contenders:

  • Firestore (Assess) - If you're running on GCP of course, even using this for the non-regular case (mobile apps) Firestore or the alike on-prem variants offer a nice approach to deliver data to your applications. This approach really fits nicely with a CQRS based architecture.
  • Jetbrains Space (Assess) - The new competitor for the Atlassian, Gitlab and Github stacks. We especially like the integration of course with Jetbrains' flagship product IntelliJ
  • Reactive (Assess) - Promises to deliver better performance and usage of CPU cores over traditional programming models. The downside is mostly the programming model which can be something you need to get used to. We hope new language features and new JVM features support reactive programming will improve this. 
  • WebAssembly (Assess) - Still quite young and the technology needs to mature, but we might see the same shift as for JavaScript, where a pure front-end only technology suddenly proved highly valuable in the backend.
  • GraalVM (Trial) - For the blazing fast microservices with very fast boot-times. The usage of this is still quite specialized and requires upfront thinking about the frameworks you intend to use.

What you should stop using

This year, we only had a few items in the Hold category: those technologies you need to think about whether you want to continue using them or move to a better alternative.

  • Angular ( replace with e.g. React ): We see React and other approaches as more light-weight. Angular is obviously not yet obsolete, still under active development and support, and you might have quite some knowledge invested in it. However, the basic component model can be somewhat heavy-weight, whereas newer approach may ease developing your front-end applications
  • Lombok ( replace with regular Java or Kotlin ): Lombok started out as an add-on for Java to reduce boilerplate code. With the recent additions in newer Java versions, like records, the value of these additions largely diminishes. There are some cases where Lombok can provide some value, but you might want to question whether the extra framework and under-the-hood-bytecode-engineering is really worth it. Another alternative is switching to Kotlin, which is more feature packed and doesn't need Lombok at all.
  • JMS ( replace with e.g. Kafka ): Most JMS servers still require quite a large installation, making them hard to run alongside the more microservices oriented landscapes we see these days. Alternatives like Kafka offer a wider feature set, while being more lightweight for the development scenario. Note that we don't necessarily have issues with the JMS API, but more with the traditionally more heavy-weight server implementations. If you do switch from JMS to Kafka, be aware that transactions (especially XA - 2-phase commit) are not supported and require manual implementation.
  • Docker Compose ( replace with kind or minikube ): It's getting more and more easy to run a Kubernetes cluster on your developer machine or connect to a provided company wide cluster / cloud based setup. Using those has the advantage that you don't need to maintain two deployment configurations. 
  • K9s (use GitOps and the regular k8s CLI): While K9S is not a bad product, you probably want to use GitOps anyway. For low level debugging, the native Kubernetes CLI tools are often better. 

How are we going to use this?

First of all, we are currently encouraging our consultants to start using AI based tools like ChatGPT, Github Copilot and others in a responsible way. There's still a lot of questions, also legal ones, so we came up with a general policy that fosters innovations, allows our high-potential junior developers of the bright-r program to still get a good foundation, whilst at the same time protecting our customers' intellectual property. 

Second, at group9, we started an proces where we will start educating our own consultants in the top technologies from our Tech Radar. Currently, we have a group of about 20 people who are actively working on getting certified in Kubernetes and KNative technologies. Afterwards, we will start organized courses for Quarkus. 

An essential part of these courses is hosting get-togethers where participants of the courses get to discuss the various technologies and focus on identifying best-practices or areas where there might be a gap in the available knowledge in applying these technologies. We are a firm believer that we are able to deliver the best value to our customers if our consultants not only have extended factual knowledge of these technologies, but also know best-practices and the pitfalls if you apply these technologies.

If you want to have your staff also get educated the group9 way, delivering the best value when applying technologies in a sensible way for your organization, contact the alfa1 academy.


Populaire posts van deze blog

New whitepaper: The Software Factory