Gradle Support for the

Scala and sbt Communities

Develocity has extended its support to the Scala/sbt community with the release of sbt for Develocity. Scala developers can also speed up their builds by taking advantage of the world’s only parallel compiler for the Scala language, Hydra.

Develocity Strategic Support for sbt

The Develocity strategy is to support all important build systems and language ecosystems in order to provide a single-vendor solution for maximizing developer productivity leveraging the practice of Developer Productivity Engineering (DPE). The release of sbt support for the Develocity Build Scan® service is an important step in that direction. Develocity already supports Gradle Build Tool, Apache Maven, and most recently, Bazel.

The Develocity multi-build-system solution strategy is based on the strategic premise that the build system market is and will continue to be fragmented within and across language ecosystems and even within most large corporations. This presented an opportunity to create a common build and test acceleration and analytics application that democratizes the benefits of DPE with a “no dev team left behind” approach to improving developer productivity and the developer experience. As a result, Develocity is independent from any single build tool and the unifying technology-enabling platform behind the practice of DPE.

Gradle’s Commitment to the Scala Community

Scala is a JVM-compatible programming language that was created in 2001 by Martin Odersky to combine functional programming and object-oriented programming into one language. The name is derived from Scalable Language. Scala was designed to improve upon Java, so you can call Java methods, inherit from Java classes, and more. Scala is commonly used in data science, machine learning, finance-related applications, content management systems, online learning platforms, and distributed applications.

  • Martin Odersky serves in a technical advisory role to Gradle. He is a computer scientist and professor of programming methods at École Polytechnique Fédérale de Lausanne (EPFL) in Switzerland.
  • Develocity support for sbt brings the leading Developer Productivity Engineering (DPE) solution platform to the sbt and Scala communities.
  • Gradle Inc. is committed to the continued development of Hydra and leveraging its proven global customer support services to ensure customer success.
Key Develocity Benefits for sbt Users

Available Now:

Build Scan®
Build Scan for sbt builds and tests gives Scala developers detailed data for every build, so they can quickly find the root cause of build and test failures and fix them on their own without re-running broken builds to reproduce problems.

To facilitate debugging, build data can be filtered by timeframe (e.g., show me only builds run in the last seven days); username (i.e., the operating system user that executed the build); the name of the root project; build tool and version; custom values and tags; and the outcome of the running build.

Build Scan links can also be shared to allow remote debugging with teammates in remote working environments. With Develocity and Build Scan you can also easily compare builds and understand the differences that lead to the same build succeeding and then failing.

The FREE Build Scan service is now available for sbt.. This provides the core functionality of the commercial service which is delivered as a part of Develocity, including the following features and reports:

  • Build Performance Summary
  • Failures Report
  • Console Log Functionality
  • Custom Values & Tagging
  • Environment Data

The commercial Develocity Build Scan service for sbt adds support for unlimited and automatic build scan invocations and data retention, as well as data privacy.

Future Capabilities:

Build Cache
Build Cache speeds up local and CI builds by allowing you to share and reuse unchanged build and test outputs across the team. The task input comparison tool helps you understand why local devs and CI builds are not benefitting from the remote build cache to maximize performance and reuse.

Predictive Test Selection

Leveraging machine learning, Predictive Test Selection can save significant testing time by identifying, prioritizing, and running only tests that are likely to provide useful feedback during test runs.

Test Distribution
This approach accelerates test execution and complements build caching while addressing many of the limitations of single-machine parallelism and CI fanout. It does this by distributing test execution work to remote executors.

Performance Continuity
Performance Continuity
 refers to a rich set of analytic, profiling,  and diagnostic tools to sustain the feedback cycle time optimizations achieved with build caching.  It includes critical path analysis to help focus performance improvements on the parts of the build that matter most.

Failure Analytics
Failure Analytics complements Build Scan by improving build, test, and toolchain reliability with rich failure metrics and trend data for  Scala  unit and instrumentation tests. You can use Failure analytics in combination with Build Scan to make problems like flaky tests and other avoidable failures easier to detect,  reproduce for root cause analysis, and prioritize for fixing based on an impact assessment and frequency of occurrence.

Management Reporting & Insights
While Develocity helps you react to tactical performance bottlenecks and daily failures, it also enables you to respond proactively to systemic problems and longer-term performance regressions using dashboards that make key metrics and KPIs more observable and actionable.

Get Started with an sbt Build Scan

An easy way to get started and get exposure to some Develocity developer productivity tools is to try sbt Build Scan for free

Create an sbt Build Scan in 30 Seconds

Hydra Overview | It Just Works!

Hydra is the world’s only parallel compiler for the Scala language. Hydra works by parallelizing all of the Scala compiler phases, taking full advantage of the many cores available in modern hardware. 

Hydra is based on the open-source Scala compiler with a focus on parallelizing the work inside the compiler and maintaining strong compatibility guarantees. Certain components are replaced or improved in order to make parallelization possible.

Being based on the open-source compiler means that Hydra supports the full Scala language, including macros and compiler plugins. Hydra is more than binary compatible with open-source Scala, it generates the same bytecode.

We keep Hydra in-sync with Scala and we release on the same schedule. New features and improvements in Scala are also available in Hydra in the corresponding release. From a language feature perspective, Hydra and the Scala compiler are 100% identical.

Key Capabilities | Compile Scala Faster

Multicore compilation
This takes advantage of the many cores available in modern hardware to achieve impressive Scala compilation speedup.

Seamless  integration
Seamless integration with development environments means that the only thing you notice is that Scala compiles fast! Hydra supports Gradle Build Tool, Maven, and sbt.

Compile-time monitoring
When compiling, Hydra automatically collects statistics about your Scala project and points out bottlenecks in compilation via a modern web dashboard.
Learn more about Hydra

Contact Us