@Johannes Barop

Your approach is interesting since it allows you to avoid cache the results
of generator execution and not have to reparse and recompile generated code
during every monolithic compile. But since it's all based on GWTAR, you're
still limited to a maximum possible impact of 50%.

The approach i'm working on should be limited only by the number of modules
you define (the more the better) and the cost of global phase generator
execution (most of which I should be able to automatically move into local
phases, aka part of specific modules). So, while I can't guarantee that
your setup will be "easily adoptable to the new compiler", it shouldn't
matter since the new incremental compilation path should be faster than
your setup and thus make it unnecessary.

There's not a lot you can do to help right now but I could eventually use
some help setting up support in external build systems (like Maven and Ant,
and possibly integrated with the GWT Eclipse plugin) for triggering the GWT
compiler once per module and/or once per modified module. I'll also
probably eventually want some external testers before this goes live. So
i'll keep you in mind.



On Wed, Aug 21, 2013 at 1:46 PM, Johannes Barop <[email protected]> wrote:

>
> Am 21.08.2013 um 09:05 schrieb James Nelson <[email protected]>:
>
> > I've long felt like highly modular projects could greatly benefit from
> producing gwtar files so that unchanged code does not require recompiling.
> > I've thought about using a maven plugin to add .gwtar to my jars, though
> this would not be a portable solution for all GWT developers.
> >
> > Any portable solution using gwtar would be to create one per module
> (using a flag to enable support while still experimental), or one per java
> package (maybe not a good idea given the size of some projects).
> >
> > Given that the compiler already knows to remove invalidated units, this
> does seem like a feasible option.
> > Producing .gwtars could also be done periodically for the whole project
> at the developers whim, perhaps through a flag to a standard full compile?
>
> As far as I know a usual gwtar contains only a precompiled Java AST from
> the first compilation phase. You still need to run the generators on all
> the visible code. It saves some seconds but for me the most time consuming
> part is the code generation and JavaScript compilation.
>
> I've currently playing around with a project where I have multiple
> modules. For each module I generate the initial Java AST, run code
> generators and throw the precompiled code in a gwttar. When building the
> final application only a small code generator which discovers all
> precomputed code runs.
>
> It's a special use case because I have defined decoupled modules which I
> want to link together. I'm unsure if this is any help for an "intelligent"
> approach :-)
>
> @John Stalcup
> Is it possible to contribute in this area? For example I want to ensure
> that the code for the project is easily adoptable to the new compiler.
>
>
> BTW:
> I agree with Stephen that Java IDE's also should be supported well. Yes
> SuperDevMode enabled to debug in the browser but the IDE is the tool I'm
> used too and I have to use the IDE for server code anyway.
>
> --
> 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 [email protected].
> For more options, visit https://groups.google.com/groups/opt_out.
>

-- 
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 [email protected].
For more options, visit https://groups.google.com/groups/opt_out.

Reply via email to