Leave the Class Path in the Rearview Mirror

The Java Module System provides a foundation for modern Java development, offering stronger models for projects, dependencies, and builds that align with the capabilities of the existing ecosystem. This evolution is introduced through command line tools like `ja` and its family, which leverage the module descriptor to create a complete project description including dependency information. These tools offer composable command line ergonomics that address gaps where graphical IDE tools are less effective, particularly for coding agents struggling with dependency resolution and source location.
The composable tools include specialized utilities such as `jig` for module version resolution and build orchestration, `jfmt` for formatting source code according to modern conventions, `jist` for symbol searching across sources, and `jdocserver` for API documentation. These tools discover and execute capabilities by implementing platform-defined models, allowing them to interact with standard JDK tooling like `jdeps`, `jlink`, and `jshell`.
The article also details strategies for maintaining module integrity through metadata, such as specifying runtime access requirements via annotations, which are enforced during dependency resolution. This includes using persistent hashes in `module-info.hash` files to verify binary dependencies and ensuring that annotation processing is treated as an explicit code generation step to improve visibility and review. The ultimate goal is to encourage a modular approach across all Java projects by making modules the default structure.

* The Java Module System evolved existing models for projects, dependencies, and builds.
* `ja` and its family provide command line tools for modern Java development based on the Java Module System capabilities.
* The module descriptor is used to include project descriptions and dependency versions.
* Tools include `jig`, which handles module version resolution, compilation, assembly, and interaction with Maven repositories.
* `jfmt` formats source code using adapted Code Conventions for modern Java.
* `jist` provides source-aware symbol search functionality.
* `jdocserver` provides locally browsable API documentation.
* Tools implement the tool discovery and execution model via `OptionChecker` and custom metadata to resolve module system options.
* Module integrity is ensured by persistent hashes in a `module-info.hash` file to verify binary dependencies.
* Runtime access requirements can be declared as module metadata (e.g., `@enableFinalFieldMutation`).
* The command line interface allows combining dependency resolution and authorization, for example, using `ja require ... --enable-final-field-mutation`.
* Module integrity is verified by sequent resolution checking persistent hashes.

The shift toward a module-first paradigm introduces tension between established repository practices and the need for verifiable, machine-readable metadata. The solution proposed attempts to reconcile this by layering verifiable coordination (using Maven coordinates and published artifact names) on top of module concepts, acknowledging that existing systems have favored namespace conventions over strict module naming in repositories.
The enforcement of integrity through runtime checks and hash verification establishes a novel mechanism for data provenance within the JVM ecosystem, moving beyond static analysis into runtime guarantees. This creates an expectation that developers must explicitly define security and access constraints at runtime, shifting responsibility from implicit path access to explicit authorization carried through the module lifecycle.
A significant implication is the re-framing of developer experience: command line tools are positioned as necessary complements to IDEs, suggesting that raw linguistic capability alone is insufficient for complex, scalable projects. The emphasis on composable tooling suggests a decentralized approach to development scaffolding, which contrasts with monolithic build systems. The challenge lies in ensuring that the mechanisms for establishing canonical coordinates and verifying module integrity do not introduce new points of failure or complexity that undermine the stated goal of making modularity the default. What assumptions are made about the ease with which developers will adopt this layered specification over deeply ingrained habits regarding classpath management?