Sponsoring the open source community

Spring is the world’s most popular Java framework for making Java programming quicker, easier, and safer for everybody. Develocity is used by the Spring Boot, Spring Framework, Spring Security and 20 more projects. The Spring Boot project migrated from Maven to Gradle Build Tool and further optimized its Build Cache effectiveness with Develocity. CI builds now take roughly 20 minutes on average, 3-4 times faster than before. Local builds are taking an average of 2.5 minutes, which is 20-30 times faster than before. The team has also started looking at Develocity Failure Analytics to address flaky tests and other avoidable failures.

Gradle Inc. collaborates with the Apache Software Foundation as a Targeted Platinum Sponsor. This involves Gradle providing a free instance of Develocity that runs as a shared ASF infrastructure service available for use by all Apache projects and contributors. Develocity offers build and test acceleration, failure troubleshooting, and toolchain observability to the ASF community of 320 active open-source software projects (8,400+ committers). There are tens of thousands of builds running weekly that leverage Develocity within the ASF project teams at Beam, Groovy, JMeter, Kafka, Lucent, Pekko, Pulsar, Solr, and more.

Kotlin is a general-purpose and free open source programming language initially designed for the JVM and Android, and is the most used programming language for building JVM applications after Java. The Kotlin Compiler open source project is built with Develocity about 60,000 times every month. Develocity was used to reduce median build time from about 10 minutes to about 3.3 minutes. Kotlin made their custom tasks cacheable and also optimized the configuration phase of the build with the help of Build Scan® insights.

The Micronaut project is a modern, JVM-based, full-stack framework for building modular, easily testable microservice and serverless applications. It runs smoothly on GraalVM and compiles to a native executable format that offers low startup times and a small memory footprint. Develocity is a Tool and Infrastructure Partner for all 80 active Micronaut Foundation projects. As a result of using Develocity to optimize their build cache performance, CI build times have been reduced 50% on average. Build Scan® was also used to identify and fix cache misses during that optimization process. Build Scan has also proven instrumental in helping the team collaborate on issues. Finally, the team leveraged Failure Analytics to identify and reduce test flakiness.

JUnit is the most widely used testing framework on the JVM. Given its widespread usage, JUnit needs to be thoroughly tested on all current JDKs and early access versions. Since enabling Develocity remote Build Cache, the average build time decreased by about 50%. Develocity’s Build Scan® product allows the JUnit team to collaborate on build failures and point out problems in pull requests. In addition, the JUnit team takes advantage of Develocity Flaky Test Detection and Failure Analytics to stabilize flaky tests. More recently, the JUnit build has adopted Develocity Test Distribution for CI to speed up slow integration tests.

Quarkus (part of the Commonhaus Foundation) is an open source, Kubernetes-native Java stack tailored for OpenJDK HotSpot and GraalVM. Quarkus is a large Maven project with over 1,000 modules, resulting in 5-minute local builds and 4-hour CI builds for project maintainers. Working closely with the Quarkus team, Develocity engineers customized the caching configuration to increase the overall Maven build cacheability, reducing average CI build time to 1 hour (a 75% decrease). This was also reflected in local build times, which went from 5 minutes to just 1 minute, allowing maintainers to run significantly more builds per day. Other structural improvements to the Quarkus build included implementing test retries, which helped to increase build consistency and reduce overall CI load. The Quarkus team also used Develocity Predictive Test Selection to intelligently choose tests affected by updates, cutting over 1 day per week of aggregate testing time. Additionally, a joint effort between the Quarkus and Develocity teams resulted in a solution to make the Quarkus build goal cacheable, which benefited not only the Quarkus build, but all Quarkus end-users.

Testcontainers assists developers in running complex tests by providing disposable instances of commonly used databases, web browser environments, and other components commonly used to support automated testing efforts. The Testcontainers community has adopted several Develocity features to accelerate their build times. First, linking directly to specific sections of a Build Scan® has been particularly useful for the distributed Testcontainers team, providing an easy way to share issue details instead of scrolling through Github action logs. Second, Task Input Comparison was used to maximize efficiency by discovering and removing impediments to caching such as unnecessary time stamps in build files. Finally, remote Build Cache, which replaced the existing caching mechanism, greatly simplified build logic by removing bespoke test caching logic and resulted in more accurate test caching.

Commonhaus is a rising software foundation that is committed to creating a collaborative environment that nurtures the growth and sustainability of projects and their communities. It encompasses such projects as Quarkus, Hibernate, Morphia, Feign, and more. Hibernate ORM is an ubiquitous and powerful object-relational mapping tool for Java. Hibernate maps Java classes to database tables, and Java data types to SQL data types. It also provides data query and retrieval capabilities. The Hibernate team used Gradle’s incremental build system to improve build performance by more than 70% on average. Develocity Performance Insights helped the Hibernate team significantly optimize their build. Morphia, a MongoDB object-document mapper in Java, was able to leverage these same insights to find opportunities for optimizations that cut their Maven build times in half.

The AndroidX project produces Android Jetpack, a suite of libraries that helps Android developers follow best practices, reduce boilerplate code, and write code that works consistently across Android versions. The AndroidX team uses Develocity to speed up builds with enhanced caching, as well as gain deep insights into build performance. In one instance, Develocity’s Build Scan® product helped the team identify and fix a pathological dependency resolution issue, reducing dependency download times on CI by almost 30 minutes. Develocity also helped identify and fix a misconfigured task that was causing cache misses.

The OpenRewrite project is an ecosystem of utilities used to search and transform source code at a large scale. OpenRewrite’s platform contains numerous recipes which can be used to refactor code automatically. The platform can be used to enforce code best practices, upgrade code from legacy standards, automate the remediation of style violations, and perform many other tasks involving code transformation. The OpenRewrite team uses Develocity to speed up their build and test cycles both locally and on CI, and to gain deep insights into the state of their builds and toolchain. The remote Build Cache has reduced their build times on CI from 30-80% depending on the job run. Develocity Performance Insights has presented new opportunities to improve performance across their codebase and has allowed them to identify slow tests and proactively optimize them. Additionally, the centralized and shareable approach that the Build Scan® offers has reduced the amount of guesswork typically involved in remediation efforts and made troubleshooting far more data-driven than before.

The Scala Center is an independent, not-for-profit center established by the creator of the Scala language, Dr. Martin Odersky, at École Polytechnique Fédérale de Lausanne (EPFL) in Switzerland. Gradle Inc. is partnered with the Scala Center and provides a free instance of Develocity for building Scala. Leveraging Develocity Build Scan enables the Scala Center engineering team and open-source contributors to easily view everything that happens during the build and test lifecycle, identifying performance regressions, bottlenecks, CI pipeline performance trends, and more.

Apollo Kotlin (formerly known as Apollo Android) is a GraphQL client that generates Kotlin and Java models from GraphQL queries. The Apollo project leveraged Develocity features to uncover areas for build optimization, pinpoint and address multiple caching inefficiencies, and make collaboration easier through linked and shareable GitHub issues. Through their analysis and with the help of task input comparisons, they identified and corrected several cache misses stemming from Java URL hashing, inconsistent property ordering, manifest attributes, and absolute path issues. They used the “Slowest Test” functionality to discover a single test that was taking seven minutes to execute. Additionally, they tackled overlapping outputs which posed both caching and build reproducibility challenges. These efforts culminated in a significant reduction in CI build times, which previously took around 25-30 minutes and now completes in 5 minutes.

Spock is a testing and specification framework for Java and Groovy applications. Spock’s beautiful and highly expressive specification language differentiates it from alternative solutions. Its JUnit runner makes Spock compatible with most IDEs, build tools, and continuous integration servers. Develocity surfaced several performance issues in Spock’s build. Build Scans® showed that tasks were not UP-TO-DATE, even with no code changes due to changing snapshot dependencies. The Develocity task inputs comparison quickly identified tasks that were not restored from the cache. After solving these problems, Spock’s build was able to take full advantage of the Develocity remote Build Cache. This brought CI build times for the Spock project from a median of 3 minutes per build to about 1 minute per build.

JHipster is a development platform to quickly generate, develop, and deploy modern web applications and microservice architectures. JHipster helps developers create deployments across a range of both frontend and backend languages and frameworks. JHipster’s project generator creates backend Java applications which in turn have their own individual build and test cycles. Develocity’s Build Cache and Build Scan® features are now seamlessly available in generated JHipster projects, saving time for JHipster developers and their users. JHipster also makes use of the Build Scan functionality to easily identify previously undetected areas for build time improvement as well as analyze build failures caused by differences in infrastructure.

Armeria is an open source, reactive microservices platform developed by the creator of Netty (along with the team at a company called LINE, which makes one of the largest messaging and services platforms in Asia). By leveraging Develocity, Armeria quickly discovered developer productivity blockers like build cache misses, flaky tests, and unnecessarily long configuration times. Using Develocity Build Scan®, the team identified downstream cache misses, dependency resolution issues, and other areas to consider refactoring. To address flaky tests, the team enabled a test retry mechanism, which helped uncover flakiness issues specific to one operating system. In the end, having the right metrics allowed them to optimize build caching and configuration settings, increase the avoidance of unnecessary build work on CI from 7% to 34%, and reducing local build times by 32%.

Ratpack is a simple and capable toolkit for creating high-performance, scalable web applications built on Java and the Netty event-driven networking engine. It consists of a set of Java libraries for building scalable HTTP applications. Optional Gradle build time support makes building and testing applications a breeze. The Ratpack team relies on Develocity Build Scan® to efficiently debug build failures. The Ratpack team also relies on the Develocity remote Build Cache to accelerate local builds and speed up their CI pipeline.

Micrometer is a vendor-neutral instrumentation facade for JVM-based applications which provides multiple interfaces that developers can use to instrument their code without being locked into a monitoring solution. The dimensional data model—in combination with the timers, gauges, counters, distribution summaries, and long-task timers provided by the interfaces—allows for searching and drilling down on metrics. Before optimizing their build with Develocity, the average build time for the project was 3 minutes. Following optimizations, the build time was less than 1 minute. Analysis of test-related task inputs found multiple opportunities for avoidance savings during test cycles, leading to further reduction in feedback cycle times. The insights gained from the Build Scan® service have helped the team uncover multiple inefficient dependency repository lookup calls. Build Scan has also improved the project’s overall cacheability. Build Scan dependency info, plugin insights, and deprecation warnings help the team ensure that build systems stay up to date with the latest version of Gradle Build Tool and the related plugins that they use.

With roots in higher ed, Apereo CAS now provides enterprise single sign-on service for everything from Fortune 500 companies to special-purpose installations. CAS is now relying on Develocity to improve build and test feedback cycle times. The project uses Build Scan® to identify and fix cache misses by leveraging the Task Input Comparison and Build Scan Timeline views. Thanks to the Build Scan Timeline view, CAS discovered that code coverage tasks had overlapping outputs. This meant that the code coverage reports were not correct in certain cases. This finding allowed the CAS team to improve their code coverage accuracy. Using Build Scan, the CAS team nearly halved fully cacheable build time and brought avoidance savings (after optimization) to 95%. The team has also started enabling Predictive Test Selection for all test categories, leading to a 46% reduction in testing time over a 28-day period.

MicroStream is a breakthrough Java-native persistence layer built for cloud-native microservices and serverless systems that need their own lightweight, high-performance persistence. MicroStream utilizes Develocity to optimize local and CI builds and tests, as well as detect failures and maintain long-term performance. MicroStream used Develocity to fix a never-before-seen annotation processor misconfiguration, enabling the team to incorporate a compile avoidance mechanism. MicroStream used insights from Develocity to apply runtimeClasspath normalization. This allowed them to fix cache misses and maximize the use of the local and remote Build Cache. Once these issues were resolved, MicroStream reported a reduced build time of 57%, and testing time on CI dropped from 50 to just 7 minutes.

XWiki is a free wiki software platform written in Java with a design emphasis on extensibility. XWiki is an enterprise wiki and includes WYSIWYG editing, OpenDocument-based document import/export, semantic annotations and tagging, and advanced permissions management. Develocity’s local and remote Build Cache capabilities have sped up XWiki Common Maven builds by 25%. In addition, Build Scan® has helped bring visibility to XWiki builds highlighting heavy downloading of dependencies. The data provided by Failure Analytics has allowed the team to make data-driven decisions about which failures to prioritize and fix.

The Nokee project provides open source plugins for developers which improve support for native builds in Gradle. Nokee is using Develocity to speed up their builds by an average of 66%, taking advantage of incremental builds along with local and remote build caching. The insights provided by Develocity allowed the Nokee team to identify several opportunities for improvement in their build process, including cache utilization, normalization of path declarations, OS-bound tasks with improper inputs, and classpath ordering issues.

Detekt is an open source static code analysis tool for the Kotlin programming language. It helps developers write cleaner code by pointing out various quality factors. Detekt is capable of running code smell analysis, allows for highly configurable rule sets, and provides a Gradle plugin to make it easy to integrate Detekt into your Gradle project. The Detekt team uses Develocity to provide insights into their builds and optimize their build speed–specifically, utilizing Build Scan® to increase performance and optimize caching during several expensive phases of the build. Build Scan helped the Detekt team uncover areas of the build which weren’t benefitting from caching because of issues like path normalization, as well as differences in configuration and environment that were causing remote cache misses.

OpenAPI Generator, one of the most popular code generation tools with 2500+ contributors, allows users to automatically generate API client libraries, server stubs covering 30+ programming languages. Powerful Develocity observability features were harnessed to uncover and understand a range of inconsistencies in their development and integration processes. The resulting insights have been instrumental in revealing opportunities to improve OpenAPI’s development workflows. For example, leveraging the Build Scan® service, the project team identified and fixed discrepancies in Maven and JDK versions used across local and CI environments. Build Scan also shed light on cache misses in compile and Surefire goals, misaligned Jacoco configurations, and an OS-specific dependency. Additionally, it was discovered that compilation avoidance was disabled due to the detection of annotation processors on the classpath, which was corrected.

Caffeine, an open-source Java caching library for high-performance in-memory caching, has made use of Build Scan® to detect abnormal build cache misses. Specifically, the Caffeine team faced an issue where a download task was uncacheable due to undefined inputs. To resolve the problem, Develocity Solutions Engineering designated the URL of the downloaded item as an input, thereby allowing Gradle to cache the task. This change improved the project’s efficiency by enhancing build performance and avoiding unnecessary operations and underlines the significance of properly defined inputs and outputs in a build system. The team will continue to to use Develocity Build Scan and Performance Insights to spot and fix performance regressions.

Gradle has emerged as the build system of choice for projects within the JVM ecosystem, including Kotlin. Gradle Build Tool has a comprehensive automated test suite that covers different operating systems and Java versions. The team runs about 70,000 builds a week. The build relies heavily on the remote Build Cache for build acceleration, Build Scan® for finding performance regressions, Flaky Test Detection to identify and prioritize fixing the most flaky tests, and Test Distribution to further reduce build times.

Grails is a powerful Groovy-based web application framework for the JVM built on top of Spring Boot. The Grails team, an early adopter and long-time user of Gradle Build Tool, utilizes Develocity to gain deep insights into their builds. This has helped the team keep Gradle up to date by providing observability during upgrades. Additionally, Grails is realizing significant benefits from build caching, achieving a 50% improvement on the project’s CI build time. Grails has used the observability features of Develocity to optimize cache usage by identifying cache misses and remediating them, including misses caused by inconsistent dependency versions pulled from Maven local repositories.