TBH this sounds overly complex and complicated for a GSoC project. It might be a good idea, but I wouldn't suggest it be undertaken by a student or really anyone who's not already deeply familiar with Maven internals.
On Sun, Nov 15, 2026 at 6: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 -- Elliotte Rusty Harold [email protected] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
