By Roberto Perez Alcolea, Java Platform Staff

At Netflix, shared Java libraries assist functions developed throughout a big, independently evolving repository ecosystem. A library change begins in a single repository, however its affect can attain many others. Producers can see the API diff in entrance of them. What they typically can not see is who nonetheless will depend on the symbols that modified.
The necessity for that visibility grows as coding brokers tackle extra of the software program improvement lifecycle. An agent can speed up a neighborhood edit, however with out cross-repository context it can not decide downstream threat or assist plan shopper migrations. The proof a producer makes use of to evaluate a change may information the agent engaged on it.
Think about a standard case: eradicating a deprecated API. Deprecated entry factors increase the floor producers should check, doc, and assist, they usually can constrain how a library evolves.
Suppose a substitute has been obtainable for a number of releases and the outdated technique can not specific choices required by new conduct. The library’s exams go, and a compatibility checker flags the elimination. The producer nonetheless can not reply the questions that decide what to do subsequent:
- Does any shopper nonetheless name this technique?
- Are shoppers focused on one model or unfold throughout a number of generations?
- Does one other library implement or wrap the API, multiplying its affect?
- Is direct coordination ample, or does this require a deprecation and migration marketing campaign?
At small scale, producers can ask close by groups or search a handful of repositories. Throughout many repositories, it’s more durable to seek out each caller of a way and the library model each makes use of. These solutions are scattered throughout shopper codebases and builds.
With out that proof, a producer could launch a breaking change and uncover the affect via shopper failures, or protect an outdated API indefinitely as a result of the chance is unknown. Libraries must evolve, and their producers want proof that helps them achieve this deliberately.
We constructed Quasar to index image definitions and references throughout Netflix repositories. For library producers, that shared index helps reply two questions:
- What modified within the library’s public API?
- Which repositories use the precise symbols that modified?
The primary identifies a doubtlessly incompatible change. The second estimates its noticed blast radius. Collectively, they flip a generic compatibility warning into proof a producer can act on earlier than merging or releasing.
From API Modifications to Shopper Influence
Current strategies every see a unique a part of the issue. Binary and supply compatibility instruments establish contract modifications, however can not inform who makes use of the modified API. Dependency graphs present declared attain, however can not show that code calls a specific technique. Textual content search could miss overloads, inheritance, or the artifact model behind a name. Shopper builds present sturdy validation, however operating them throughout the fleet is pricey.
Quasar builds on SCIP, an open interchange format for semantic code intelligence. Language-specific indexers encode definitions, references, and relationships utilizing secure image identifiers. Quasar retains API definitions for library variations and commits alongside references from shopper repositories. That shared id lets it join an API change in a single repository to precise usages elsewhere, even when these repositories have been listed independently.

On every enrolled CI construct, language-specific indexers submit SCIP indexes to Quasar’s ingestion service. It writes API definitions and shopper references as Parquet in Amazon S3, retaining the image id, dependency model, and supply location wanted to research a change.
Throughout pull-request evaluation, Quasar compares listed base and head definitions and counts direct shopper references with Amazon Athena. Quasar exposes these findings via its REST and GraphQL APIs and MCP server; follow-up utilization queries present dependency-version breakdowns and supply areas. A separate compatibility-impact evaluation may observe implementations and their callers when a producer provides a modified JVM image.
Think about this simplified API change:
public interface Consumer {
- Consequence getLegacyValue(Request request);
+ Consequence getValue(Request request, Choices choices);
}For an in depth compatibility-impact evaluation of this elimination, a producer-side device provides the outdated technique descriptor. Quasar constructs its canonical image id. This abridged excerpt from the direct-reference portion of Quasar’s Amazon Athena question exhibits the important match:
SELECT c.change_id, 'DIRECT_REFERENCE' AS evidence_kind,
r.scm_type, r.org, r.repo, r.dep_version, r.file_path
FROM requested_changes c
JOIN quasar.symbol_refs r
ON r.symbol_canonical = c.target_canonical
requested_changes incorporates the API modifications submitted by the producer. The SQL excerpt finds repositories that decision the eliminated technique. Quasar additionally checks implementations and calls via them, so it will possibly depend every affected repository as soon as. It returns pattern dependency variations and file areas to assist examine the outcome.
For the Consumer change, this tells the producer which repositories nonetheless use getLegacyValue, which variations they use, and the place a few of these calls happen. That helps the producer resolve whether or not to coordinate a migration earlier than eradicating the technique.
Bringing the Evaluation Earlier than Launch
Model-to-version comparability is efficacious when planning an improve or writing a migration information. Producers profit much more when suggestions arrives throughout code evaluation.
For pull-request evaluation, Quasar shops API definition snapshots keyed by commit. Given a base and head commit, it classifies symbols as added, eliminated, or signature-modified. Removals and modifications then turn out to be candidates for consumer-impact evaluation.
An incompatible change is just not mechanically a high-risk change. Quasar stories the noticed affect so the producer can resolve what to do; it doesn’t implement a launch coverage. “No references noticed” means solely that Quasar discovered none within the listed inhabitants. Reflection, configuration, dynamic loading, stale branches, or incomplete indexing can cover shoppers. The outcome wants to indicate whether or not the requested commits have been listed, how recent the patron indexes are, and whether or not proof was truncated.
Pull-request evaluation requires listed snapshots for the precise base and head commits. If both is unavailable, Quasar stories that it can not evaluate them; it doesn’t substitute a default-branch snapshot. This retains a lacking comparability from wanting like a clear API diff.
Return to our Consumer change. This illustrative report brings collectively indicators obtainable via Quasar's API comparability, consumer-usage queries, and library-level criticality. It isn’t a literal response from one API:
{
"change": "REMOVED",
"image": "Consumer#getLegacyValue(Request)",
"affectedRepositories": 137,
"versionDistribution": [
{ "version": "4.2.1", "repositories": 86 },
{ "version": "4.1.7", "repositories": 38 },
{ "version": "3.9.4", "repositories": 13 }
],
"sampleConsumerLocations": [
{
"repository": "checkout-service",
"filePath": "src/main/java/com/example/checkout/CheckoutClient.java",
"lines": [84, 129]
},
{
"repository": "client-wrapper",
"filePath": "src/major/java/com/instance/consumer/ClientAdapter.java",
"traces": [57]
}
],
"libraryCriticality": {
"tier": 1,
"foundation": "highest-tier downstream software"
},
"comparability": {
"baseShaFound": true,
"headShaFound": true
}
}
The repository depend is symbol-specific: on this instance, 137 listed repositories confer with the eliminated technique. The model distribution reveals a dominant cohort on 4.2.1 and a smaller lengthy tail nonetheless on 3.9.4. A producer can examine affected repositories and retrieve listed file paths, with line numbers the place the index offers them. The JSON exhibits solely two pattern areas to maintain the instance readable. The filePath and features form mirrors Quasar's question contract. The tier is broader context concerning the library, inherited from its highest-criticality downstream software; it doesn’t suggest that each one 137 callers are Tier 1.
Collectively, these indicators change the producer’s plan. As a substitute of merging the elimination and ready for failures, the producer can retain and deprecate the outdated technique, publish a migration path, coordinate a broader migration, and observe the long-tail variations earlier than elimination. File paths and obtainable line numbers flip that scope right into a concrete work record for engineers or coding brokers. The identical API diff paired with weak or stale proof would result in a unique motion: refresh the indexes earlier than deciding. The worth is just not merely detecting the elimination; it’s selecting a proportionate subsequent step.

A Polyglot Basis with SCIP
The shared SCIP format additionally lets Quasar index a number of language ecosystems. Every language indexer resolves its personal code, whereas Quasar can use the ensuing image identities to seek out references throughout repositories.
Conceptually, client-lib indexes Consumer#getLegacyValue(Request) as a definition, whereas checkout-service indexes a reference to the identical image. Quasar can then join the library API to its shopper throughout repositories.

Relationships are particularly helpful when generated code separates the API a producer owns from the symbols shoppers invoke. For instance, Quasar can hint a Protobuf definition via its generated Java members to the repositories that use them, even when shopper code by no means names the .proto factor.
SCIP information symbols and their references; it doesn’t decide whether or not an API change violates an ecosystem’s compatibility guidelines. Right now, Quasar compares listed JVM and Protobuf API definitions and traces Protobuf modifications via generated Java to seek out affected repositories. A separate JVM compatibility-impact path makes use of breaks recognized by a producer-side device to question affected repositories. Go, Python, JavaScript/TypeScript, and Rust assist utilization queries, however Quasar doesn’t but assess their breaking API modifications.
Shifting Danger Evaluation Earlier
Right now, Quasar surfaces API-change findings on pull requests, together with noticed shopper counts and confidence. Producers can use its different queries to examine dependency variations and supply areas, with library criticality as broader context. Collectively, these indicators assist a call earlier than merge.
We need to transfer that context earlier. An agent writing library code ought to acknowledge when it’s altering a public image and seek the advice of Quasar earlier than the change turns into a pull request. Quasar’s APIs and Mannequin Context Protocol (MCP) integration present an entry path, however entry alone doesn’t create consciousness. The coding workflow should additionally acknowledge public API edits so the agent is aware of when to question affect and when to contain the producer.

Earlier steerage is not going to exchange pull-request evaluation. The PR evaluation will nonetheless confirm the concrete diff and catch modifications that weren’t acknowledged throughout coding. Protection, freshness, ambiguity, unsupported platforms, and truncation should journey via each checks in machine-readable type. An agent shouldn’t flip “no noticed usages within the obtainable index” into “protected to take away.”
Right now, brokers can question Quasar via MCP when prompted. We’re working towards making that context a part of the coding workflow, then utilizing recognized name websites to organize migration modifications. Quasar provides semantic proof, an agent reduces migration toil, and the library producer stays answerable for API and launch selections.
What We Realized
Constructing this workflow led us to 4 sensible classes.
- Separate compatibility from attain. A eliminated technique can break the API contract even when Quasar finds no callers. A listing of affected repositories and their library variations exhibits the migration work forward. Producers want each indicators to decide on a launch path.
- Make the proof inspectable. A repository depend is extra helpful with pattern name websites and a model breakdown. The outcome additionally wants to indicate which commits have been listed, how recent the patron indexes are, and whether or not proof was truncated. In any other case, “no utilization discovered” might be mistaken for proof that no one is affected.
- Maintain utilization and compatibility separate throughout languages. SCIP lets Quasar discover image references in a number of ecosystems. Deciding whether or not an API change is breaking requires compatibility guidelines or a trusted producer-side sign for that ecosystem.
- Deliver proof to the producer whereas selections are open. Pull-request findings can immediate a producer to retain an API, publish a migration path, or coordinate shoppers earlier than merge. Shifting the identical proof into the coding workflow might form the edit earlier. After launch, it nonetheless helps find shoppers that must migrate.
Right now, Quasar indexes JVM, Go, Python, JavaScript/TypeScript, and Rust code for cross-repository utilization evaluation. It compares JVM APIs and traces Protobuf modifications via generated Java. Producers can evaluation change findings via Quasar’s REST and GraphQL APIs or its MCP server, then examine affected repositories and name websites. We’re extending this basis towards extra ecosystem-specific compatibility checks, deeper code-review integration, and agent-assisted shopper migrations that maintain launch approval with the producer.
Quasar is inner to Netflix, however the sample is moveable: index code semantically, retain API definitions, evaluate them on the level of change, question affected shoppers, and report the standard of the proof. Library producers want greater than a compatibility verdict. They should know who could also be affected and have sufficient time to behave earlier than launch.
An enormous thanks to the Java Platform crew at Netflix. Their experience, collaboration, and assist made this work attainable
Associated Talks
- From Lag to Lightning: Reworking Dependency Replace Timelines explores how Netflix shortened dependency-update timelines.
- Netflix’s Journey to Assured Automated Code Modifications discusses constructing confidence in automated modifications at scale.
Past API Compatibility: Constructing a Software to Measure the Blast Radius of Library Modifications was initially revealed in Netflix TechBlog on Medium, the place individuals are persevering with the dialog by highlighting and responding to this story.