Enable javascript in your browser for better experience. Need to know to enable it? Go here.

Languages & Frameworks

Adopt ?

  • In a move that mirrors Apple's introduction of SwiftUI, Google introduced Jetpack Compose as a new and quite different approach to building user interfaces for modern Android applications. Compose brings more powerful tools and an intuitive Kotlin API. In most cases less code is needed, and it has become easier to create user interfaces at runtime rather than defining a static UI that can be filled with data. With Compose Multiplatform and Kotlin Multiplatform developers now have a unified toolkit to build desktop, web and native Android apps. Wear OS 3.0+ is included, too, and with support for iOS already present in Kotlin Multiplatform Mobile, it's likely that iOS will be supported by Compose in the future.

  • React Hooks have introduced a new approach to managing stateful logic; given React components have always been closer to functions than classes, Hooks have embraced this and brought state to the functions, instead of using classes to take function to the state with methods. Another staple of state management in React applications is Redux, and we've already noted that it has come under scrutiny, suggesting that sometimes the complexity of Redux isn't worth it and in such cases a simple approach using Hooks is preferable. Rolling this completely on your own can quickly become tricky; therefore we recommend considering a combination of React Context and the useContext and useReducer hooks, along the lines explained in this blog post.

Trial ?

  • Arium is an automated testing framework for 3D applications written in Unity. Functional tests are an important part of a healthy test pyramid. Arium, which is built as a wrapper on the Unity Test framework, lets you write functional tests for 3D apps on multiple platforms. We've used it successfully in a few of our projects.

  • Chakra UI is a UI component library for React.js that is designed for accessibility. We like it, especially for its accessibility features, including dark mode and compatibility with the Web Accessibility Initiative – Accessible Rich Internet Applications (WAI-ARIA) guidelines. Moreover, it is easy to test and customize which makes for a good development experience, accelerating the development process of UI solutions in production environments.

  • DoWhy is a Python library to perform end-to-end causal inference and analysis. Although machine-learning models can make predictions based on factual data, exploiting the correlation of variables that were present at the time, they're insufficient in scenarios where we need to ask What if and Why questions: What if a variable changed? What would be the impact on the outcome? Causal inference is an approach to answer such questions. It estimates the causal effect, that is, the magnitude by which an outcome would change, if we changed one of the causal variables. This approach is applied when we can't arrive at the answer through observations and collecting data from A/B testing — due to the cost of experiments or limitations. The DoWhy library estimates the causal effect based on a process that uses the past collected facts and data as well as assumptions one can make knowing the domain. It uses a four-step process of modeling the causal relationships graph based on assumptions, identifying a cause for an outcome, estimating the causal effect and finally challenging those assumptions by refuting the result. We've used this library successfully in production, and it's one of the commonly used libraries in causal estimation use cases.

  • Although several frameworks promise the same ease of development and scalability typical of static site generators, we continue to have good experiences with Gatsby.js. In particular we've used it to build and deploy websites that scale to very large numbers of users without having to worry about capacity planning or deployment infrastructure. Our developers have also been impressed by the focus on accessibility and support for old browsers and that they could reuse their React.js experience. All in all, we feel Gatsby has matured well and is a solid choice in this space.

  • Jetpack Hilt has recently reached version 1.0, and we can report that we've had good experiences with it. Jetpack Hilt offers extensions for integrating Hilt with various other AndroidX libraries, such as WorkManager and Navigation. It further expands the reach of Hilt, to provide developers with a standard way of incorporating Dagger dependency injection into Android applications. We've featured Koin as a Kotlin-native dependency injection framework in the Radar before, and we would advise against attempting to replace Koin in a large existing codebase. However, when starting a new project, Hilt, it seems, is now the way to go.

  • For many organizations, cross-platform mobile development is becoming a strong option especially as the end-to-end experience of building mobile cross-platform applications becomes more enjoyable and efficient. Kotlin Multiplatform Mobile (KMM) is an SDK provided by JetBrains that leverages the multiplatform capabilities in Kotlin and includes tools and features designed to streamline the developer experience. With KMM you write code once for business logic and the app core in Kotlin and then share it with both Android and iOS applications. You write platform-specific code only when necessary, for example, to take advantage of native UI elements; and the specific code is kept in different views for each platform. We're moving KMM to Trial as it is evolving rapidly and we're seeing a few organizations use this as their default.

  • lifelines is a library for survival analysis in Python. Originally developed for birth and death events, it has evolved into a complete survival analysis library to predict any duration of time. Beyond medical use cases (such as answering, How long does this population live for?), we've used it in retail and manufacturing to answer questions like How long users are subscribed to a service? or When should we do the next preventive maintenance?

  • Web applications, especially those for internal use in enterprises, are usually written in two parts. The user interface and some business logic run in the web browser while business logic, authorization and persistence run on a server. These two halves normally communicate via JSON over HTTP. The endpoints shouldn't be mistaken for a real API; they're simply an implementation detail of an application that is split across two run-time environments. At the same time, they provide a valid seam to test the pieces individually. When testing the JavaScript part, the server side can be stubbed and mocked at the network level by a tool such as Mountebank. Mock Service Worker offers an alternative approach of intercepting requests in the browser. This simplifies manual tests as well. Like Mountebank, Mock Service Worker is run outside the browser as a Node.js process for testing network interactions. In addition to REST interactions, it mocks GraphQL APIs — a bonus because GraphQL can be complex to mock manually at the network level.

  • State management in React applications has been a recurring topic in the Radar, and we've recently clarified our position on Redux, a popular framework in this space. NgRx is, in essence, Redux for Angular. It's a framework for building reactive applications with Angular, providing ways to manage state and to isolate side effects. Our teams report that picking up NgRx was straightforward, not the least because it is built with RxJS, and they highlight a trade-off similar to the one we know from Redux: adding reactive state management comes with added complexity that only pays off in larger applications. The developer experience is enhanced by schematics, a scaffolding library and a set of tools that enable visual tracking of state and time-travel debugging.

  • Originally type annotations were added to Python to support static analysis. However, considering how widely type annotations, and annotations in general, are used in other programming languages, it was only a matter of time before developers would begin to use Python's type annotations for other purposes. pydantic falls into this category. It allows you to use type annotations for data validation and settings management at run time. When data arrives as, say, a JSON document and needs to be parsed into a complex Python structure, pydantic ensures that the incoming data matches the expected types or reports an error if it doesn't. Although you can use pydantic directly, many developers have used it as part of FastAPI, one of the most popular Python web frameworks. In fact, using pydantic in FastAPI is considered so indispensable that a recently proposed change to Python, aimed at reducing the cost of loading annotated code into memory, was reconsidered because it would have broken the use of type annotations at run time.

  • We assessed Quarkus two years ago, and now our teams have more experience with it. Quarkus is a Kubernetes-native Java stack tailored for OpenJDK HotSpot and GraalVM. Over the past two years, Quarkus has wired those best-of-breed libraries in the Java world and streamlined the code configuration, giving our teams a pretty good developer experience. Quarkus has a very fast boot time (tens of milliseconds) and a low RSS memory footprint; this is because of its container-first building approach: it uses ahead-of-time compilation techniques to do dependency injection at compile time and thus avoids the run-time costs of reflection. Our team has also had to endure the trade-offs: it takes nearly 10 minutes for Quarkus to build on our pipeline; some features that rely on annotations and reflection (such as ORM and serializer) are also limited. Part of these trade-offs are the result of using GraalVM. So if your application is not running for FaaS, using Quarkus with HotSpot is also a good choice.

  • If we want animations in React Native applications, React Native Reanimated 2.0 is the way to go. We previously had Reanimated 1.x, but it had issues related to the complexity of the Reanimated declarative language and also had some additional performance costs related to initialization and communication between the React Native JavaScript thread and the UI thread. Reanimated 2.0 is an attempt at reimagining how to run animations in the UI thread; it allows us to code the animations in JavaScript and run them on the UI thread using a new API called animation worklets. It does this by spawning a secondary JavaScript context on the UI thread that then is able to run JavaScript functions. We're using it in our React Native projects which need animations and like it a lot.

  • React Query is often described as the missing data-fetching library for React. Fetching, caching, synchronizing and updating server state is a common requirement in many React applications, and although the requirements are well-understood, getting the implementation right is notoriously difficult. React Query provides a straightforward solution using hooks. As an application developer you simply pass a function that resolves your data and leave everything else to the framework. We like that it works out-of-the-box but still offers a lot of configuration when needed. The developer tools, unfortunately not yet available for React Native, do help with understanding of how the framework works, which benefits developers new to it. In our experience, version 3 of the framework brought the stability needed to be used in production with our clients.

  • Our developers have continued to be productive with Tailwind CSS and are impressed with its ability to scale with large teams and codebases. Tailwind CSS offers an alternative approach to CSS tools and frameworks that reduces complexity through lower-level utility CSS classes. The Tailwind CSS classes can easily be customized to suit any customer's visual identity. We've also found that it pairs particularly well with Headless UI. Tailwind CSS allows you to avoid writing any classes or CSS on your own which leads to a more maintainable codebase in the long term. It seems that Tailwind CSS offers the right balance between reusability and customization to create visual components.

  • Since we first mentioned TensorFlow Lite in the Radar in 2018, we've used it in several products and are happy to report that it works as advertised. The standard use case is to integrate pretrained models into mobile apps, but TensorFlow Lite also supports on-device learning which opens further areas of application. Numerous examples on the website showcase many common areas of application, such as image classification and object detection, but also hint at new ways of interaction using, for example, pose estimation and gesture recognition.

  • We first mentioned Three.js in the Radar in Assess back in 2017. Since then, this 3D rendering library for the web has evolved and improved rapidly. The standard WebGL APIs have improved, and Three.js has added support for WebXR, turning it into a viable tool for creating immersive experiences. At the same time, browser support for 3D rendering and WebXR device APIs has improved, making the web an increasingly attractive platform for 3D content. Although there are other 3D rendering libraries, our teams have come to prefer Three.js, especially when paired with React Three Fiber to abstract away some of the low-level details. We've found that developers still need to be conscious of performance issues and will sometimes need to restructure data to optimize rendering speed.

  • When creating a user interface with SwiftUI, the idea is to build a view model that can be mapped easily to the elements of the user interface. In such cases, most of the testing can be done on the model, using the standard unit testing frameworks which makes these tests straightforward to write and fast to run. To test the bindings between the model and the views, developers usually reach for XCUITest, a test automation framework that launches the full application and remote controls the interface. It works, tests are reasonably stable, but they take a long time to run.

    For a faster approach to writing unit tests for SwiftUI, try ViewInspector, an open-source framework that uses Swift's public reflection API to access the underlying views created by SwiftUI. With ViewInspector, a test simply instantiates a SwiftUI view, locates the interface elements that need to be tested and then makes assertions against them. Basic interactions such as taps can be tested, too. Like many UI testing frameworks, it provides an API to locate interface elements, either by specifying a path through the view hierarchy or by using a set of finder methods. These tests are usually simpler than XCUITests, and they run much faster. As a word of caution, though, given the ease with which tests can be written using ViewInspector, you might be tempted to over-test the interface. Testing simple one-to-one mappings is just double-entry bookkeeping. And even though ViewInspector makes it easier to test the SwiftUI code, remember to keep most of the logic in the model.

  • Vowpal Wabbit is a general-purpose machine-learning library. Even though it was originally created at Yahoo! Research over a decade ago, we still want to mention it to highlight that it continues to be the place where many of the newest machine-learning techniques get added first. If you're interested in machine learning, you may want to keep an eye on the innovations in Vowpal Wabbit. Note also that Microsoft has shown a deeper interest in Vowpal Wabbit in recent years, employing a main contributor and integrating it into their Azure offerings, for example in their machine-learning designer and in Personalizer.

  • Zap is a super performant structured logging library for GoLang which is faster than the standard Log implementation and other logging libraries. Zap has both a "pretty" logger, providing a structured and printf-style interface, as well as an (even) faster implementation with just the structured interface. Our teams have used it extensively at scale and are happy to recommend it as their go-to solution.

Assess ?

  • Headless UI is an unstyled component library for either React.js or Vue.js from the same people that created Tailwind CSS. Our developers like that they don't have to customize or work around the default styles that other component libraries come with. The components' rich functionality and full accessibility, combined with the frictionless styling, allows developers to focus more productively on the business problem and user experience. Unsurprisingly, Headless UI also pairs well with Tailwind CSS classes.

  • InsightFace is an open source 2D and 3D deep face analysis toolbox, mainly based on PyTorch and MXNet. InsightFace uses some of the most recent and accurate methods for face detection, face recognition and face alignment. We're particularly interested in it, because it has one of the best implementations for ArcFace, a cutting-edge machine-learning model that detects the similarities of two images. InsightFace with ArcFace received a 99.83% accuracy score on the Labeled Faces in the Wild (LFW) data set. We're experimenting with it in the context of facial deduplication and have seen promising results.

  • Kats is a lightweight framework for performing time series analyses, recently released by Facebook Research. Time series analysis is an important area in data science; it encompasses the problem domains of forecasting, detection (including the detection of seasonalities, outliers and change points), feature extraction and multivariate analysis. Typically we tend to have different libraries for different techniques in a time series analysis. Kats though aims to be a one-stop shop for time series analyses and provides a set of algorithms and models for all the time series analysis problem domains. Previously we mentioned Prophet, also by Facebook Research, which is one of the models Kats implements for forecasting. We're looking forward to trying Kats in problems involving time series analyses.

  • If you're using Apache Kafka and building stream-processing applications, ksqlDB is a great framework for writing simple applications using SQL-like statements. ksqlDB is not a traditional SQL database. However, it allows you to use lightweight SQL-like statements to build new Kafka streams or tables on top of the existing Kafka topics. The queries can pull data, similar to reading from a traditional database, or push results to the application when incremental changes occur. You can choose to run it as a standalone server natively as part of your existing Apache Kafka installation or as a fully managed service on Confluent Cloud. We're using ksqlDB in simple data-processing use cases. In more complex use cases, where an application requires programming code beyond algebraic SQL queries, we continue to use data-processing frameworks such as Apache Spark or Apache Flink on top of Kafka. We recommend experimenting with ksqlDB in scenarios where the simplicity of the application allows it.

  • Polars is an in-memory data frame library implemented in Rust. Unlike other data frames (such as Pandas), Polars is multithreaded and safe for parallel operations. The in-memory data is organized in the Apache Arrow format for efficient analytic operations and to enable interoperability with other tools. If you're familiar with Pandas, you can quickly get started with Polars' Python bindings. We believe Polars, with Rust implementation and Python bindings, is a performant in-memory data frame to assess for your analytical needs.

  • PyTorch Geometric is a geometric deep learning extension library for PyTorch. Geometric deep learning aims to build neural networks that can learn from non-Euclidean data like graphs. Graph network-based machine-learning approaches have been of increasing interest in social network modeling and in biomedical fields, specifically in drug discovery. PyTorch Geometric provides an easy-to-use library to design complicated graph network problems like protein structure representation. It has GPU and CPU support and includes a good collection of graph-based machine-learning algorithms based on recent research.

  • Micro frontends have continued to gain in popularity since they were first introduced. However, it's easy to fall into micro frontend anarchy if teams fail to maintain consistency across an application, from styling technique to state management. Qiankun, which means heaven and earth in Chinese, is a JavaScript library built to provide an out-of-the-box solution for this. Qiankun is based on single-spa, so it allows different frameworks to coexist in a single application. It also provides style isolation and JavaScript sandbox to ensure the style or state of microapplications do not interfere with each other. Qiankun has received some attention in the community; our teams are also assessing it, hoping that it can support more friendly debugging.

  • With the rising interest in — and viability of — 3D and extended reality (XR) applications in web browsers, our teams have been experimenting with React Three Fiber for developing 3D experiences on the web. React Three Fiber is a library that takes the React.js component and state model and translates it to 3D objects rendered with the Three.js library. This approach opens up 3D web programming to the wider group of developers already familiar with React.js and the rich ecosystem of tools and libraries surrounding it. However, when developing applications with React Three Fiber, our teams often have to manipulate the 3D scene imperatively. This doesn't mix well with the reactive component paradigm provided by React. There is no escaping the need to understand the basic 3D rendering mechanisms. The jury is still out on whether React Three Fiber offers enough abstraction to warrant learning its idiosyncrasies or if it's better just to work with Three.js directly.

  • Tauri is an Electron alternative for building desktop applications using a combination of Rust tools and HTML, CSS, and JavaScript rendered in System's WebView. Unlike Electron which bundles Chromium, the applications built with Tauri leverage the underlying WebView, that is, WebKit on macOS, WebView2 on Windows and WebKitGTK on Linux. This approach has interesting trade-offs — on one hand you get small and fast application binaries; on the other hand, you need to verify compatibility quirks across WebViews of different systems.

  • Transloco is a library for Angular to build multilingual applications. It can be used in templates and offers a function to cover more complex use cases. Because the translations are loaded on-demand at run time, Transloco makes it easy to implement language switching in the web browser. It also covers localization of numbers, dates and more using template pipes.

Hold ?

languages-and-frameworks quadrant with radar rings Adopt Trial Assess Hold Adopt Trial Assess Hold
Moved in/out
No change

Unable to find something you expected to see?


Each edition of the Radar features blips reflecting what we came across during the previous six months. We might have covered what you are looking for on a previous Radar already. We sometimes cull things just because there are too many to talk about. A blip might also be missing because the Radar reflects our experience, it is not based on a comprehensive market analysis.

Unable to find something you expected to see?


Each edition of the Radar features blips reflecting what we came across during the previous six months. We might have covered what you are looking for on a previous Radar already. We sometimes cull things just because there are too many to talk about. A blip might also be missing because the Radar reflects our experience, it is not based on a comprehensive market analysis.


Download Technology Radar Volume 25

English | Español | Português | 中文


Stay informed about technology


Subscribe now

Visit our archive to read previous volumes