Development Mode will not be supported in Firefox 27+

[Brian Slesinsky]

Mozilla has stopped exporting some C++ symbols that the Firefox plugin relies on [1]. Therefore it's not possible to support Development Mode in any new versions of Firefox starting with 27.

As a workaround, I am doing one last release to get the plugin working again with Firefox 24.2 (and hopefully newer point releases on the ESR track). If you wish to continue to use Development Mode on Firefox, you will need to download this version from Mozilla [2]. For more details see the issue tracker [3]. 

Long-term, the plan is to improve Super Dev Mode.

I apologize for the late notice; when I said at GWT.create that Firefox could stop working with any release, I didn't expect it to be the next one.

- Brian

[1] https://bugzilla.mozilla.org/show_bug.cgi?id=920731

[2] http://download.cdn.mozilla.net/pub/mozilla.org/firefox/releases/24.2.0esr/

[3] https://code.google.com/p/google-web-toolkit/issues/detail?id=8553

[Cristiano Costantini]

Hi Brian,

I wonder how does it works the development mode plugin?

Isn't it possible to replace it with something in pure javascript that is based on Web Sockets?

Yesterday I was making some test with this technology (see https://github.com/cristcost/gwt-websocket) and it it seems it has good support at least on latest Chrome, Firefox and IE (Safari don't works but I've not investigated deeply why). For the server side, I used the Jetty 7 WebSocket implementation.

I would enjoy to have a look a the code but GWT src is big, could you please tell where to look for if I would like to study the feasibility of this idea?

Debugging in Eclipse the Javascript code is one of the most important aspect of using GWT for me and I would be happy if it is possible to save it.

Cristiano

2014-02-04 Brian Slesinsky <skyb...@google.com>:

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

[Thomas Broyer]

On Tuesday, February 4, 2014 8:05:16 AM UTC+1, Cristiano wrote:

Hi Brian,

I wonder how does it works the development mode plugin?

Isn't it possible to replace it with something in pure javascript that is based on Web Sockets?

No, because we need blocking I/O, synchronous communication with the DevMode code server.

Leif Åstrand (from Vaadin) tried something using synchronous XMLHttpRequests, but even synchronous XMLHttpRequests are going to disappear.

The only solution would be to use the remote debugging protocols so you can really pause the execution in the browser while you do things in Java. I had started a proof of concept using the Flash Debugger to connect to an Adobe AIR runtime a while ago, could be used as a starting point if you want; but connecting a remote debugger (or using the debugger APIs from an extension) generally disables the browser's dev tools (at least it's the case in Chrome, don't know about Firefox).

https://code.google.com/p/gwt-in-the-air/source/browse/branches/oophm/oophm/src/net/ltgt/gwt/air/shell/

Debugging in Eclipse the Javascript code is one of the most important aspect of using GWT for me and I would be happy if it is possible to save it.

The idea going forward is to use SourceMaps and remote debugging from the IDE, leveraging the same IDE code (and effort!) as for other "compiled to JS" languages (CoffeeScript, etc. or even just JS with a minifier or js2js compiler)

[Cristiano Costantini]

No, because we need blocking I/O, synchronous communication with the DevMode code server.

mmm, good point...

can we just block with a while?

 

The only solution would be to use the remote debugging protocols so you can really pause the execution in the browser while you do things in Java. I had started a proof of concept using the Flash Debugger to connect to an Adobe AIR runtime a while ago, could be used as a starting point if you want; but connecting a remote debugger (or using the debugger APIs from an extension) generally disables the browser's dev tools (at least it's the case in Chrome, don't know about Firefox).

https://code.google.com/p/gwt-in-the-air/source/browse/branches/oophm/oophm/src/net/ltgt/gwt/air/shell/

I'll take a look.

Cristiano

 

[Thomas Broyer]

On Tuesday, February 4, 2014 10:38:34 AM UTC+1, Cristiano wrote:

No, because we need blocking I/O, synchronous communication with the DevMode code server.

mmm, good point...

can we just block with a while?

Because JS is single-threaded, you'll never know when to break out of the while.

[Cristiano Costantini]

webworkers?

2014-02-04 Thomas Broyer <t.br...@gmail.com>:

--

[Jens]

Anything people can look into to improve SDM performance? For example is it still worth it refactoring generators to be incremental generators or does the upcoming incremental compile of GWT does a better job at the end and it would be better to take a look at other things to improve SDM?

I think it would be great to have plan written down or at least very well organized issues in the bug tracker so that more people can work on improving SDM. With Firefox 27 not supporting DevMode and Chrome can break any time in the next months it may take too long for Brain alone to make SDM more useful.

-- J.

[Cristiano Costantini]

looking at the docs of webworkers and even them don't share any state, so it won't work it too...

Anyway it would be great to find a workaround that don't require either Flash or browser plugin or Java Applet...

2014-02-04 Cristiano Costantini <cristiano....@gmail.com>:

[Thomas Broyer]

On Tuesday, February 4, 2014 11:01:15 AM UTC+1, Cristiano wrote:

Anyway it would be great to find a workaround that don't require either Flash or browser plugin or Java Applet...

Flash or applets wouldn't work, because a) they're going asynchronous too (Flash at least) and b) they can't get access to the internal APIs we need in DevMode plugins to make them work (and that have just been removed in Firefox 27); basically knowing the lifecycle of JS objects so we can send a message to the DevMode code server to free the corresponding Java objects/references and reclaim memory (but there might be other things we need).

As I said, using the debugger APIs/protocols could work, except again for detecting JS objects "finalization" (maybe if one day we see WeakRef in JavaScript, but it's not there yet).

No, really, the way forward is better tooling for SuperDevMode to provide a similar experience to DevMode (i.e. never leave the IDE), and even allow setting breakpoints and do step-by-step within JSNI.

[Cristiano Costantini]

No, really, the way forward is better tooling for SuperDevMode to provide a similar experience to DevMode (i.e. never leave the IDE), and even allow setting breakpoints and do step-by-step within JSNI.

Oh if this is possible than I'm ok, I was thinking that with SuperDevMode I would had been obliged to debug and breakpointing on browser development tools.

Then I need to have a look at it. 

...and yes if that is possible I agree that it is the way forward.

[Ümit Seren]

Playing devil's advocate here: 

I code in IntelliJ but I must say that I really like the experience that the Chrome Developer Tools are providing. 

From pure debugging point of view (stepping through the code) I actually prefer the Dev Tools over the IDE because with the Dev Tools I can easily change CSS styles, modify the DOM and see the results directly in the browser. 

Furthermore Chrome Dev Tools has some really good performance and profiling tools built in. 

There are a couple of pain points of course and things I would like to see changed. 

- Bi-directional breakpoints:  Currently if I want to set a breakpoint I have to do it inside Chrome Deve Tools. It would be nice to be able to set the breakpoint in my IDE and then debug inside Chrome Dev Tools and vice versa. 

- Sometimes Dev Tools crash or freeze (if you debug a huge project) or try to display an array with many values. 

[Wayne Rasmuss]

I second the bi-directional breakpoints idea. That's the biggest pain point for me with SDM. It stinks to track down some code in your IDE then have to track it down again in your browser to set the break point. If I didn't have to do that, I wouldn't miss debugging in the IDE much.

[Kirill Prazdnikov]

Does the Chrome expose any kind of debugging interface so that any front-end IDE can use and visualize it ?

[Thomas Broyer]

On Thursday, February 6, 2014 10:03:35 AM UTC+1, Kirill Prazdnikov wrote:

Does the Chrome expose any kind of debugging interface so that any front-end IDE can use and visualize it ?

https://developers.google.com/chrome-developer-tools/docs/debugger-protocol 

[Ed]

Usage example of the chrome debugger (not as part of the Chrome browser): Wienre: http://people.apache.org/~pmuellr/weinre/docs/latest/

(A very nice tool btw for controlling your DOM on a mobile device)

[Thomas Broyer]

Remote debug works great too ;-)

[Ed Bras]

> Remote debug works great too ;-)

Yes, if you have a Mac ;)      (I assume you mean Safari remote debugging ? Else let me know, device independent (iphone, android))

[Thomas Broyer]

I don't have a Mac. Chrome remote debug works great cross platform (tested with Chrome for Android, on Linux and Windows; should work w/ Chrome for iOS AFAICT). Firefox for Android (and FirefoxOS) should too (though I haven't tested it)

[sabi...@hotmail.com]

well. no more gwt for me then, until mozilla gives google access again. downgrading the browser(either by using chrome or an earlier version of firefox) is not acceptable for me. but i can wait. got lots of non-google projects to work on.

[Aleksander Gralak]

That is pretty bad information for all GWT developers.
For now I can stick with FF 24.2, however in the future we need to develop on the most up to date browsers.

When do you estimate Super Dev Mode will be production ready? If it is more then 6 months then we should think of some workaround. Is is possible to do a custom build of FF with all necessery symbols exported? According to

[1] https://bugzilla.mozilla.org/show_bug.cgi?id=920731

they have switched it off. But if someone (sorry I am not C++ developer so I will not do it myself) can build GWT development version with those symbols. Then we would be able to do development for several more months on the latest browser and wait till Super Dev Mode if fully functional.

[Jeff Evans]

Can someone clarify what is meant by "fully functional" for Super dev mode?  In my view, debugging the client-side GWT code in the IDE debugger, alongside server-side Java code, is the "killer feature."  I can't believe anyone would ever consider in-browser Javascript debugging to be an acceptable replacement.  Or perhaps I'm missing something?

[Brian Slesinsky]

Super Dev Mode works and we have many teams that use it. The Chrome debugger is quite good and I recommend learning it well; anyone working on web apps will benefit from knowing this tool. For other browsers, adding a GWT.debugger() call to the Java code and recompiling is an easy way to stop in the right place. I discussed other workarounds in my GWT.create talk [1].

It's an unfortunate transition and this experience is not as smooth as it could be yet, but that's where we are.

- Brian

[1] https://docs.google.com/a/google.com/presentation/d/1DTWZ_06dQsTPhinIwzHSdoPMndRr92wpZoZWicK97YQ/edit?forcehl=1&hl=en#s

--
You received this message because you are subscribed to a topic in the Google Groups "Google Web Toolkit" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/google-web-toolkit/QSEjbhhHB4g/unsubscribe.
To unsubscribe from this group and all its topics, send an email to google-web-tool...@googlegroups.com.

[Jeff Evans]

On Wednesday, February 19, 2014 1:03:15 PM UTC-5, Brian Slesinsky wrote:

Super Dev Mode works and we have many teams that use it. The Chrome debugger is quite good and I recommend learning it well; anyone working on web apps will benefit from knowing this tool. For other browsers, adding a GWT.debugger() call to the Java code and recompiling is an easy way to stop in the right place. I discussed other workarounds in my GWT.create talk [1].

It's an unfortunate transition and this experience is not as smooth as it could be yet, but that's where we are.

- Brian

[1] https://docs.google.com/a/google.com/presentation/d/1DTWZ_06dQsTPhinIwzHSdoPMndRr92wpZoZWicK97YQ/edit?forcehl=1&hl=en#s

Thanks, this presentation looks useful.

 

[Ed Bras]

>  The Chrome debugger is quite good and I recommend learning it well;

It depends on your project. I been down this road, tried it several times with several projects (few months ago last one). 

Currently the Super Dev mode is "Hello World ready", but not "Enterprise ready"

With new projects, I like to start with Super dev mode, but when it becomes bigger... I am forced to jump back to FF/Chrome plugin usage.

Using it with bigger code base makes it slow and a code puzzle in chrome debug. 

For bigger projects, Chrome debugger should offer more IDE features that make debugging easy and friendly, just like we are used to using IDE tools like Eclipse.

Of course this will change, and I hope this will be soon..

[m...@touk.pl]

Couldn't agree more... debugging the client-side GWT code in the IDE debugger (Eclipse in my case) is base of my every day work :(

[Thomas Broyer]

On Thursday, February 20, 2014 9:49:42 AM UTC+1, m...@touk.pl wrote:

Couldn't agree more... debugging the client-side GWT code in the IDE debugger (Eclipse in my case) is base of my every day work :(

I'm sure the SDBG devs would love to hear your feedback ;-)

https://github.com/sdbg/sdbg

 

[m...@touk.pl]

On Thursday, February 20, 2014 11:57:30 AM UTC+1, Thomas Broyer wrote:

I'm sure the SDBG devs would love to hear your feedback ;-)

https://github.com/sdbg/sdbg

 

SDBG has a long way to come (it is still in proof of concept stage, there is no support for other browser then chrome), nether the less what else we can do but to help them.

[bruciadmin]

This is a pretty important change for me - looks like it's a downgrade to FF 26 a workaround is found. I had never heard of Super Dev mode but sounds like it's still got a fair way to go - and right now I need to focus on ROI for my work (retooling in the last 90% of a project is not an option with given deadlines).

[Benjamin Bitdiddle]

Would anyone like to follow up the last comment on the bugzilla thread, where a FF dev claims that:

Most C++ JSAPI usage in extensions can in fact be replaced by a combination of privileged script and the debugger APIs

I assume we wouldn't be seeing this thread if that was really true as you guys would have just updated the plugin.

[Brian Slesinsky]

I'm not sure there's much to discuss. Firefox 27 is already released, and we do want to move off of Dev Mode sooner or later for other reasons. I don't feel comfortable asking them to bring back an API that they never officially supported anyway and it seems unlikely that they'd agree. Running Firefox 24 seems like an acceptable workaround.

Regarding the Firefox-specific debugger API's, I'm not sure it's worth even figuring out if it's feasible or not since our plan is to move to Super Dev Mode. But if someone wants to take a look then go ahead.

- Brian

--

[joerg.h...@googlemail.com]

Hi there,

I can understand that it is a hard task to maintain the GWT and especially DevMode with its plugins.
However, the hole thing about GWT is that you can do pure Java and use the Java tooling.
Developers know how to work with Eclipse. And within the Eclipse debugger you can evaluate deeply into variables and objects, add conditional breakpoints, exception breakpoints, dynamically evaluate expressions, have step filters, drop to frame, etc., etc.
I am a power user and going to SDM with chrome debugger is simply no alternative and will IMHO never be.
With GWT 2.6.0 DevMode even stopped working due to Jetty problems so I can not even use it with older FF versions.
This is a real pain for me. I am wondering if I wasted the last years building on GWT all nights (https://github.com/m-m-m/mmm/tree/master/mmm-client/mmm-client-ui/mmm-client-ui-widget/mmm-client-ui-widget-impl-web-gwt). Then I could also assimilate with JS hell and go for AngularJS.
Sorry for being so negative but I am really frustrated. Thanks for all your support on GWT (2.6.0 brings J1.7 syntax support, etc. what is really cool) and your will to improve it in the future. Maybe you can change my mind one fine day and bring me back...

Regards
  Jörg

[Brian Slesinsky]

I'm not sure what the Jetty problems are but they should be fixed. Do we have a good bug report for them?

(In our setup we see stack traces but Jetty still runs.)

- Brian

--

[Ümit Seren]

The Chrome Dev Tools support actually most of  eclipse's debugger features like: 

  - Evaluating deeply into variables

  - Conditional breakpoints

  - Exception breakpoints (break on uncaught exception and any exception)

  - Dynamically evaluating expressions 

Missing features are AFAIK "Drop to frame" and "step filters". 

However an advantage of SDM is that you can visually evaluate and the DOM and also inspect javascript objects (both are not really possible in eclipse).

[Jens]

you can evaluate deeply into variables and objects,

You can do that in Chrome 

 

add conditional breakpoints,

You can do that in Chrome 

 

exception breakpoints,

You can do that in Chrome 

 

dynamically evaluate expressions,

You can do that in Chrome 

So the most important things are covered. Maybe you should just give it a serious try ?

-- J.

 

[Nagin Kothari]

I do not know what Jetty problem  Jörg  is talking about. I am using GWT 2.6 with FF 26 and I am able to use DevMode.

--

You received this message because you are subscribed to the Google Groups "Google Web Toolkit" group.
To unsubscribe from this group and stop receiving emails from it, send an email to google-web-tool...@googlegroups.com.

To post to this group, send email to google-we...@googlegroups.com.
Visit this group at http://groups.google.com/group/google-web-toolkit.
For more options, visit https://groups.google.com/groups/opt_out.

--
Nagin Kothari
Co-founder,
Zilicus Solutions
www.zilicus.com

[Thomas Broyer]

On Friday, February 28, 2014 1:59:24 AM UTC+1, Brian Slesinsky wrote:

I'm not sure what the Jetty problems are but they should be fixed. Do we have a good bug report for them?

There's a strange classloader issue: https://code.google.com/p/google-web-toolkit/issues/detail?id=8585

And a small regression on something we never really actually supported: https://code.google.com/p/google-web-toolkit/issues/detail?id=8526

…and now that we're using Jetty 8, people are sking for more ;-) https://code.google.com/p/google-web-toolkit/issues/detail?id=8472

[joerg.h...@googlemail.com]

Hi Jens,

> Maybe you should just give it a serious try ?

I already gave SDM several tries. However it never worked in my case at all. The problem is that I am not just doing a hello world with GWT but some rather complex UI framework with some special aspects. I hope that I do not appear just to be a ignorant jerk. Maybe SDM can convince me some day...
Hopefully someone can help me. I always get this:

workDir: C:\Users\hohwille\AppData\Local\Temp\gwt-codeserver-8835691028753667732.tmp
log4j:WARN No appenders could be found for logger (org.eclipse.jetty.util.log).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
binding: user.agent=safari
binding: compiler.useSourceMaps=true
binding: locale=en
Compiling module net.sf.mmm.app.Mmm
   Validating units:
      Ignored 17 units with compilation errors in first pass.
Compile with -strict or with -logLevel set to TRACE or DEBUG to see all errors.
   Finding entry point classes
      [ERROR] Unable to find type 'net.sf.mmm.app.client.Mmm'
         [ERROR] Hint: Check that the type name 'net.sf.mmm.app.client.Mmm' is really what you meant
         [ERROR] Hint: Check that your classpath includes all required source roots
[ERROR] Compiler returned false
com.google.gwt.core.ext.UnableToCompleteException: (see previous log entries)
    at com.google.gwt.dev.codeserver.Recompiler.compile(Recompiler.java:128)
    at com.google.gwt.dev.codeserver.ModuleState.<init>(ModuleState.java:58)
    at com.google.gwt.dev.codeserver.CodeServer.makeModules(CodeServer.java:120)
    at com.google.gwt.dev.codeserver.CodeServer.start(CodeServer.java:95)
    at com.google.gwt.dev.codeserver.CodeServer.main(CodeServer.java:71)
    at com.google.gwt.dev.codeserver.CodeServer.main(CodeServer.java:49)

This is all confusing:
> Unable to find type 'net.sf.mmm.app.client.Mmm'
That is actually my entry Point and it is available in the m2e project from that I run the SDM. Also didn't GWT say the following so it should have already found the type:
> Compiling module net.sf.mmm.app.Mmm
Also confusing:
> Compile with -strict or with -logLevel set to TRACE or DEBUG to see all errors.
IMHO there is no such option for com.google.gwt.dev.codeserver.CodeServer
> [ERROR] Hint: Check that your classpath includes all required source roots
I am using m2e in Eclipse and my codebase is VERY modular. Maybe that is the source of the problem.

Any help would be highly appreciated...
BTW: I found some workarounds for my Jetty problem and can at least run DevMode with FF 26 on 2.6.0 now.

Regards
  Jörg

[Thomas Broyer]

That's the module (gwt.xml), which references the entry point.

How are you launching SDM? Using M2E or just a “Java application” Eclipse launch configuration? How is it configured?

 

Also confusing:
> Compile with -strict or with -logLevel set to TRACE or DEBUG to see all errors.
IMHO there is no such option for com.google.gwt.dev.codeserver.CodeServer

That's right.

 

> [ERROR] Hint: Check that your classpath includes all required source roots
I am using m2e in Eclipse and my codebase is VERY modular. Maybe that is the source of the problem.

Maybe, maybe not. Hard to tell without knowing more about the way you launch SDM.

(also: maybe better to start a new thread, for others that could search the group archives in the future)

[Joseph Lust]

I'm surprised more folks are not excited to jump ship to SuperDevMode. 

I'd argue Eclipse DevMode is more pain than it's worth. Certainly, it is very cool to have your backend and frontend breakpoints set and hit on the same screen. Yet I've spent a lot of time trying to all of the Run Configurations setup properly. Have a multi-module project? Have an OSGi project? Trying to debug a remote server? Working with JSO's? It's a bit of trial and error and not always possible. Startup is slow. Recompile is even slower and it's a memory hog, crashing with OutOfMemory more than I'd like. Plus, you need a ring of chicken blood around your computer to ward of breakages with new browser upgrades.

Enter SDM. I open one console type mvn tomcat7:run-war. I open a second and run mvn gwt:run-codeserver. No need for configuration settings windows and embedded Jetty's. No need to even have an IDE at all! Personally I find simpler, imperative tooling much easier to use and troubleshoot. Add to this Chrome Dev Tools will be a full fledged IDE soon at the rate they're adding features and FF Dev Tools have also come a very long way since FireBug.

Finally, don't we want the GWT team to spend their time building new features rather than keeping old tooling alive in the ICU? I think GWT's hit an inflection point where dumping IE everything and DevMode would free up a lot of resources. Many projects never make such painful decisions and become dinosaurs for it. I hope GWT does not.

Sincerely,

Joseph

[Ed Bras]

> I'm surprised more folks are not excited to jump ship to SuperDevMode. 

I think because many dev peeps use GWT for enterprise projects.....(and they should of course)...

And for bigger projects, SDM is (still) hard to use (as explained in this post, and I "really" tried/used it several times).

Really hoping this will change soon...

[Thomas Broyer]

And as a corollary, Enterprise culture has a HUGE resistance to change. There are people out there still using GWT 2.4 (more than 2 years old already!) or even older versions. The problem is with these people and that culture; most of the time they chose GWT (and webapps) for bad reasons, and fall into the Enterprisey over engineering trap that makes GWT painful to use (bloated apps). They have to change, they have to update their tools and move forward, or quit doing Web dev.

[Ed Bras]

> They have to change, they have to update their tools and move forward, or quit doing Web dev.

Agree, that's why I spend a lot of grey hairs in using SDM, but it's simple not there yet saidly... Don't get me wrong, I wish it would as I certainly see the advantages.

I noticed that it's hard to understand these reasons by people that have their focus on "Hello world" app's or hardly touch enterprise alike GWT app's...

BTW: for none enterprise app's, I use others JS frameworks like JQuery.

GWT: heavier business logica (= call it Enterprise app's or some other beautiful trendy name), share with backend...

Just my 50 cents to have a good understanding what we talk about..

[Thomas Broyer]

On Wednesday, March 5, 2014 9:30:54 AM UTC+1, Ed wrote:

> They have to change, they have to update their tools and move forward, or quit doing Web dev.

Agree, that's why I spend a lot of grey hairs in using SDM, but it's simple not there yet saidly... Don't get me wrong, I wish it would as I certainly see the advantages.

And don't get me wrong: I'm not saying SDM is either perfect nor 100% usable yet. I was just reacting to the fact people complain that DevMode won't be maintained anymore as they don't *want* to move to SDM (which is entirely different from your “I tried, it didn't work” situation).

We're currently in a transition period where DevMode is already half-dead and SDM isn't 100% usable yet. Hopefully SDM should be much better by the next release, with incremental compilation (that'll have an impact on your code to really take advantage of it).

[James Wendel]

My company got screwed by using GXT2 with gxt-uibinder library that broke with GWT 2.5 due to compiler changes. We've been stuck on GWT 2.4 for that reason as we had 100+ .ui.xml files to convert to pure java. We finally did the work, but it was definitely a painful lesson.

[Thomas Broyer]

On Friday, March 28, 2014 3:58:00 AM UTC+1, James Wendel wrote:

My company got screwed by using GXT2 with gxt-uibinder library that broke with GWT 2.5 due to compiler changes. We've been stuck on GWT 2.4 for that reason as we had 100+ .ui.xml files to convert to pure java. We finally did the work, but it was definitely a painful lesson.

I hope the lesson is to avoid relying too much on hacks (particularly when coming from a third party).

(been there, done that)

[Ed Bras]

Can't agree more. Same experience, even contributed to mygwt (previous name of GXT)... 

The nice thing about GWT: making easy/fast small lib's, is also a risk; not being maintained..

[dhoffer]

Could you elaborate on how you have your POM setup?  I'm trying to make the switch to SDM but I get errors running run-codeserver.  Your setup seems ideal I'd like to know how you have both of those things configured.  Not sure it matters but I use IntelliJ instead of Eclipse...DM worked great.

-Dave

[Juan Pablo Gardella]

Hello James, 

after replace ui.xml by pure javadoes the application compile faster? I thought ui.xml views increment a lot the compiler time.

Juan

2014-03-27 23:58 GMT-03:00 James Wendel <jmwe...@gmail.com>:

My company got screwed by using GXT2 with gxt-uibinder library that broke with GWT 2.5 due to compiler changes. We've been stuck on GWT 2.4 for that reason as we had 100+ .ui.xml files to convert to pure java. We finally did the work, but it was definitely a painful lesson.

--

You received this message because you are subscribed to the Google Groups "Google Web Toolkit" group.

To unsubscribe from this group and stop receiving emails from it, send an email to google-web-tool...@googlegroups.com.

To post to this group, send email to google-we...@googlegroups.com.
Visit this group at http://groups.google.com/group/google-web-toolkit.

For more options, visit https://groups.google.com/d/optout.

[Jérôme Beau]

Hi Thomas,

I just realized that lack of Firefox 27+ support for dev mode recently (tried it because Chrome's plugin crashed too often) and really think this is a shoot in the foot for GWT : even if you don't control Mozilla choices of course, forcing to move to a non-mature SDM is very risky for GWT itself.

By non-mature, I mean a SDM that lacks features DM had, such as Java-level inspection (inspecting Java values of Java variables). I am amazed that nobody complains about this loss. Even if you achieve proper support for debugging in SDM from the IDE, will it allow such Java-level inspection ? I doubt it, you'll only allow JS-level inpections, while allowing Java-level stepping, which does not fit the GWT promise of keeping at the Java level. This is the reason why most of GWT developpers use it.

[Aleksander Gralak]

Do not agree. A lot of people complain about it. 

--

You received this message because you are subscribed to a topic in the Google Groups "Google Web Toolkit" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/google-web-toolkit/QSEjbhhHB4g/unsubscribe.
To unsubscribe from this group and all its topics, send an email to google-web-tool...@googlegroups.com.
To post to this group, send email to google-we...@googlegroups.com.
Visit this group at http://groups.google.com/group/google-web-toolkit.

For more options, visit https://groups.google.com/d/optout.

[Jens]

I just realized that lack of Firefox 27+ support for dev mode recently (tried it because Chrome's plugin crashed too often) and really think this is a shoot in the foot for GWT : even if you don't control Mozilla choices of course, forcing to move to a non-mature SDM is very risky for GWT itself.

But there is no other viable solution and the transition was actually planed more smoothly. I can understand that many people can not use SDM just because the SDM compilation is too slow for their project. But I don't understand people saying that debugging with SDM is a pain. Yeah for a Java developer it is strange to leave the IDE but honestly for every day debugging browsers provide everything you need. There may be some hiccups here and there but overall it is useable and it is not at all comparable to the situation around the time GWT was invented. Back in these days "use your Java debugging tools" was a very strong argument but today browsers have catch up and will continue to catch up. If GWT will provide debugging in IDEs with SDM then it is only for convenience. 

You must become a web developer even if choosing GWT and you should understand the browser platform sooner or later just like you need to understand Swing when doing Java Desktop apps.

I think the most risky thing of GWT proper was to ignore mobile too long and now it has to catch up quickly. With this in mind, SDM is actually a huge plus for GWT because it enables you to build/debug mobile apps more easily. With DevMode only, developing mobile apps is painful.

-- J.

[David]

For me it will depend how well SDM works with IE because that is the main browser that I need to support. Not all GWT applications are put on the internet and in an enterprise environment (more specifically banking) IE is still king. It will already be a big battle to get them to move to IE9 or preferably IE10 or newer.

 

I could use FireFox/Chrome in dev (and I do actually) but I need to often debug in IE because of issues that only happen there and with SDM that can be painful.

 

--

You received this message because you are subscribed to the Google Groups "Google Web Toolkit" group.

To unsubscribe from this group and stop receiving emails from it, send an email to google-web-tool...@googlegroups.com.

To post to this group, send email to google-we...@googlegroups.com.
Visit this group at http://groups.google.com/group/google-web-toolkit.

For more options, visit https://groups.google.com/d/optout.

[Thomas Broyer]

On Wednesday, April 2, 2014 3:05:22 PM UTC+2, stuckagain wrote:

For me it will depend how well SDM works with IE because that is the main browser that I need to support. Not all GWT applications are put on the internet and in an enterprise environment (more specifically banking) IE is still king. It will already be a big battle to get them to move to IE9 or preferably IE10 or newer.

 

I could use FireFox/Chrome in dev (and I do actually) but I need to often debug in IE because of issues that only happen there and with SDM that can be painful.

AFAICT, for the time being, and for the coming year(s?), DevMode will still be supported in IE. Specifically because IE Developer Tools aren't really developers' friends and don't support Source Maps.

[Jérôme Beau]

Hi Jens,

Just for the record : do you agree that using SDM you cannot inspect Java values of Java variables in your browser? I agree about the mobile dev, about knowing the underlying web platform, about everything but... any debugging session, Java or JS, have to be consistent : if I debug JS, I expect to have JS inspections ; if I debug Java (even in the browser through sourcemaps), I expect to see Java values and Java symbols, and I expect that my conditional breakpoints occur on Java expressions, not JS expressions. That's it. Otherwise I would have used a JS framework.

Is there a tiny possibility that GWT can provide this in some future? 

[Ümit Seren]

What exactly do you mean with "I cannot inspect Java values of Java variables" with SDM ? 

Can you provide an example where you can't inspect a Java value with Chrome Dev Tools ? 

I think Dev Mode will never come back. SDM is here to stay and despite there is a lot to be desired, with time development experience will be much better than with normal Dev Mode. 

The Chrome team is putting huge amounts of work into improving Chrome Dev Tools. 
The profiling features are crucial if you want to create performant web apps and I prefer to do all task (profiling, fiddling with DOM/CSS and debugging) right in the Chrome Dev Tools rather than switching between Chrome Dev Tools and my IDE. 

For those who really need the features of their IDE there are some efforts to bring sourcemap debugging to eclipse (AFAIK IntelliJ has already support for it built in)

The biggest issue with SDM are currently compile times but that's going to improve with the incremental compiler in GWT 2.7. 

--
You received this message because you are subscribed to a topic in the Google Groups "Google Web Toolkit" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/google-web-toolkit/QSEjbhhHB4g/unsubscribe.
To unsubscribe from this group and all its topics, send an email to google-web-tool...@googlegroups.com.
To post to this group, send email to google-we...@googlegroups.com.
Visit this group at http://groups.google.com/group/google-web-toolkit.

For more options, visit https://groups.google.com/d/optout.

[Vassilis Virvilis]

A lot of negative feedback (maybe ) has been going for SDM. It seems a little harsh to my eyes so here is my positive 2 cents.

We are using SDM for a new project which started from zero lines but grows up pretty fast. We are importing older (even non GWT) modules and 3rd party projects with a fast pace. So far we are at 15-20kloc (sloccount) and the SDM compilation doesn't really slows us down. Of course we do tricks with remote filesystems and ssh-tunels to run the compiler in faster machines than our older developer machines. But the fact that we able to pull such tricks is evident to me that the technology is sound and simple enough for me to understand it. I have to admit that the DM with the plugin business I never understand it enough so I could explain it to my co developers. The SDM is pretty straight forward.

Of course I wouldn't say no to improvements in compile time (currently 8sec for me - but may vary up to 30sec) in my i5 with 8G machine.

On another note I have to say that SDM triggered some old memories of mine. The way the debug happens in the browser reminded me my first days in computing with x86 debuggers where we were trying to match the compiler output (assembly) to the higher level C input (yes I know - source maps). I am not really using the debugger in my every day life to watch variable values so this feature was not a big enough loss for (and can be emulated by looking at the assembly ^H^H javascript variables).

However what I find indispensable is the browser's debug tools. Why css is not applied? It is overrided? Who override it? Why width: 100% means 83px? Where are my other 2 pixels? Where is the padding? What the padding is doing here?

And of course flow related questions like: Exception? From where? From here? I thought it was an event listener? Aah the mouse events are also triggering the event listener. What do you know...

And for this the browser's debugging tools (chrome and (not or) firefox) are good enough ^H^H best admittedly with some brain assisted mapping.

So far SDM represents a win for me

   Vassilis Virvilis

--

You received this message because you are subscribed to the Google Groups "Google Web Toolkit" group.

To unsubscribe from this group and stop receiving emails from it, send an email to google-web-tool...@googlegroups.com.

To post to this group, send email to google-we...@googlegroups.com.
Visit this group at http://groups.google.com/group/google-web-toolkit.
For more options, visit https://groups.google.com/d/optout.

--

Vassilis Virvilis

[Jens]

Am Mittwoch, 2. April 2014 15:57:55 UTC+2 schrieb Jérôme Beau:

Hi Jens,

Just for the record : do you agree that using SDM you cannot inspect Java values of Java variables in your browser?

Yes thats true. The only Java code you see in the browser is the Java source file provided via source maps. Everything else is JS based because you are debugging JS and not Java.

 

if I debug JS, I expect to have JS inspections ;

Thats what you do with SDM debugging. The only difference is that the browser helps you to figure out which line of code in your source language (in this case Java) maps to that specific piece of JS you are currently debugging. 

SourceMaps is not about making the browser understand Java code. You should not expect the browser to understand something like "e.getMessage().equals(MyErrorsEnum.CONSTANT)" in a conditional break point. The browser simply does not know how to execute that string.

 

if I debug Java (even in the browser through sourcemaps), I expect to see Java values and Java symbols, and I expect that my conditional breakpoints occur on Java expressions, not JS expressions.

Thats what you do with classic DevMode + browser plugin. In this situation you never really leave the JVM which could also mean that you never really spot an issue in your code because it might only occur in pure JS after the app is compiled. That already happened to me: Clients report errors but in DevMode you can not reproduce them just because you are using DevMode.

Is there a tiny possibility that GWT can provide this in some future? 

I think there is some work going on for IntelliJ and Eclipse to use the browser remote debug connection to get JS from the browser and then use source maps inside your IDE. And maybe, just because this now happens inside an IDE, that IDE is then able to do some more work to provide you a more Java'ish feeling while debugging.

For example take a look at: https://github.com/sdbg/sdbg as a proof of concept in Eclipse.

-- J.

[Jérôme Beau]

Hi Ümit,

By "I cannot inspect Java values of Java variables" I mean that the source-mapping of the Chrome Dev Tools (which are good for JS) :

- shows me stuff I'm not interested into (most of the time) : "this" is "Window[0]", DOM, JS or internal GWT-generated functions or properties appear, such as "$H", "___clazz$", "getClass$", "hasCode$", "toString" & "toString$", "attached", "eventsToSink", "proto", etc.

- renames stuff I'm interested into : "MyClass" becomes "MyClass 0" "1", etc. "this" becomes "this$static"

- doesn't allow me to skip only in my code by defaut, that is,  automatically skip "internal", gwt-generated code while stepping

- doesn't allow me to use Java-expressions in breakpoints nor evaluations : have to use JS string.length, not String.length() for instance, etc.

You know, this just like when you debug plain Java code. Most of the time, you are not interested in debugging JDK sources. This may be interesting for understanding things and optimization (if you forget that's only draft JS code that will _not_ be the final code), but this is disabled by default. One might also consider than inspecting bytecode is good for understanding and optimization, but that's not reasonnable. 

[Brian Slesinsky]

It's true these are disadvantages.  There are some compensating advantages that people are pointing out: the code executes faster, it works with remote websites where latency is higher, it works with mobile phones, and so on. But there's no question that losing DevMode (other than IE and Firefox 24) is a loss.

Our short-term plan is to speed up compiles and generate JavaScript that looks more like Java for Super Dev Mode and draftCompile. But it it will still be JavaScript, and we will have to adjust. Longer-term, it may be possible to create a variable inspector that shows Java objects instead of JavaScript objects, but that isn't even prototyped yet.

[Slava Pankov]

DevMode is working just fine in Firefox 26 (not 24). And probably will work till Firefox ESR becomes 27 (it's only 24.4 now). So there is a time frame for normally working DevMode at least till the end of 2014. I hope SDM will be much better then.
What I'm concerned about that GWT team don't broke DevMode in 2.7 and 3.0 releases. Also it would be really nice to ask Mozilla team return back needed functionality for DevMode (but allow/enable it only if you run Firefox with specific command line parameters). I think it's completely possible to talk to them and explain the situation, nobody benefits from the situation, when GWT developers are refusing/disabling Firefox updates after 26 version.

[Jérôme Beau]

Thank you Brian. I can understand that, as well as I acknowledge the "compensating" benefits (which is not an appropriate term to me, as an extra arm doesn't really compensate loosing a leg). 

Hope for GWT that the long term will not be so long, before the the benefits of "I don't have to learn another language" disappear. 

[Thomas Broyer]

FYI, I've just been told that the new IE11 supports sourcemaps (http://blog.oio.de/2014/04/04/internet-explorer-11-source-map-based-debugging/)

[Ivan Markov]

Regarding sourcemap support for fields/variable names deobfuscation:

1- I found some thoughts on "SourceMap.next" here: http://fitzgeraldnick.com/weblog/55/ . 

It goes as far as suggesting how conditional breakpoints and eval() expressed in the source language can work for sourcemap-based debuggers. (If I understand it correctly, it shifts the responsibility for implementing these to the transpiler. The debugger will "just" call a javascript function defined in the sourcemap).

2- Some thoughts how we may address the problem in SDBG (the sourcemap JS debugger for Eclipse): https://github.com/sdbg/sdbg/issues/6

To unsubscribe from this group and all its topics, send an email to google-web-toolkit+unsub...@googlegroups.com.

[Chak Lai]

 

The stack-trace in Super Dev Mode is the only major issue that I have. It would be nice if the UncaughtException in SDM can tell me which line in java source is causing the problem, instead of giving me those JavaScript stack-trace messages... 

So far I like SDM. My current project is running a lot faster in SDM compare to Development Mode plugin.

[Brian Slesinsky]

If you are debugging interactively, using "pause on uncaught exceptions" can help. Then you can look at the stack frames in the debugger.

Another workaround is to log stack traces to the server and use StackTraceDeobfuscator. This will also help you in production:

http://www.gwtproject.org/javadoc/latest/com/google/gwt/core/server/StackTraceDeobfuscator.html

I don't think we can easily deobfuscate stack traces in the GWT application itself, because it requires the sourcemap which is normally only loaded by the debugger. It would be possible with a round trip to the Super Dev Mode code server, but this would be an asynchronous call so the API would be awkward.

On Wed, Apr 9, 2014 at 2:03 PM, Chak Lai <chakl...@gmail.com> wrote:

 

The stack-trace in Super Dev Mode is the only major issue that I have. It would be nice if the UncaughtException in SDM can tell me which line in java source is causing the problem, instead of giving me those JavaScript stack-trace messages... 

So far I like SDM. My current project is running a lot faster in SDM compare to Development Mode plugin.

--

You received this message because you are subscribed to a topic in the Google Groups "Google Web Toolkit" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/google-web-toolkit/QSEjbhhHB4g/unsubscribe.

To unsubscribe from this group and all its topics, send an email to google-web-tool...@googlegroups.com.

[Ivan Markov]

The StackTraceDeobfuscator does not play very well with the Super Dev Mode code server though.

Reason: StackTraceDeobfuscator needs to have access to the "AABBCD...HF.symbolMap" files generated during the last SDM compilation. However this directory is a moving target in the SDM code server because each compilation done by the SDM code server creates a *brand new* directory containing all the artefacts generated by this compilation (JS files, source maps, symbol maps). I.e.:

- Initially, the symbol maps can be found here: <code-server-work-dir>/<module-name>/compile1/war/WEB-INF/deploy/<short-module-name>/SymbolMaps

- After the second compilation, they are here: <code-server-work-dir>/<module-name>/compile2/war/WEB-INF/deploy/<short-module-name>/SymbolMaps
- and so on

For the JS files (and GWTRPC files) the above scheme is not a problem, as the code server's own HTTP service serves all artefacts generated by the latest compilation at this fixed URL: http://localhost:<sdm-port>/<short-module-name>

... except for the source map and the symbol map

Now, the latest source map is also served by the code server, using another magic URL (which I don't recall at the moment).

But no such luck for the symbol map...

Brian: how hard would it be to alter the code server to serve the symbol map as well, at some special URL?

10 април 2014, четвъртък, 00:16:43 UTC+3, Brian Slesinsky написа:

If you are debugging interactively, using "pause on uncaught exceptions" can help. Then you can look at the stack frames in the debugger.

Another workaround is to log stack traces to the server and use StackTraceDeobfuscator. This will also help you in production:

http://www.gwtproject.org/javadoc/latest/com/google/gwt/core/server/StackTraceDeobfuscator.html

I don't think we can easily deobfuscate stack traces in the GWT application itself, because it requires the sourcemap which is normally only loaded by the debugger. It would be possible with a round trip to the Super Dev Mode code server, but this would be an asynchronous call so the API would be awkward.

On Wed, Apr 9, 2014 at 2:03 PM, Chak Lai <chakl...@gmail.com> wrote:

 

The stack-trace in Super Dev Mode is the only major issue that I have. It would be nice if the UncaughtException in SDM can tell me which line in java source is causing the problem, instead of giving me those JavaScript stack-trace messages... 

So far I like SDM. My current project is running a lot faster in SDM compare to Development Mode plugin.

--
You received this message because you are subscribed to a topic in the Google Groups "Google Web Toolkit" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/google-web-toolkit/QSEjbhhHB4g/unsubscribe.

To unsubscribe from this group and all its topics, send an email to google-web-toolkit+unsub...@googlegroups.com.

[Brian Slesinsky]

Ivan, there is an existing bug that's related so I will reply there:

https://code.google.com/p/google-web-toolkit/issues/detail?id=7693

To unsubscribe from this group and all its topics, send an email to google-web-tool...@googlegroups.com.

[Thomas Broyer]

IIUC, Chrome will kill DevMode in 35 (current in beta, will reach the stable channel in May): http://blog.chromium.org/2014/04/chrome-35-beta-more-developer-control.html

On Tuesday, February 4, 2014 1:01:41 AM UTC+1, Brian Slesinsky wrote:

Mozilla has stopped exporting some C++ symbols that the Firefox plugin relies on [1]. Therefore it's not possible to support Development Mode in any new versions of Firefox starting with 27.

As a workaround, I am doing one last release to get the plugin working again with Firefox 24.2 (and hopefully newer point releases on the ESR track). If you wish to continue to use Development Mode on Firefox, you will need to download this version from Mozilla [2]. For more details see the issue tracker [3]. 

Long-term, the plan is to improve Super Dev Mode.

I apologize for the late notice; when I said at GWT.create that Firefox could stop working with any release, I didn't expect it to be the next one.

- Brian

[1] https://bugzilla.mozilla.org/show_bug.cgi?id=920731

[2] http://download.cdn.mozilla.net/pub/mozilla.org/firefox/releases/24.2.0esr/

[3] https://code.google.com/p/google-web-toolkit/issues/detail?id=8553

[Mario Jauvin]

People, this has been going on since beginning of February with no action on the part of Mozilla.  I have create a new mozilla bug https://bugzilla.mozilla.org/show_bug.cgi?id=996947 which is about the fact that GWT developper does not work in Firefox any longer.  I have proposed a workaround solution that I think is reasonable for Mozilla and the GWT developper community.  The only way we will get some traction on this is if every developper interested in having GWT developper working on Firefox (and I would think there are probably several hundreds if not thousands) should then create a bugzilla Mozilla account and vote on this bug (please remember to click change my vote to record your vote).  You can also add yourself on the CC list to get updated.  I am sure that if Mozilla gets a few hundred votes they will come up with something to get GWT developper plugin working again on Firefox.  Please forward this text to all the people who you think will be interested in voting.  Lets get the word out it can have a exponential effect.

[1] https://bugzilla.mozilla.org/show_bug.cgi?id=996947

[Brian Slesinsky]

For the direction of an open source project, people who volunteer to do actual coding are more important than marketing efforts by people who only want to be users. The intersection of GWT developers and Firefox browser developers seems to be the empty set, so we have very limited influence.

This is a challenging time and migration can be painful, but this decision fundamentally isn't up to us. We need to move forward. I think a more promising direction for people who want to improve GWT on Firefox would be to investigate problems with the Firefox debugger and contribute patches that make it practical to use.

- Brian

On Wed, Apr 16, 2014 at 6:10 PM, Mario Jauvin <mar...@gmail.com> wrote:

People, this has been going on since beginning of February with no action on the part of Mozilla.  I have create a new mozilla bug https://bugzilla.mozilla.org/show_bug.cgi?id=996947 which is about the fact that GWT developper does not work in Firefox any longer.  I have proposed a workaround solution that I think is reasonable for Mozilla and the GWT developper community.  The only way we will get some traction on this is if every developper interested in having GWT developper working on Firefox (and I would think there are probably several hundreds if not thousands) should then create a bugzilla Mozilla account and vote on this bug (please remember to click change my vote to record your vote).  You can also add yourself on the CC list to get updated.  I am sure that if Mozilla gets a few hundred votes they will come up with something to get GWT developper plugin working again on Firefox.  Please forward this text to all the people who you think will be interested in voting.  Lets get the word out it can have a exponential effect.

[1] https://bugzilla.mozilla.org/show_bug.cgi?id=996947

--

[Emiliano André]

Hello,
I created this guide (http://openbpm.wordpress.com/2014/05/31/getting-gwt-plugin-to-work-on-firefox-on-ubuntu-14-04/) to get multiple versions of firefox running locally in order to be able to have an older version with GWT working while still use the latest firefox version for everything else. And added the link to the bug hopefully it will help to get some traction in it.
Thanks!

- Brian

To unsubscribe from this group and all its topics, send an email to google-web-toolkit+unsub...@googlegroups.com.

[Alex Epshteyn]

As of now, quite sadly, the GWT plugin is no longer supported in the latest of versions of Firefox nor Chrome (starting with 35). I've been using GWT since 2006, and I think it's a sad state of affairs that after so much work went into GWT's OOPHM (a.k.a "Development Mode"), we're back to Internet Explorer being the only browser that can be used for GWT debugging on Windows.  I think that SuperDevMode goes against the original "do everything from your IDE" spirit of GWT, but I digress...

The main reason I'm posting this is to describe my workaround to save some time for anyone who still wants to use dev mode under Chrome and Firefox (which I'm guessing is the majority of the people here):

The hack I came up with (for Windows) was to install "portable" versions of Chromium and Firefox.

Portable Firefox 24: http://portableapps.com/apps/internet/firefox-portable-esr

Portable Chromium 35: http://crportable.sourceforge.net/

Then you need to manually install the GWT plugin into Chromium, since it's now disabled on the Chrome Web Store:

1. download the file GWT-Developer-Plugin_v1.0.11357.crx from http://chrome-extension-downloader.com/ (entering ID number jpjpnpmbddbjkfaccnmhnkdgjideieim into the search field)

2. drag and drop the downloaded file into the chrome://extensions/ tab to install the plugin

The good thing about this Chromium build is that it seems to be immune from Google's auto-updater, but for a limited time, you can also still get Google Chrome 35 Portable at http://portableapps.com/apps/internet/google_chrome_portable, and follow the same procedure for manually installing the GWT plugin.

I'm hoping that this hack will allow many of us to keep using the old dev mode for a long time to come, and I'm also hoping that the GWT project members will not abandon dev mode support.  

Question for GWT project members: I understand that both FF and Chrome are getting rid of the NSAPI, which enabled the GWT plugin.  Are there really no other ways to keep supporting dev mode on the latest versions of those browsers?  Has anyone looked into "Native Client" (https://developer.chrome.com/native-client)?

Best,

Alex

[Slava Pankov]

Also on Windows it's still possible to use Chrome 36 with devmode. Download Dart (I'm using 1.5.3 distribution), and use Chromium from there (it's portable, just copy it to any folder). Also you need GWT-Developer-Plugin_v1.0.11357.crx of course, see previous post.

[m...@touk.pl]

Lost of Development Mode is kind of "tombstone" for GWT projects in my company :( Most of Java oriented developers switched to JS frameworks as they lost their "one common language environment" argument. JS oriented developers, well they were always in opposition to "slow and clumsy" java frameworks. I personally stick with GWT in my private projects (especially with Java 8 support on the horizon) but as advocate of Occam's razor principle I will stick to Development Mode as long as possible (still using FF 24 :) ). Writing, testing and debugging in one language (and IDE) was a reason I choose GWT long time ago. Luckily there are few other reasons to use GWT, and Super Dev mode should improve with time.

Still there is one question that do not let me sleep peacefully. With old good Dev Mode I could easily trak fragments of java code that didn't work properly on GIVEN browser (was it IE, Chrome or FF). With SDM I'm bind to Chrome at least if I want to use source maps ?

[Jens]

With SDM I'm bind to Chrome at least if I want to use source maps ?

Firefox and IE 11 both support source maps as well. Opera should also support it as it is now based on Chrome. In case source maps is not supported you still see nearly unoptimized JavaScript that looks very similar to your Java code. If you are not totally blocking JavaScript in your mind then you should be able to debug the JavaScript produced by SDM as well and transfer the result to your Java code ;-)

-- J.

[Leejjon]

There's a developer version of Firefox coming out:
https://blog.mozilla.org/blog/2014/11/03/the-first-browser-dedicated-to-developers-is-coming/

Maybe we can ask Mozilla to export the C++ symbols in this developer version, so the GWT dev plugin can work on this developer version of Firefox.

Op dinsdag 4 februari 2014 01:01:41 UTC+1 schreef Brian Slesinsky:

[m...@touk.pl]

Certainly worth to try.

[David Hoffer]

IMO, the loss of DevMode is a huge problem for GWT, I understand SuperDevMode is its replacement but unfortunately that is no where near a true replacement at least not yet.  

It's a bit hard to explain unless you have used both approaches on a large project but the best way I can think of to explain it is that in SuperDevMode you see an 'opaque' version of your source in the browser.  So yes you can 'see' your Java source in the browser and you can debug it...but that's about it.  E.g. you get to have an image or a copy of your source in the browser.  However that's all you get in SuperDevMode what you don't get is the ability to find and edit your source code.  I have an app with hundreds of classes in the client side, there are no tools like my IDE has for finding the code i want to jump to so I can inspect, set break points, edit code, etc. 

So with SuperDevMode everything has to be done twice, you can debug in the browser (but navigating the code is very painful) but then when you need to make changes you need to re-navigate the code over in the IDE, edit the code, and re-deploy.  So in effect the code in the browser is an image of the real code...you can't do anything with it really.  

I find SuperDevMode to be incredibly inefficient in developing GWT applications, especially large ones where the strength of GWT is evident.  SuperDevMode might be fine for later stages of development, e.g. testing stages where you don't need to make large code changes but rather just need to fine tune what GWT generated but it's inadequate for development stages. Personally I'm keeping an an old version of Firefox so that I can continue to use DevMode.

Please let me know if I'm missing something here or are other approaches.

-Dave 

--
You received this message because you are subscribed to a topic in the Google Groups "Google Web Toolkit" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/google-web-toolkit/QSEjbhhHB4g/unsubscribe.

To unsubscribe from this group and all its topics, send an email to google-web-tool...@googlegroups.com.

[Timothy Michael Spear]

David,

The problem is a fundamental disconnect in approach. In using Places, and the MVP model, your application is supposed to be a series of much smaller applications with minimal navigation required to re-enter a specific point. 

I have very mixed perceptions on this multi-entry point development.

Tim

You received this message because you are subscribed to the Google Groups "Google Web Toolkit" group.

To unsubscribe from this group and stop receiving emails from it, send an email to google-web-tool...@googlegroups.com.

[David Hoffer]

I definitely use a MVP/C model but not Places.  I don't think I should be tided to one and only one MVP approach.  However even if I did it's not clear how that would help the fact that the browser has a 'copy' or 'image' of the real thing...at the end of the day I need my IDE to make changes.

-Dave

[Jens]

I definitely use a MVP/C model but not Places.  I don't think I should be tided to one and only one MVP approach.

Places are just for navigation. They have nothing to do with MVP. You can use them without GWTs Activity class.

 

  However even if I did it's not clear how that would help the fact that the browser has a 'copy' or 'image' of the real thing...at the end of the day I need my IDE to make changes.

Yeah it is a bit counter intuitive if you see your Java code in the browser and want to debug it. The best thing you can do is to place breakpoints and then step through the code. Navigating the code with something like ctrl + click as in Java IDEs is not possible with source maps (although you can search, open file, goto line using shortcuts). Also conditional break points obviously need to use JavaScript expressions. At the end you are debugging JavaScript that only got visually transformed into your original Java code to please your eyes.

As an alternative you could try the following in Chrome:

- use the SDM parameter -XmethodNameDisplayMode with your desired setting

- Disable source maps in Chrome Dev Tools.

Now you are dealing with the raw JavaScript (which already looks pretty similar to your Java code) but when hitting a breakpoint Chrome will display your Java class/method name for each stack element. So you kind of see a Java stack trace in Chrome but when clicking on it you see the raw JS code. The added benefit of using raw JS is that while a break point is active you can now hover JS code and Chrome will give you additional information about the code as well as a link to jump to the definition. And with the Java like stack trace it is easier to spot the code path in your IDE. Might be an interesting compromise.

Other than that there is the experimental Eclipse plugin named SDBG so you can use your IDE for debugging (but you are still debugging JS!). IntelliJ can do the same out of the box.

-- J.

[David Hoffer]

I like where you might be going with your last paragraph (the IntelliJ part)..."Other than that there is the experimental Eclipse plugin named SDBG so you can use your IDE for debugging (but you are still debugging JS!). IntelliJ can do the same out of the box."

Are you saying that IntelliJ can somehow use SDM and still be debugging in IntelliJ?  If so I'd like to know more about this.  I was thinking that for SDM to be acceptable...somehow it has to get back to the IDE so I can debug, navigate & edit in one tool.  If this is possible then SDM starts to look better.

--

[Paul Robinson]

If you're using eclipse and chrome, then sdbg is good. It's not perfect, but it is *much* better than browsing Java source and setting break points in the browser.

Paul

You received this message because you are subscribed to the Google Groups "Google Web Toolkit" group.

To unsubscribe from this group and stop receiving emails from it, send an email to google-web-tool...@googlegroups.com.

[David Hoffer]

I'm using IntelliJ...I'd like to hear if/how IntelliJ can do this too.

-Dave

[Jens]

I'm using IntelliJ...I'd like to hear if/how IntelliJ can do this too.

https://docs.google.com/document/d/1Sf9lahq0jr0AsxR74ZE-Lntf0y5ZNk0104mhD8ozEuM/edit 

Also see the linked issue in the doc.

-- J.

[Jens]

I'm using IntelliJ...I'd like to hear if/how IntelliJ can do this too.

With the released IntelliJ 14 things are a bit easier.

- Create a new GWT run configuration and select "User Super Dev Mode" and at the bottom "with JavaScript debugger". 

- IntelliJ will automatically generate a JavaScript debugger run configuration. Open that run configuration and you should see your GWT project directory tree. In that tree navigate to your source folder (src or src/main/java) and double click on the "Remote URL" column next to it. The remote URL is where IntelliJ will download source map files from so you should paste in something like http://127.0.0.1:9876/sourcemaps/<module-name>.

Now launch the GWT SDM run configuration which should also automatically launch the JavaScript Debug configuration. Chrome should now tell you that IntelliJ is debugging your site (you may need to install the LiveEdit Chrome extension) and you should be able to set break points in your Java code and step through the code from within IntelliJ.

Sometimes when you hit a break point the source map file isn't ready yet in IntelliJ (seems like a timing problem) and you see the pure JavaScript. But once you do the first "step over" IntelliJ should switch to the Java source by using source map information. Overall it works pretty well.

But keep in mind that fields and expressions in conditional break points are still all JavaScript. You are not debugging Java!

-- J.

[David Hoffer]

That is really good news.  I haven't tried this yet (need to upgrade IDEA to 14) but it sounds like one gets most/all the benefits of DevMode development/debugging yet it's really using SDM.  Very impressive.

-Dave

--

[Slava Pankov]

Just tiny update. Dev mode is still working just fine on Windows with Chromium 38.0.2125.0 (292384) from Dart 1.8.3 distribution.

[Liam Stewart]

Debugging javascript is a king size pain in the arse if you live and breath Java, super dev mode is still nowhere near good enough to really use when you have a lot going on and you need to step through and evaluate line by line the state of the application at runtime, this becomes particularly important if you are delving deeply into hibernate and hazelcast environment like we do.

I was tasked with evaluating IntelliJ as a viable alternative after we went to GWT.create this year, I used it for a morning and wasn't impressed with what I saw... it is painfully obvious you are debugging javascript as the values you want are hidden down inside elements and the debugger simply won't play ball at times, having to put in a debugger API call if you actually do really want it to stop is ridiculous...

I've attached an image of how I feel google has responded to the issue of dev mode - if they really cared about the developers they would have just released a dev version of chrome or something for us, not dropped us in it with a super dev mode that 'will definitely be good, honest, promise... at some time in the infinite future'.

Grumble.

[Ümit Seren]

What does debugging hibernate/hazelcast have to do anything with debugging the frontend (GWT) part ? 

Yes, debugging in SDM has it's pain points but apart from Dart (which has its own Chrome version Dartium) every transpiled/compiled languages relies on source maps and the browser's DevTools, so you can be sure that this will become better and better. 

Apart from that Chrome Dev Tools provide many pretty cool features to debug client side apps ranging from detecting memory leaks to performance flame charts, etc. 

Also being able to directly manipulate the generated HTML in the dev tools is quite powerful.

[jonl]

https://sdbg.github.io

Allows you to debug javascript in Eclipse when running your application in Chrome.  Has its limitations and is a work in progress, but it works.