Languages & Frameworks

OpenTelemetry is quickly becoming the industry standard for observability. The release of the OpenTelemetry protocol (OTLP) specification established a standardized way to handle traces, metrics and logs, reducing the need for multiple integrations or major rewrites as monitoring distributed solutions and interoperability requirements grow. As OpenTelemetry expands to support logs and profiling, OTLP ensures a consistent transport format across all telemetry data, simplifying instrumentation and making full-stack observability more accessible and scalable for microservices architectures.

Adopted by vendors like Datadog, New Relic and Grafana, OTLP enables organizations to build flexible, vendor-agnostic observability stacks without being locked into proprietary solutions. It supports gzip and zstd compression, reducing telemetry data size and lowering bandwidth usage — a key advantage for environments handling high volumes of telemetry data. Designed for long-term growth, OTLP ensures OpenTelemetry remains a robust and future-proof standard, solidifying its position as the de-facto choice for telemetry transport.

We noted React Hook Form as an alternative to Formik. By defaulting to uncontrolled components, it delivers significantly better out-of-the-box performance, especially for large forms. React Hook Form is well-integrated with various schema-based validation libraries, including Yup, Zod and more. Additionally, React Hook Form offers a lot of flexibility, making it easy to integrate with existing codebases and other libraries. You can use React Hook Form with external controlled components libraries such as shadcn or AntD. With strong performance, seamless integration and active development, it’s a solid choice for building large form or form-heavy application.

Effect is a powerful TypeScript library for building complex synchronous and asynchronous programs. Web application development often requires boilerplate code for tasks such as asynchrony, concurrency, state management and error handling. Effect-TS streamlines these processes using a functional programming approach. Leveraging TypeScript’s type system, Effect helps catch hard-to-detect issues at compile time. Our team previously used fp-ts for functional programming but found that Effect-TS provides abstractions that align more closely with daily tasks. It also makes code easier to combine and test. While traditional approaches like Promise/try-catch or async/await can handle such scenarios, after using Effect, our team found no reason to go back.

The Hasura GraphQL engine is a universal data access layer that simplifies building, running and governing high-quality APIs on different data sources. It provides instant GraphQL APIs over various databases (including PostgreSQL, MongoDB and ClickHouse) and data sources, enabling developers to fetch only the data they need quickly and securely. We found Hasura easy to implement GraphQL for server-side resource aggregation and have applied it in multiple data product projects. However, we remain cautious about its powerful federated query and unified schema management. A noteworthy recent addition is Hasura's PromptQL feature, which allows developers to leverage LLMs for more natural and intuitive data interactions.

LangGraph is an orchestration framework designed to build stateful multi-agent applications using LLMs. It provides a lower-level set of primitives like edges and nodes compared to LangChain’s higher-level abstractions, offering developers fine-grained control over agent workflows, memory management and state persistence. This graph-based approach ensures predictable and customizable workflows, making debugging, scaling and maintaining production applications easier. Although it has a steeper learning curve, LangGraph's lightweight design and modularity make it a powerful framework for creating agentic applications.

MarkItDown converts various formats (PDF, HTML, PowerPoint, Word) into Markdown, enhancing text readability and context retention. Since LLMs derive context from formatting cues like headings and sections, Markdown helps preserve structure for better comprehension. In RAG-based applications, our teams used MarkItDown to pre-process documents into Markdown, ensuring logical markers (headers, subsections) remained intact. Before embedding generation, structure-aware chunking helped maintain full section context which improves the clarity of query responses, especially for complex documents. Widely used for documentation, Markdown also makes MarkItDown’s CLI a valuable developer productivity tool.

Module Federation allows for the specification of shared modules and dependency deduplication across micro frontends. With version 2.0, it has evolved to function independently of webpack. This update introduces key features, including a federation run time, a new plugin API and support for popular frameworks like React and Angular as well as popular bundlers like Rspack and Vite. By adopting Module Federation, large web applications can be divided into smaller, manageable micro frontends, allowing different teams to develop, deploy and scale independently while sharing dependencies and components efficiently.

Prisma ORM is an open-source database toolkit that simplifies working with databases in Node.js and TypeScript applications. It offers a modern, type-safe approach to database access, automates database schema migrations and provides an intuitive query API. Unlike typical ORMs, PrismaORM uses plain JavaScript objects to define database types without decorators or classes. Our experience with Prisma ORM is positive; we find it not only better aligns with the general TypeScript development landscape, it also neatly integrates with the functional programming paradigm.

.NET Aspire is designed to simplify the orchestration of distributed applications on a developer's local machine. Aspire lets you orchestrate multiple services in a local development environment — including multiple .NET projects, dependent databases and Docker containers — all with a single command. Furthermore, Aspire provides observability tools — including logging, tracing and metrics dashboards — for local development, decoupled from the tools used in staging or production environments. This significantly improves the developer experience when building, tweaking and debugging the observability aspects of any system they are working on.

Google, in collaboration with Samsung and Qualcomm, has introduced Android XR, a new operating system designed for XR headsets. Support is planned for glasses and other devices. Most Android apps are supported with no or minimal changes, but the idea is to build new spatial apps from scratch or to "spatialize" existing apps. The new Android XR SDK is positioned as the go-to SDK for such projects, and Google provides guidance on how to choose tools and technologies bundled in the SDK. It’s available in developer preview now.

Browser Use is an open-source python library that enables LLM-based AI agents to use web browsers and access web applications. It can control the browser and perform steps that include navigations, inputs and text extractions. With the ability to manage multiple tabs, it can perform coordinated actions across multiple web apps. It’s useful for scenarios where LLM-based agents need to access web content, perform actions on it and get the results. The library can work with a variety of LLMs. It leverages Playwright to control the browser, combining visual understanding with HTML structure extraction for improved web interaction. This library is gaining traction in multi-agent scenarios, enabling agents to collaborate on complex workflows involving web interactions.

CrewAI is a platform designed to help you build and manage AI agents that can work together to accomplish complex tasks. Think of it as a way to create a crew of AI workers, each with their own special skills, who can collaborate to achieve a common goal. We’ve mentioned it previously in the Radar under LLM-powered autonomous agents. In addition to the open-source Python library, CrewAI now has an enterprise solution so organizations can create agent-based applications for real-world business cases, run them on their cloud infrastructure and connect to existing data sources such as Sharepoint or JIRA. We've used CrewAI multiple times to tackle production challenges, from automated validation of promotion codes to investigating transaction failures and customer support queries. While the agentic landscape continues to evolve rapidly, we’re confident in placing CrewAI in Assess.

ElysiaJS is an end-to-end type-safe web framework for TypeScript, designed primarily for Bun but also compatible with other JavaScript run times. Unlike alternatives such as tRPC, which enforces specific API interface structures, ElysiaJS does not impose any API interface structure. This allows developers to create APIs that follow established industry practices such as RESTful, JSON:API or OpenAPI and also provide end-to-end type safety. ElysiaJS is highly performant when used with Bun run time, even comparable to Java or Go web frameworks in some benchmarks. ElysiaJS is worth considering, especially when building a backend-for-frontend (BFF).

FastGraphRAG is an open-source implementation of GraphRAG designed for high retrieval accuracy and performance. It uses Personalized PageRank to limit graph navigation to the most relevant nodes among all the related nodes in the graph, enhancing retrieval accuracy and improving LLM response quality. It also provides a visual representation of the graph, helping users understand node relationships and the retrieval process. With support for incremental updates, it’s well-suited to dynamic and evolving data sets. Optimized for large-scale GraphRAG use cases, FastGraphRAG improves performance while minimizing resource consumption.

Erlang/OTP is a powerful platform for building highly concurrent, scalable and fault-tolerant distributed systems. Traditionally, its languages have been dynamically typed, but Gleam introduces type safety at the language level. Built on BEAM, Gleam combines the expressiveness of functional programming with compile-time type safety, reducing run-time errors and improving maintainability. With a modern syntax, it integrates well with the OTP ecosystem, leveraging the strengths of Erlang and Elixir while ensuring strong interoperability. The Gleam community is active and welcoming, and we look forward to its continued development.

GoFr is a framework for building microservices in Golang, designed to simplify development by abstracting away boilerplate code for common microservice functionalities such as logging, traces, metrics, configuration management and Swagger API documentation. It supports multiple databases, handles database migrations and facilitates pub/sub with brokers like Kafka and NATs. Additionally, GoFr includes task scheduling with cron jobs. It reduces the complexity of building and maintaining microservices, and allows developers to focus on writing business logic rather than infrastructure concerns. Even though there are other popular Go libraries for building web APIs, GoFr is gaining traction and is worth exploring for Golang-based microservices.

At the core of asymmetric cryptography, which secures most modern communication, lies a mathematically hard problem. However, the problem used in today's algorithms will be easy to solve with quantum computers, driving research for alternatives. Lattice-based cryptography is currently the most promising candidate. Although cryptographically relevant quantum computers are still years away, post-quantum cryptography is worth considering for applications that must remain secure for decades. There is also the risk that encrypted data is recorded today in order to be decrypted once quantum computers become available.

Java post-quantum cryptography takes its first steps in JDK 24, set for general availability in late March. This release includes JEP 496 and JEP 497 — which implement a key encapsulation mechanism and a digital signature algorithm — both standards-based and designed to be resistant to future quantum computing attacks. While liboqs from the Open Quantum Safe project provides C-based implementations with a JNI wrapper, it’s encouraging to see a native Java implementation emerging as well.

Presidio is a data protection SDK for identifying and anonymizing sensitive data in structured and unstructured text. It detects personally identifiable information (PII) such as credit card numbers, names and locations, using named entity recognition, regular expressions and rule-based logic. Presidio supports custom PII entity recognition and de-identification, allowing businesses to tailor it to their specific privacy requirements. Although Presidio automates the identification of sensitive information, it’s not foolproof and may miss or misidentify data. Exercise caution when relying on its results.

As the technologies to build LLM-backed applications and agents continue to evolve rapidly, frameworks for building and orchestrating such applications often struggle to keep up or find the right timeless abstractions. PydanticAI is the latest entrant in this space, aiming to simplify implementations while avoiding unnecessary complexity. Developed by the creators of the popular Pydantic, it builds on lessons learned from earlier frameworks — many of which already rely on Pydantic. Rather than trying to be a Swiss Army knife, PydanticAI offers a lightweight yet powerful approach. It integrates with all major model APIs, includes built-in structured output handling and introduces a graph-based abstraction for managing complex agentic workflows.

Since the release of Swift 6.0, the language has expanded beyond Apple's ecosystem with improved support for major operating systems, making it more viable to use Swift for resource-constrained applications. Traditionally, this space has been dominated by C, C++ and, more recently, Rust, due to their low-level control, high performance and availability of certified compilers and libraries that comply with standards such as MISRA, ISO 26262 and ASIL. While Rust has begun achieving similar certifications, Swift has yet to pursue this process, limiting its use in safety-critical applications.

Swift's growing adoption is driven by its balance of performance and safety features, including strong type safety and automatic reference counting for memory management. While Rust’s ownership model offers stronger memory safety guarantees, Swift provides a different trade-off that some developers find more approachable. Both Swift and Rust share the LLVM/Clang compiler backend, allowing advancements in one to benefit the other. With its ability to compile to optimized machine code, its open-source development and its expanding cross-platform support, Swift is emerging as a contender for a wider range of applications — far beyond its iOS roots.

Tamagui is a library for efficiently sharing styles between React web and React Native. It offers a design system with reusable styled and unstyled components that render seamlessly across platforms. Its optional optimizing compiler boosts performance by converting styled components into atomic CSS with divs on the web and hoisted style objects on native views.

torchtune is a PyTorch library for authoring, post-training and experimenting with LLMs. It supports single and multi-GPU setups and enables distributed training with FSDP2. The library provides YAML-based recipes for tasks like fine-tuning, inference, evaluation and quantization-aware training. Each recipe offers a focused set of features, avoiding complex flag-based configurations. It prioritizes simplicity, favoring code clarity over excessive abstractions. It also includes a CLI for downloading models, managing recipes and running experiments efficiently.

A few years ago, we observed Node overload: Node.js was often used for questionable reasons or without even considering any alternatives. While we understand that some teams prefer a single-language stack — despite the trade-offs — we continue to advocate for polyglot programming. At the time, we noted that Node.js had a deserved reputation for efficiency in IO-heavy workloads, but we mentioned that other frameworks had caught up which offered better APIs and superior overall performance. We also cautioned that Node.js was never well-suited to compute-heavy workloads, a limitation that remains a significant challenge. Now, with the rise of data-heavy workloads, we’re seeing teams struggle with these as well.