> I may need to revisit some of that responsibility though, since the 
> current GWT Eclipse plugin owns/manages the GWT compile triggering process. 
> I'm toying with the idea of implementing this iterative compilation 
> triggering responsibility in Maven and (since GWT shouldn't try to act like 
> a build system) then integrating this into the GWT Eclipse plugin? I 
> haven't thought all the way through this part and haven't implemented any 
> of this part yet, so would appreciate suggestions.
>

In my experience with eclipse plugins, the m2eclipse plugin is actually 
more user friendly to perform tasks with than the actual eclipse build 
process.
Anything and everything that does work in maven can work with m2eclipse.

The only gotcha is that not everyone is on the maven bandwagon.  
Still, it would be possible to setup a hidden "shadow project" based solely 
on source dependencies and .gwt.xml modules.
Of course, requiring m2eclipse for the gwt plugin may be a little 
intrusive, but it could prevent duplication of labor (reuse in eclipse, and 
probably intelliJ as well).

As for incremental recompiles, maven out-of-the-box does not have good 
support for this (yet).
At work, we use a custom plugin that computes unique hashes of files to 
detect changes; every snapshot is compiled and deployed to a repo, so the 
plugin can use the existing jar if it is found, or compile and deploy a new 
one if needed.
For gwt compiles, it would make sense to use a local-repo in /target or 
gwt-unitCache to do something similar; obviously the computing of these 
hashes would add a little overhead, 
but given that hashing a file is certainly faster than recompiling, 
visiting and translating the file, it would still be a win.

I'd heard that maven 3 has extra support for something similar to this, but 
I have yet to see a production use case for it (and I'm pretty sure it 
depends on nexus setup, which is clearly way more overhead than necessary).

If you had a spec for what you want a maven / eclipse plugin to do, I do 
have experience with both, and would be glad to help.


Also, ant tends to have much better support for incremental builds using 
timestamps, which is fine for local development;
we prefer the hash approach because it allows a dependency built by 
developer A to be reused by developer B,
but if we're storing all this locally, timestamps would likely be the best 
of both worlds.

-- 
http://groups.google.com/group/Google-Web-Toolkit-Contributors
--- 
You received this message because you are subscribed to the Google Groups "GWT 
Contributors" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to google-web-toolkit-contributors+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

Reply via email to