I'm trying to take as step back here to see the general issue of sub-modules rather than the pinpoint solution for alfredo or hoop.
Comment quite long, two main sections: Flat vs Hierarchical module structure & dual artifacts modules.
Flat vs Hierarchical module structure
For the purposes of the discussion, I'm leaving aside the concerns of another SVN move.
When organizing a multi-module Maven project there are 2 approaches, using a flat module structure or using a hierarchical module structure.
Our current layout is a mix of both (for the purposes of the generalization, lets assume hoop is in as well):
hadoop-auth/ (f) (this is alfredo)
hadoop-hdfs-http-client/ (f) (this is hoop)
hadoop-hdfs-http-server/ (f) (this is hoop)
hadoop-mapreduce/ (h) (*)
(f: flat modules, h: hierarchical modules, *: aggregator modules)
1. Note that the module names, flat or hierarchical, denote the hierarchy. Those names also denote the artifact name produced the module (typically a JAR). Because of this I think module names should stay as they are regardless.
2. The nice thing about a hierarchal structure is that we use directory levels to naturally represent the hierarchy. Still, because of #1, we shouldn't simplify the names. The bad thing, is that navigating through directory paths becomes a bit more cumbersome/long. Another issue is that we need additional aggregator modules (like hadoop-mapreduce, hadoop-mr-client and hadoop-yarn).
3. The nice thing about flat structure is that directory navigation is easy, the structure is in the names already. The bad thing is that the number of directories at trunk/ level is larger. The bad thing is that the sense of module scope is lost. IDEs like IntelliJ and Eclipse flatten the hierarchy. Thus, a flatten structure could be a bit more intuitive.
4. Maven doesn't care if flat or hierarchical, it resolves the order of building based on dependencies.
Personally, I'd prefer a flat structure, but I'm OK either way. What I would definitely like is to have full consistency.
Dual Artifact Modules
Currently hadoop-common and hadoop-hdfs modules produce 2 types of artifacts, a JAR and a TAR.
In my opinion, a Maven module should produce a single artifact, a JAR or a TAR. This is, for Common and HDFS we should have a hadoop-common-dist and a hadoop-hdfs-dist modules that only do assembly work. This decoupling will easily allow to bundle hoop with HDFS.
Otherwise, if Hoop depends on HDFS (it must for testing) there is a circular dependency (Hoop depends on HDFS for build/testing, HDFS depends on Hoop for packaging).
Because of this I'd advocate for single artifact modules.