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
