OSS Projects Revved Up by Develocity

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. Gradle aims to scale Develocity build and test performance acceleration, failure analytics, and flaky test management benefits across the ASF community of 320 active open-source software projects and over 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, Pulsar, and Solr, to name a few.

Spring is the world’s most popular Java framework for making Java programming quicker, easier, and safer for everybody. Develocity is being used by the Spring Boot, Spring Framework, and Spring Security projects. After the Spring Boot project migrated from Maven to the Gradle Build Tool and further optimized the 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.

Kotlin is a general-purpose, 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.

Quarkus is an open-source, Kubernetes-native Java stack and tailored for OpenJDK HotSpot and GraalVM. Quarkus is a large Maven project with over 1000 modules, resulting in 5-minute local builds and 4-hour CI builds for project maintainers. Working closely with the Quarkus team, Develocity engineers were able to customize the caching configuration to increase the overall Maven build cacheability, reducing average CI build time down to just 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 an order of magnitude 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 only tests that have been affected by updates, letting them cut 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. 

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 the Develocity remote Build Cache, the average build time decreased by about 50%. Build Scans allow the JUnit team to collaborate on build failures and point out problems in pull requests. In addition, the JUnit team takes advantage of the Develocity Test Failure analytics to stabilize flaky tests. More recently, the JUnit build has adopted Develocity Test Distribution for CI and local builds to speed up slow integration tests.

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 (Formerly known as Gradle Enterprise) 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 also 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 are now completed in about 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 Gradle build. Build Scans showed that tasks were not up-to-date with no code changes because of changing snapshot dependencies. The Develocity task inputs comparison identified tasks that were not being pulled from the cache. After solving those problems, as well as a few others, Spock’s Gradle build could 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 caching and 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 more 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 deploying 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 areas to consider refactoring. Regarding flaky tests, the team enabled a test retry mechanism that unearthed test flakiness issues on a specific OS. 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 reduce average local build times by 32%.

Ratpack is a simple, capable, toolkit for creating high performance and 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 Scans to efficiently debug build failures and on the remote build cache to accelerate building locally and in 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 the build with Develocity the average build time for the project was 3 minutes; after 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 alongside improvements to 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 the Gradle Build Tool and the related plugins that they use.

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 average build times on CI from 30-80% depending on the job run. Develocity’s Trends & Insights capability has presented new opportunities to improve performance across their codebase and test performance analytics has allowed them to identify slow tests and take steps to speed them up. 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.

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 and assist in collaboration. First, URL linking to parts 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.

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, the Develocity Build Scan service helped the team identify and fix a pathological dependency resolution issue, reducing dependency download times on CI by almost 30 minutes. Develocity also helped to identify and fix a misconfigured task that was causing cache misses.

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 to Micronaut on all 80 current projects. As a result of using Develocity to optimize their build cache performance, CI build times have been reduced 50% on average. Further, Build Scan was used to identify and fix cache misses during that optimization process, and continues to help the team collaborate on issues. Finally, the team leveraged Test Failure Analytics to identify and reduce test flakiness.

With roots in higher ed, Apereo CAS now provides enterprise single sign-on service for the web 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. In addition to performance improvements, 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 has allowed the CAS team to improve their code coverage accuracy. Additionally, Build Scan has 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 cache capabilities have sped up XWiki Common Maven builds by 25%. In addition, Build Scan^® has helped bring visibility to builds with heavy downloading of dependencies, and the data provided by Failure Analytics has allowed the team to make data-driven decisions about which failures to prioritize and fix.

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 the 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.

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 build insights have helped the Hibernate team significantly optimize their build. Issues such as missing cacheable task annotations, timestamps in JAXB-generated headers, and tasks not taking advantage of Gradle’s incremental UP-TO-DATE capabilities have been revealed and resolved using Develocity build observation features.

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 on average 66% by taking advantage of incremental building as well as local and remote 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 Build Scan, Performance, and Trends dashboards to spot and fix performance regressions.

Gradle has emerged as the build tool 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 Scans for finding performance regressions, flaky test management to identify and prioritize fixing the most flaky tests, and Test Distribution to further reduce build times.