Re: Improve 'Geronimo' Development--WORDY RESPONSE

[Tim McConnell <ti...@gmail.com>]

Hi Sachin, this is a very good question and I've been dwelling on it for a number of weeks 
now after looking at the Geronimo deployment code, and the integration steps required for 
JSF 1.2. Being the new kid on the block in the community I feel there is another side to 
this problem that also has some room for improvement. Two of the things that first struck 
me about Geronimo when I joined the team were how little code there is in Geronimo proper 
(relatively), and how much a simple user interface with a topology and dependency viewer 
would really improve maven. So my three main points are that:

1 -- One of the primary strengths of Geronimo is how configurable it is and how so many 
other other services and functions can be integrated into it. I hesitate to use the word 
"easily" here though--it might be easy after a steep learning curve but it's not 
intuitively easy.
2 -- How there are really no GUI based tools to aid in the tasks required for integration, 
configuration, and building of Geronimo
3 -- How much time developers spend doing changes for integration, configuration, and the 
maven build, and how little time is spent writing Java code. This point may seem like 
somewhat of an exaggeration but I see the all the changes flowing into SVN/SVK everyday 
and the Java changes are easily surpassed by the various changes to XML type files

I'm very visually oriented and consume and retain information much easier when it's in 
graphical in nature. So it just seems to me that we could easily create a GUI-based tool 
to aid in the tasks required for new integrations and configurations--not another IDE for 
Java development but maybe an analog such as an Integration and Configuration Environment 
(I can think of a very cool acronym here).

So, I'm kinda envisioning a tool with some of the selected capabilities of Eclipse GEF, 
Visio, and XMLSpy. I for one would really benefit from a tool with these capabilities:

-- See a hierarchical view of all the POM's required to build Geronimo and the 
dependencies between those POM's, and could selectively drill down from the top-most POM 
into all the other dependent levels, expand and collapse various trees in the hierarchy, 
and easily navigate and traverse the build and dependency topology
-- Change XML in graphical or tabular view (like any XML editor or XMLSpy) such that the 
views/forms are created and validated with the appropriate XSD(s) instead of editing XML 
using a flat-file editor . This could apply not just to Maven POM XML files, but also 
Geronimo-specific deployment plan XML files, etc....
-- Search and display (and create or delete) dependencies and relationships graphically
-- Graphically view all the dependencies and artifacts within a particular Geronimo assembly
-- Graphically view all the dependencies for modules and GBeans
-- Drag and drop dependencies and artifacts from lists to nodes in the topology
-- Use wizards based on best-practices and past experiences for integration of new 
functions/services
-- I could go on and on but I hope I've conveyed my thoughts.

Of course, this is just my impression--it just seems we could be more productive if we 
could mitigate some of the effort required to configure and integrate new function and/or 
services into Geronimo with a GUI based tool (not yet another command line based tool) 
such that we could spend more productive time coding and less time 
integrating/configuring/building. Obviously, this is not a panacea but I'm wondering what 
others in the community think. I'm actually thinking it might be worthwhile for me to plan 
to spend some time over the holidays doing a simple staged prototype (e.g., first, display 
the maven build topology, then maybe graphically display the Geronimo specific deployment 
plans, etc...) and then solicit more feedback/comments. Any thoughts ?? Be brutal--I don't 
mind.

Thanks much
Tim

Sachin Patel wrote:
> So since I've been working on Geronimo, one of the most annoying things 
> developing Geronimo in an IDE is the overhead involved between modifing 
> code and being able to test the code.  For a single line change you have 
> to rebuild and install the module, rebuild the assembly, and re-extract 
> and relaunch the server image.  This is needed since Geronimo loads 
> classes from the server repository and currently cannot from the local 
> m2 repo or from the "target/classes" directory itself.
> 
> Well to ease the developer experience I think we need to change that.  
> As a first step, I'd like to see if we can hook into geronimo a 
> "developers module" that the repository code can delegate over to to 
> load from the m2 repo.  That itself would be an improvement and 
> developers could simply rebuild the module without having to regen a new 
> assembly.  A step beyond that would be the ability to treat the source 
> tree as a repo, and geronimo load directly from target/classes, this is 
> tricker since the modules in the source tree don't follow a 
> groupId/artifact/version/type convention so some sort of intelligent 
> mapping would have to be done.  In theory, this would give us the 
> ability to simply compile a module (with an IDE compiler and not maven) 
> and simply re-start the server.
> 
> Would this be an effort that would be valuable to the community?
> 
> If so, if there are suggestions on how to go about implementing either 
> the first or second solution, please give your input.
> 
> thx
>  
> -sachin
> 
>