Am 02.08.2011 17:23, schrieb Alex Tkachman:
> As i said I really appreciate being left out of the loop after all my
> contributions to groovy core and to vision of static compilation.
Alex, if you now imagine that Guillaume, myself and some other did go
and designed a "static mode" for Groovy, then you are wrong. We
contacted some people to see about their fears and concerns for such a
beast. We didn't make really any decision about how it should work, only
about if it should be done and what speaks against it. Also if you think
there had been a lot of discussion in the past... we only about started
with this 2 months ago, with last month basically nothing happening on
the outside or with these people. We put it a bit on hold because you
started the poll and I wanted to use that as entry point for more
discussion in that area with you. Only the two mails we exchanged never
reached this point, as you stopped replying to my second mail already
(that was July 13). The next planned step, once Guillaume is back from
holidays, was to start open discussion on the list including you and
starting a prototype. That's the point we wanted to include everyone and
that is right after we wanted trying to talk to you again. Since we
already know your position to static typing there was no use about
asking you about it directly before that. Only when we start with some
actual planning it makes sense to me. We didn't start the discussion
right away in the open, because we hadn't decided to even do that yet
and it makes only partially sense to stir up the community with worries
about something that is maybe never coming.
Integrating Groovy++ in Groovy is for me all about taking the concepts
that work, look good and are useful, to then make them better and free
them from all the ballast it of course has, because in Groovy++ things
are not as tightly integrated as they can probably be with Grumpy. A
goal for Grumpy is to keep things as simple as possible first. That
means no traits, no native bytecode, no SMA conversion beyond what
Groovy already has, no tail recursion, no multi property set operator,
no mixing in one block of static and nonstatic code, and more.
And the problem sphere for Grumpy and Groovy++ is different. For example
for the each method with a Closure taking an Object parameter, it is for
Grumpy enough to see the DGM-each and be done. Another example is to
subclass BigInteger and there provide your own plus method. Basically
for Grumpy it can be enough to take the BigInteger method we have
defined in the math support, because Grump won't wire that, the runtime
will still do that for us. For Groovy++ you not only want the right
implementation of that method, you also want to make the invocation of
it efficient. That is a much more complex thing to do.
bye blackdrag
--
Jochen "blackdrag" Theodorou
The Groovy Project Tech Lead
http://blackdragsview.blogspot.com/For Groovy programming sources visit
http://groovy.codehaus.org---------------------------------------------------------------------
To unsubscribe from this list, please visit:
http://xircles.codehaus.org/manage_email
Locked
