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
