directory-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Alex Karasulu <>
Subject [eve] builds and directory layout
Date Tue, 29 Jun 2004 03:52:08 GMT

I've been giving the directory structure and the number of maven
projects in Eve a lot of thought lately.  Both Alan and Vince
(rightfully so) thought the number of projects and jars generated were
out of control.  It made it very difficult to get things settup and get
a bering so one can contribute.

I bring this up again now because the site documentation discussions are
very close at heart to these matters as well.  I'm thinking we might as
well do all this together if and when we get to it.

Right now if you look here it describes the current motives for the
directory structure and layout in the Eve subproject:

Here's a snippet of what that looks like:

./eve               -- top component projects and subsystems
  ./frontend        -- contains frontend subsystem APIs and service projects
    ./common        -- contains shared code common to frontend subsystem
      ./api         -- API common to all projects in frontend
    ./buffer        -- frontend buffer service projects
      ./spi         -- frontend buffer service provider interface project
      ./pojo-impl   -- frontend buffer component POJO implementation project
      ./merlin-impl -- frontend buffer component Merlin implementation project
    ./event         -- frontend SEDA event dispatcher service projects
      ./spi         -- frontend event dispatcher SPI project
      ./pojo-impl   -- frontend event dispatcher POJO implementation project
      ./merlin-impl -- frontend event dispatcher Merlin wrapper impl project
  ./backend ... 

This structure is optimal if we were going to reuse these components 
all over the place and expose them as re-usable components much like
the Avalon cornerstone components.  However this is not our objective 
here at the Directory project although we don't mind making Eve itself 
a component.

What are the goals?

1). Keep it simple stupid (KISS)!
2). Minimize the learning curve and setup overhead for new commers 
    (KISS Helps)
3). Allow Eve deployment with any microkernel

#3 conflicts with both #1 and #2.  But there is a balance.  First 
we scrap the need for component level projects: meaning each component
need not have its own service provider interface maven project and pojo 
implementation maven project.  We have one eve maven project which is 
composed of the service interfaces and their default pojo 
implementations.  Next we have the various micro kernel wrappers for Eve.

So the above becomes ...

  backend ...

In the old scheme the number of maven projects equaled:

#_of_components * ( #_of_wrappers + 2 )

Here the number of maven projects equals:

#_of_wrappers + 1

Most people can ignore the Eve wrapper projects minus the one they are 
most interested in.  So essentially their scope only applies to at most
two projects total.

What do you guys think about this approach?


View raw message