GWT evolves to slowly
wangzx
no bug is closed(although most of them require only 1 line
modification), no new components, no new features.
So what is google's really manner on GWT?
wolverine
really concern me.
georgeuoa
'faster' web page it's ready for use. But in my own experience
(scattered as posts around the forum) there are just now a little too
few bugs and problems with the hosted mode which, in bad sportsmanship,
the GWT team has neither commented on or included them into the open
issue list. Speaking for myself, from an over-hilarious feeling of
new-lit exhaltation I'm now down to an asi-asi, and just hope the new
GWT release will fix these issues.
If you think you need to use a lot of serialisation, complex layouts
(many widgets into other widgets) and complex inheritance (widgets
initialising other widgets in the constructor, a particularily nasty
idiom of GWT which doesn't initialise properties in the correct order)
then you will bitterly fail with GWT.
Please don't think I'm rampaging on the forum, I've already written a
complex GWT app , gone live with it and have answered many trivial and
less trivial question of other members.
Of course, I still reserve the right to be completely wrong and just
not having got the 'grasp' of it :)
G.
-----------------------------------------
Using GWT _is_ possible in complex applications, just a huge pain.
Using other ajax frameworks in complex application is impossible.
ash
large application with GWT and his recommendations are spot on.
my story:
not to long ago i too hung in desperation and lost an entire day
attempting to track down a compiler error. however, i pinged scott blum
who recieved my email in the early hours (im in australia) and he
responded immediately from home before getting to the google office.
(see msg extract below)
<snip>
mate,
thanks for the reply. you were right on the money. i discovered this
about 10 min ago after i injected some byte-code into the google
classes to give me some indication of what is going on. my injection
was good enough to report which method was the culprit and from there i
tried a few different things out.
i go to admit, i love your product but the pain of addressing runtime
library and kernel problems in addition to application code is bringing
me to tears.
thanks for the prompt response.
ill let u guys see my work soon enough
rgds ash
</snip>
scott's actions indicate to me a very high level of concern and care.
frankly, the tone of this thread made me want to share my story.
from my experience, most of the bugs that are reported are ones that we
are empowered to fix ourselves. hence, why i maintain my own user r/t
library. there are other defects that are in the compiler that we as a
community cant do anything about except wait for the next distro.
fortunately, im yet to encounter one of those.
perhaps as a community we should start thinking about taking ownership
of the user runtime (which incl serialisation) and letting google
manage the distribution of the:
* compiler
* emulation subsystem and
* hosted platforms
i already plan on open-sourcing my GWT MVC framework that ive been
using to build my application. perhaps i should commit all my user r/t
bug fixes/enhancements as a subproject. when google releases the next
user r/t i will do an svn merge treating my distro as a branch.
purpose of this post: we can do something about most of these problems.
waiting on a vendor in the product game can kill you.
rgds ash
pierrot
>no bug is closed(although most of them require only 1 line
>modification), no new components, no new features.
Hey dude. Do you work for Microsoft?
Elam
Ash. It would beat hours of searching the forums for solutions.
Anthony
I'm personally not currently thinking of GWT as "open source" since
it's clearly a closed team of Google developers working on it, not a
community of developers. I think of GWT more as a free product from a
software company that over time will hopefully grow into a true open
source model with contributors from the community.
GWT being controlled by a small team is great thing and I applaud the
Google GWT team for taking this approach. At the inception of any code
base a small core team should be in control of both the vision and the
code. They are the ones with the architectural and product vision and
they should set the direction. The Google GWT team is rightly seeking
feedback from other developers. We can all help the Google team by
providing bug reports and constructive feedback about the architecture,
and this is what they are asking for per their faq:
"We're releasing GWT in beta to get feedback from the developer
community. We expect to update the GWT class libraries and development
tools based on this feedback, and once we're confident that GWT
developers are satisfied with the features and stability of the GWT
tools, we'll remove the beta label. In the meantime, you should expect
the APIs to change in upcoming versions of the product."
Great software takes time. Think of this in the context of the history
of the Java programming language. It has changed enormously over the
years, and in big ways. I hope the Google GWT team can learn from the
history of Java and open GWT up sooner, but not yet! James Gosling,
Ted Husted, Linus Torvalis all maintained control of their code and
project direction in the early years. Take a look at the history of
Java for perspective:
http://java.sun.com/features/1998/05/birthday.html
http://en.wikipedia.org/wiki/Java_programming_language
Finally, I don't think it's a good idea to build a large code base on
GWT. Not yet. Anybody building a large code base should be ready for
a bumpy road ahead and really doesn't have a right to complain about
the uncomfortable ride. Obviously, GWT is not yet mature and and this
is one of the primary concerns raised in my GWT review:
http://groups.google.com/group/Google-Web-Toolkit/browse_thread/thread/8dd3d87da9f4b1f1/
Finally, much thanks to Google and the GWT team for the exciting vision
and toolkit.
Please, take your time and do it right!
Anthony
Colorado HomeFinder
www.COhomefinder.com
Our live, production GWT mortgage calculator:
http://www.cohomefinder.com/Colorado-mortgage.htm
Eugine
> Hey dude. Do you work for Microsoft?
Hey, dude - have you tried working with GWT? He's exactly right.
pierrot
to understand the purpose of GWT and I'm certain Google will provide
new releases in due time.
Eugine
over a month ago. This is a long time for a brand new technology, and
is too long if you are looking for the technology to be adopted. GWT is
a young technology and needs a lot of support before it can be
considered mature (and not need as much maintainance.)
I am mindful of Google, and do not want to sound ungrateful, however
you must realize that for some developers (myself included) the
sporadic update schedule and uncertainty of updates is a problem, since
we are looking to use GWT for large projects, and have to report to our
Project Managers on suitability of GWT.
As for whether GWT works well or not - that is an opinion, and as such
I am entitled to having my own. I don't bitch at you for finding that
GWT works well for your purposes, so don't bitch at me for my
repeatedly running into bugs in GWT. In fact if you look at other posts
in the forum you'll see a great number of bugs which have been reported
by people - and confirmed by the GWT developers. Many of the bugs are
a one-line fix, yet remain an issue until the next release. This does
not make GWT worse of a system, but it does reduce its usability.
As for the "purpose of the GWT" - the purpose of it was to create a OO
framework for Google to write its own webapps in. This in itself
carries no responsibility to us. However when Google decided to release
GWT for use by developers it made an implicit as well as an explicit
promise to continue work on the GWT.
To be more specific, the purpose of GWT is to provide a high-level OO
language to be used in writing JS applications.
Do you have a different "purpose of GWT" in mind?
wangzx
like GWT, So is the reason that i hope GWT more.
I know GWT is not opensource but "Beta" and "Free" product, that is the
decision of google, but i still can express my hope: by opensource GWT,
it will evolved more quickly.
really, GWT is very powerful, extend GWT is easy, such as DOM support,
new component, add i18n support etc. But if each useful feature is
required a 3rd solution from internet, why not merge them into the GWT
core?
pierrot
>language to be used in writing JS applications.
>Do you have a different "purpose of GWT" in mind?
The best developers on this planet are probably now working for Google
and if GWT is mature enough to be used by them to develop sophisticated
applications like GoogleMaps then it certainly can be used by mere
mortals like us to develop any application we can dream of.
Cheerio.
cole...@gmail.com
they are only used as examples of AJAX applications. At this point,
GWT is not mature enough to develop those kinds of applications without
major bug fixes.
Eugine
pierrot wrote:
> The best developers on this planet are probably now working for Google
> and if GWT is mature enough to be used by them to develop sophisticated
> applications like GoogleMaps then it certainly can be used by mere
> mortals like us to develop any application we can dream of.
One does not really follow from the other.
Google developers are indeed the best, however I don't consider myself
to be a mere mortal, even compared to them. A friend of mine works for
Google, and I've got to tell you - he's a flesh-and-blood human like
the rest of us.
My point is that skill of programmers does not reflect in any way on
the complexity of programs they are assigned to write.
For example you may be a good programmer for all I know - however in
your program you obviously didn't need to remove rows several times
from an existing table. If you had - you would have run into a small
GWT bug that nevertheless breaks the entire table scheme (bug detected,
solution found and expected in the next release.)
Likewise you probably didn't try to construct a dynamic tree in GWT. If
you had you would have seen that a trivial bug (detected and solution
known to be a one-line fix) makes it trigger two consecutive
"onTreeItemStateChanged" events.
Similarly a bug prevents you from writing a line like
"Window.setTitle("New Title");" because the setTitle method was
accidentally not declared as static.
The point is that many of these bugs are features that may not be used
in 19 programs out of 20. Does that mean that if the GWT team hasn't
until now used the features then we shouldn't use them? No! There are
dozens of people currently working with GWT, hundreds of projects being
made. Sooner or later people run into the bugs. Is it wrong for us to
want the bugs fixed? I don't think so.