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