I'm moving an application out of an svn repository it shares with a bunch of other stuff into its own, brand new one. So, I have a chance to make a fresh start with layout.

The app itself has two components - a reasonably standard Java webapp, that talks to a database, and a backend component, also Java, that polls the db, and kicks off long-running processing tasks based on what it finds - essentially, the DB is being used as a queue. The code is broken up into three packages:

1. `org.blah.common` - code, such as DAOs, that is shared between web app and back end
2. `org.blah.webapp` - The web app; this depends on `org.blah.common`, and builds out to a `.war` file.
3. `org.blah.backend` - The back end process; this depends on `org.blah.common`, and builds out to a tar file containing a jar and some scripts.

I'd also like to get other bits of tomcat and apache config into svn as well.

Right now, all three packages are in svn under a `src` dir, and there's an ant script with different targets that build the different parts. It's all a bit scrappy - the svn:ignore property has gotten quite big, and it's not immediately apparent that the scripts in one dir are related to the code in some package down under `src`, while those in another are for starting and stopping tomcat.

I'm drawn to the [maven standard directory layout](http://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html), but I've not used it before. I've come up with this:

```
common/
    src/
        main/
            java/
            resources/
        test/
            java/
            resources/
    target/    # Not checked in
        common.jar
webapp/
    src/
        main/
            java/
            resources/
            webapp/
        test/
            java/
            resources/
    target/    # Not checked in
        webapp.war
backend/
    src/
        main/
            java/
            perl/
            resources/
        test/
            java/
            resources/
    target/    # Not checked in
        backend.tar
infra/
    tomcat/
        bin/
        conf/
    apache/
        bin/
        conf/
db/
    tables/
    procs/
    triggers/

```

Note that right now, I don't intend to migrate to maven - I'll adapt the existing ant scripts, since they work. I'd like to keep the option of moving to maven (or something like buildr, that uses the maven layout) at some point in the future though.

So:

* Does this seem like a reasonable way of laying out the repository? Is there anything that will trip me up further down the line?
* Is this going to be obvious to people new to the app?
* Would this be compatible with maven, should I decide to use it? (I know that theoretically, you can make maven work with any layout, but I believe they recommend a standard for a reason.)
* Are IDEs going to have any problems with this? (Depending on which computer I'm on, I use intellij or eclipse. Other people on my team - who helpfully don't have opinions on this - use netbeans.)