Hi Sergey and Romain,

Thank you both for the suggestions and references. They give me a clearer
direction for investigating this idea.

Romain, I went through Maven issue #11136
<https://github.com/apache/maven/issues/11136>. From my understanding, it
primarily focuses on ABI compatibility metadata between library versions
and dependency resolution. My proposal is more focused on using ABI changes
and class-level dependency information to determine which classes need
recompilation during a build.

However, I can see some conceptual overlap in ABI modelling. I'll
investigate the existing work further to understand whether there are
reusable components or related design decisions.

Sergey, regarding ABI model storage, I was initially considering keeping
the metadata as module-specific build state rather than introducing
attached artifacts immediately.

One possible starting point would be to store ABI snapshots and class-level
dependency information inside the module's build output directory, under a
dedicated Maven Compiler Plugin directory. This would allow the metadata to
be regenerated whenever necessary and avoid introducing additional artifact
publication or resolution requirements during the initial prototype.

For external dependencies, I would like to investigate whether ABI
information could be cached separately using artifact identity and content
fingerprints.

I also find your suggestion of starting with a standalone Maven extension
interesting. I'll explore your maven-surefire-cached project to understand
its delegation approach and whether a similar architecture could help
validate the concept before considering integration into the compiler
plugin.

My next step will be to study the existing incremental compilation
implementation, investigate the related ABI work, and build a small proof
of concept before finalizing the scope.

Thank you again for taking the time to share your experience and guidance.

Best regards,
Charan Gowda M D

On Mon, 16 Nov 2026 at 01:35, Romain Manni-Bucau <[email protected]>
wrote:

> Hi Charan,
>
> Did you review https://github.com/apache/maven/issues/11136 ? Might
> overlap
> - Guillaume works a lot on that and concurrent builds.
>
> Romain Manni-Bucau
> @rmannibucau <https://x.com/rmannibucau> | .NET Blog
> <https://dotnetbirdie.github.io/> | Blog <https://rmannibucau.github.io/>
> | Old
> Blog <http://rmannibucau.wordpress.com> | Github
> <https://github.com/rmannibucau> | LinkedIn
> <https://www.linkedin.com/in/rmannibucau> | Book
> <
> https://www.packtpub.com/en-us/product/java-ee-8-high-performance-9781788473064
> >
> Javaccino <https://javaccino.dev/> founder (Java/.NET service - contact
> via
> linkedin)
>
>
> Le dim. 15 nov. 2026 à 20:46, Sergey Chernov <[email protected]> a
> écrit :
>
> > Hey, Charan.
> >
> > This feature is potentially interesting though it has few caveats.
> > One of the questions that I have: where do you plan to store the ABI
> models
> > for modules and for the libraries?
> > E.g. Gradle stores this in its ~/.gradle/caches/X/transforms (if I'm not
> > mistaken).
> > But regarding Maven it can be target directories for module, ~/.m2 or
> > projectRoot/.mvn/target (since Maven 4). Should it be a new attached
> > artifacts of the build?
> >
> > Indeed such enhancement may be too ambitious (while potentially
> realistic).
> > What I did in the past was somehow similar, but related to
> > surefire/failsafe plugins caching (as in our case it takes approx ~95% of
> > all build time to run tests, while things like compilation are relatively
> > fast).
> > Instead of forking the plugin (or submitting the change directly to it),
> I
> > made an extension that creates proxying wrapper to the real
> > standard-implemented surefire Mojo delegates. And this wrapper first
> checks
> > the existing cache entries (in my case these are stored in
> > ~/.m2/test-cache)
> > and takes cached artifacts (usually TEST-*.xml reports, but not only),
> > otherwise executes the tests (delegates to default Mojos) and in case of
> > success caches them (either locally or remotely). This can be a good
> start
> > for your early prototyping, and such project can live separately even if
> > eventually the enhancement is not merged to the main branch of
> > maven-compiler-plugin. I mean the logic of either delegating or skipping
> > the default impl.
> > My project is https://github.com/seregamorph/maven-surefire-cached which
> > may be a reference as it gives some clarity on the approach. Conceptually
> > it's quite different to how the Apache Maven Build Cache Extension is
> > implemented.
> >
> >
> > On Sun, Nov 15, 2026 at 7:40 PM CHARAN GOWDA M D <
> [email protected]>
> > wrote:
> >
> > > Hi everyone,
> > >
> > > I'm Charan, a Computer Science Engineering student and a contributor to
> > > Apache Maven. Some of my contributions include:
> > >
> > >    -
> > >
> > >    https://github.com/apache/maven/pull/13941
> > >    -
> > >
> > >    https://github.com/apache/maven/pull/13722
> > >
> > > I'm considering applying for GSoC 2027 with Apache Maven. Before
> > preparing
> > > a full proposal, I'd like to share an idea I've been exploring and get
> > > feedback from the community.
> > >
> > > *Proposal: Introduce class-level dependency tracking and ABI-aware
> > > invalidation for incremental compilation in maven-compiler-plugin.*
> > >
> > > *Problem*
> > >
> > > The Maven Compiler Plugin already supports incremental compilation
> > through
> > > different strategies. However, its current approach primarily
> determines
> > > which source files need compilation based on file changes, timestamps,
> > > compiler options, and dependency changes.
> > >
> > > For example, when a source file is modified, Maven's default
> incremental
> > > compilation strategy can trigger recompilation of the entire module.
> > > Alternatively, compiling only the modified source files does not
> > > necessarily recompile other classes that depend on the changed class,
> > which
> > > can lead to compilation errors or inconsistent outputs.
> > >
> > > This creates an opportunity to explore a more dependency-aware approach
> > to
> > > incremental Java compilation, particularly for large projects
> containing
> > > many source files.
> > >
> > > *Proposed idea*
> > >
> > > Investigate and prototype class-level dependency tracking in
> > > maven-compiler-plugin.
> > >
> > > The proposed mechanism would maintain a dependency graph between
> compiled
> > > classes and use it to determine which classes are affected when a
> source
> > > file changes.
> > >
> > > Ideally, the implementation would also distinguish between API/ABI
> > changes
> > > and implementation-only changes.
> > >
> > > For example:
> > >
> > > User.java
> > >     |
> > >     +---- UserService.java
> > >     |          |
> > >     |          +---- UserController.java
> > >     |
> > >     +---- UserRepository.java
> > >
> > > PaymentService.java
> > >
> > > Consider two scenarios:
> > >
> > >    1.
> > >
> > >    *Implementation-only change:* If only the body of a private method
> in
> > >    User.java changes without affecting its externally observable ABI,
> > >    dependent classes may not need recompilation.
> > >    2.
> > >
> > >    *API/ABI change:* If a public method signature or another relevant
> > >    compile-time contract changes, the affected dependent classes should
> > be
> > >    identified and recompiled.
> > >
> > > The intention is to minimize unnecessary compilation while preserving
> the
> > > correctness and consistency of build outputs.
> > >
> > > *Prior art and existing work*
> > >
> > > I've started looking into the following:
> > >
> > >    -
> > >
> > >    *Maven Compiler Plugin:* Its existing incremental compilation
> > >    strategies, particularly the incrementalCompilation configuration
> > >    introduced in the 4.x line. I want to understand how the existing
> > > classes,
> > >    sources, and rebuild strategies can be extended or improved without
> > >    duplicating existing functionality.
> > >    -
> > >
> > >    *Maven Build Cache Extension:* It already provides input
> > fingerprinting,
> > >    build caching, and restoration of previously generated outputs. I
> > would
> > >    like to understand how class-level dependency analysis could
> > complement
> > > its
> > >    existing caching mechanism.
> > >    -
> > >
> > >    *Gradle incremental Java compilation:* Gradle provides class-level
> > >    dependency analysis and ABI-based compile avoidance. Its approach is
> > an
> > >    interesting reference for investigating how similar capabilities
> could
> > > fit
> > >    into Maven's compiler plugin architecture.
> > >    -
> > >
> > >    *GNU Make:* Its prerequisite-based dependency model initially
> inspired
> > >    this exploration. However, Java compilation introduces additional
> > >    complexity, particularly around type dependencies, compiler
> analysis,
> > > and
> > >    generated sources.
> > >
> > > *Open design questions*
> > >
> > > There are several areas where I would appreciate guidance:
> > >
> > >    1.
> > >
> > >    *Dependency analysis:* What would be the most reliable approach to
> > >    constructing a class-level dependency graph? Should this be based on
> > >    bytecode analysis, compiler APIs, or another mechanism?
> > >    2.
> > >
> > >    *ABI detection:* How should the implementation identify changes that
> > >    affect a class's compile-time contract versus changes limited to its
> > >    implementation?
> > >    3.
> > >
> > >    *Correctness and edge cases:* How should cases involving inlined
> > >    constants, annotation processors, generated sources, inheritance,
> and
> > >    deleted classes be handled?
> > >    4.
> > >
> > >    *Build cache integration:* How should the dependency information be
> > >    persisted and integrated with the existing Build Cache Extension
> > without
> > >    introducing inconsistent build results?
> > >    5.
> > >
> > >    *Compatibility:* How can this functionality be introduced without
> > >    breaking existing compiler plugin configurations or changing the
> > > behaviour
> > >    of existing incremental compilation strategies?
> > >
> > > *Rough implementation plan (12 weeks)*
> > >
> > >    1.
> > >
> > >    *Research and design:* Study the existing incremental compilation
> > >    implementation, reproduce relevant scenarios, investigate Gradle's
> > >    approach, and prepare a design document.
> > >    2.
> > >
> > >    *Dependency analysis prototype:* Develop a mechanism to collect and
> > >    persist class-level dependency information, initially focusing on
> > >    straightforward Java dependency relationships.
> > >    3.
> > >
> > >    *Change detection and invalidation:* Identify affected classes after
> > >    source changes and investigate ABI-aware invalidation. Use
> > conservative
> > >    full recompilation whenever correctness cannot be established.
> > >    4.
> > >
> > >    *Testing and evaluation:* Add unit and integration tests covering
> > >    dependency changes, API modifications, implementation-only changes,
> > > deleted
> > >    classes, and relevant edge cases.
> > >    5.
> > >
> > >    *Performance evaluation and documentation:* Compare compilation
> > >    behaviour against the existing strategies using representative
> > projects
> > > and
> > >    document the implementation, limitations, and performance results.
> > >
> > > The scope would be refined based on the existing implementation and
> > > community feedback.
> > >
> > > *I'd appreciate feedback on the following:*
> > >
> > >    1.
> > >
> > >    Is this a meaningful and feasible direction for a 12-week GSoC
> > project,
> > >    or is the proposed scope too ambitious?
> > >    2.
> > >
> > >    Does similar functionality already exist in the Maven Compiler
> > Plugin's
> > >    development branch, Maven 4, or any ongoing discussions or JIRA
> > issues?
> > >    3.
> > >
> > >    Would maven-compiler-plugin be the appropriate place for this
> > >    implementation, or would parts of the functionality be better suited
> > to
> > >    another Maven component?
> > >    4.
> > >
> > >    Would any Apache Maven committer or experienced contributor be
> > >    interested in discussing and potentially mentoring this idea for
> GSoC
> > > 2027?
> > >    5.
> > >
> > >    Are there specific classes, existing implementations, or design
> > >    discussions in the codebase that I should investigate before taking
> > this
> > >    further?
> > >
> > > I understand that this is an early-stage idea and that some aspects may
> > > overlap with existing work. I'm open to refining the scope or
> exploring a
> > > different approach based on the community's feedback.
> > >
> > > As I've already started contributing to Maven, I'd like to use this
> > > opportunity to work on a more substantial improvement and develop a
> > deeper
> > > understanding of its compiler and build execution architecture.
> > >
> > > I'd appreciate any feedback, suggestions, or pointers to relevant
> > > discussions.
> > >
> > > Thank you for your time.
> > >
> > > Best regards,
> > >
> > > Charan Gowda M D
> > > GitHub: https://github.com/charangowdamd-cmd
> > >
> >
>

Reply via email to