As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 9 years ago.
My company is planning on developing a brand new web front-end application.
Some background:
It must "sizzle" i.e. a nice marketable look and feel.
Our development team has no Java experience, with limited experience in Silverlight, Javascript, JQuery or CSS.
Time to market is a factor.
We need to stream large amounts of data from an Oracle database.
It must support 500 - 1000 concurrent users
It will be hosted internally behind a firewall.
We need mapping (geo-spatial) capabilities.
Someone has recommended using GWT instead of Silverlight or Traditional technologies(Javascript, jquery, CSS etc.).
I am not sure if this is the right way to go? A lot of the GWT news is from 2007/2008. It makes me think that this technology is old and maybe dying.
If you had a choice would you choose GWT?
unfortunately two of your statements are mutually exclusive in this context:
Our development team has no Java experience
Time to market is a factor
I'm a Java programmer who has picked up GWT over the last year or so. It's immensely effective being able to write direct to the browser using a compiled language & mature development tools. I can fly through web-development faster than ever before (using ASP, JSP, ExtJS ...).
But, as the other commenters have said: if you've no Java experience you're going to find it a real challenge picking up both technologies (Java & GWT) in a short time. If you do manage to make it to market in a reasonable time I could only imagine the code base would be in very poor condition (since you'd be learning as you go) - which would be a very poor foundation for your organisation's shiny new venture.
There again, you don't have a 'lot' of skills in the other related skills you listed either.
I suspect there's a more effective solution. As some wise old goat project manager said:
I have three variables to delivering your project: time, cost and quality. Pick any two
In your situation, if the organisation wants a quality product in a short time, it's the cost factor that must compensate - your organisation should buy in some interim GWT expertise to give you a sound software architecture and to mentor your team for the next few months. After that you'll be ready to take the reigns, inheriting a quality codebase by 'standing on the shoulders of giants'.
As others have said, GWT definitely is not a dying project. Quite the contrary actually as there are now more than 20 regular contributors from within Google (versus a semi-dozen back in 2008). Wave (despite being discontinued as a Google service, it's still alive as an Apache Foundation project), Orkut, AdWords, Google Moderator and the new (still beta) Google Groups are made with GWT; and parts of Google Buzz and a few other projects at Google are built with it too.
Now as to your choice:
Silverlight is a dying technology. Microsoft made it clear that it now invests in "HTML5": http://www.zdnet.com/blog/microsoft/microsoft-our-strategy-with-silverlight-has-shifted/7834
GWT is mostly a client-side toolkit, but it comes with "high productivity" tools for client-server communications (GWT-RPC and RequestFactory for end-to-end protocols, AutoBeans for easy JSON serialization). With UiBinder, you can easily put to use your web designer skills.
if you're comfortable with JS, then go for it, but then you'd have to choose the "right toolkit" (jQuery? Google Closure?). Otherwise (which seems to be the case), it really depends how much "ajaxy" you need/want to be. I'm a strong believer in "one-page apps", but YMMV, or you can have specific constraints that rule it out. In any case, you'd have to choose a server-side technology.
So, depending on your needs/wants and skills, I'd choose GWT or "some JS toolkit". In any case, you'll have full control over the look and feel (unless you choose one of the bloated players: ExtJS/ExtGWT, SmartGWT or similar; you'll probably have a shorter time-to-market with these, but you'll pay it later, in terms of performance, integration with other toolkits, and look-and-feel).
In the light of what you're saying about your skills, I would definitely recommend GWT (despite your lack of experience with Java); because lack of experience with JavaScript is far worse than lack of experience with Java (you're talking about a "large application", so it's really important to start building things right and/or have tools to help refactoring, which you'll have with Java).
#ianmayo replied while I was writing the above, and I can only second what he said!
GWT is definitely not old or dying! A lot of Google's own applications are developed using GWT. You can download the GBST case study and learn how the global financial company uses GWT to improve productivity and create a rich user experience. You have to know that when you use GWT you automatically use javascript, html, etc. You create a your gwt application in java, but when you compile it gwt creates a folder with html files, javascript code, css, etc...
I definitely recommend it!
In order not to mislead readers with above seemingly unanimous answers, keep objective view in respected stackoverflow, following review expressed exact experiences I had with using GWT. Whether GWT is dying depends on how many new apps will adopt it,Google trend can tell (gwt trend).
Excerpt from https://softwareengineering.stackexchange.com/questions/38441/when-not-to-use-google-web-toolkit
>
I am both good and bad to answer this question - good, in that I've actually used it before, and bad, in that I was quite experienced with HTML/CSS/JavaScript prior to working with GWT. This left me maddened by using GWT in a way that other Java developers who don't really know DHTML may not have been.
GWT does what it says - it abstracts JavaScript and to some degree HTML into Java. To many developers, this sounds brilliant. However, we know, as Jeff Atwood puts it, all abstractions are failed abstractions (worth a read if considering GWT). With GWT, this specifically introduces the following problems:
Using HTML in GWT sucks.
As I said it, to some degree, even abstracts away HTML. It sounds good to a Java developer. But it's not. HTML is a document markup format. If you wanted to create Java objects to define a document, you would not use document markup elements. It is maddeningly verbose. It is also not controlled enough. In HTML there is essentially one way to write
<p>Hello how are <b>you</b>?</p>
In GWT, you have 3 child nodes (text, B, text) attached to a P node. You can either create the P first, or create the child nodes first. One of the child nodes might be the return result of a function. After a few months of development with many developers, trying to decipher what your HTML document looks like by tracing your GWT code is a headache-inducing process.
In the end, the team decided that maybe using HTMLPanel for all HTML was the right way to go. Now, you've lost many of GWT's advantages of having elements readily available to Java code to bind easily for data.
Using CSS in GWT sucks.
By attachment to HTML abstraction, this means that the way you have to use CSS is also different. It might have improved since I last used GWT (about 9 months ago), but at the time, CSS support was a mess. Because of the way GWT makes you create HTML, you often have levels of nodes that you didn't know were injected (any CSS dev knows how this can dramatically affect rendering). There were too many ways to embed or link CSS, resulting in a confusing mess of namespaces. On top of that you had the sprite support, which again sounds nice, but actually mutated your CSS and we had problems with it writing properties which we then had to explicitly overwrite later, or in some cases, thwarted our attempts to match our hand-coded CSS and having to just redesign it in ways that GWT didn't screw it up.
Union of problems, intersection of benefits
Any languages is going to have it's own set of problems and benefits. Whether you use it is a weighted formula based on those. When you have an abstraction, what you get is a union of all the problems, and an intersection of the benefits. JavaScript has it's problems, and is commonly derided among server-side engineers, but it also has quite a few features that are helpful for rapid web development. Think closures, syntax shorthand, ad-hoc objects, all of the stuff done by Jquery (like DOM querying by CSS selector). Now forget about using it in GWT!
Separation of concerns
We all know that as the size of a project grows, having good separation of concerns is critical. One of the most important is the separation between display and processing. GWT made this really hard. Probably not impossible, but the team I was on never came up with a good solution, and even when we thought we had, we always had one leaking into the other.
Desktop != Web
As #Berin Loritsch posted in the comments, the model or mindset GWT is built for is living applications, where a program has a living display tightly coupled with a processing engine. This sounds good because that's what so many feel the web is lacking. But there are two problems: A) The web is built on HTTP and this is inherently different. As I mentioned above, the technologies built on HTTP - HTML, CSS, even resource-loading and caching (images, etc.), have been built for that platform. B) Java developers who have been working on the web do not easily switch to this desktop-application mindset. Architecture in this world is an entirely different discipline. Flex developers would probably be more suited to GWT than Java web developers.
In conclusion...
GWT is capable of producing quick-and-dirty AJAX applications quite easily using just Java. If quick-and-dirty doesn't sound like what you want, don't use it. The company I was working for was a company that cared a lot about the end product, and it's sense of polish, both visual and interactive, to the user. For us front-end developers, this meant that we needed to control HTML, CSS, and JavaScript in ways that made using GWT like trying to play the piano with boxing gloves on
First of all , GWT is not dying technology, its usage increases, and its latest version is 2.2. I am using GWT for 2 years, since version 1.6. Its improvements since them is quite amazing.
Since GWT is client side technology, it does have only positive effects of your application scaliblity feature. Because server side web technologies such as jsf, struts, wicket are server resource consumers, but gwt does not need any server resource to render user interface..
But there is problem for your team. Because your team has no java experience, it would be quite difficult to adapt yourself two new technologies java and gwt.. If you have time to learn , I would strongly suggest GWT.
It takes approx 1 year to become proficient in GWT. Using GWT pays off if you develop an application as sophisticated as MicrosoftOffice or PhotoShop. It makes no sense to use GWT for small and relatively simple apps, IMHO. GWT is a time killing framework indeed, and you have to have very strong reasons to use it. I think that 99% of web apps don't need GWT.
GWT is not dying framework, but time killing framework. It has security issue. You can do easily CSRF(Cross site request forgery) request to the GWT applications. Also Java and Javascript are totally different languages, you can't translate easily. For your productivity avoid GWT.
Related
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
We are trying to choose a framework for our client development for a web application. These are the key points about our application.
1) Rich text application where user performs many activities in the client.
2) We are looking to develop using Java technology
3) The services will be offered in cloud.
4) Mobile support is required.
5) Scalability is also one main concern.
I went through lot of doc and information along with this video http://twit.tv/show/floss-weekly/187 online and have now left with Vaadin and plain GWT. I have a small bit of experience in development with GWT, but not in Vaadin(I have written couple of sample programs only in Vaadin). Please help me in understanding few things.
1) If I have to write a new widget in Vaadin how easy or difficult it is to accomplish?
2) Is there any obvious issues with Vaadin widgets or concepts which might be a blocker for any application?
3) If tomorrow we decide to just switch back to GWT, is that feasible given that Vaadin works with all server code logic?
4) Does the Vaadin method of going to server everytime a concern for applications that are deployed on cloud?
5) Last but most important, how is forum support and future dev?
Thanks a lot. Please note that I have gone through many articles and links about these discussions but feel its good to know from a guy who has real experience in these stuffs atleast for sometime. Thanks again.
GWT
now left with Vaadin and plain GWT.
Vaadin 7 and Vaadin 8, now known as Vaadin Framework, are both Java-based wrappers around Google Web Toolkit (GWT).
You write pure Java code for your business logic and UI-creation. This Java code runs in a JVM on the server-side in a Java Servlet web container. The magic happens when Vaadin uses GWT to auto-generate the necessary HTML, CSS, JavaScript, DOM, AJAX, XML & JSON, WebSocket, and Push code needed to render your web-app’s user-interface within the user’s client-side web browser.
So, pure Java on the server-side, pure web-standards tech on the client-side (no Java on client).
Web Components
Vaadin 10, now known as Vaadin Flow, replaces the internal use of GWT with the emerging Web Components standard technology. This new generation is a major re-write of Vaadin, though its purpose and many of its concepts such as data-binding remain the same.
By leveraging Web Components technology, it should be easier to build Vaadin widgets. And it should be relatively easy to make existing JavaScript-based components not designed explicitly for Vaadin available to your server-side Java code. That's the whole point of Web Components: making web-based widgets that work across various web framework tools.
While the Vaadin Ltd in quite excited and proud to ship Vaadin 10 Flow, they remain committed to Vaadin 8 Framework as well. Vaadin 8 is under active development, with a road map plan for continued support at least through the year 2022.
If you really want to work with GWT, you can do so in Vaadin 8 Framework.
If you want to bet on Web Components instead of GWT, go with Vaadin 10 Flow.
Rich apps
Rich text application where user performs many activities in the client.
If you meant "rich text" as in fonts, colors, and such, you should study the RichTextArea widget bundled with Vaadin 8 as well as check the Vaadin Directory for additional add-ons. That widget is not being brought over to Vaadin 10 Flow, but as mentioned above, the use of Web Components may make other existing such tools available to a Java-based Vaadin app. I see one already in beta.
If you meant "rich" in terms of professional-looking, business-oriented, desktop-style web apps with enterprise-level reliability, that is the very purpose of Vaadin.
Java
We are looking to develop using Java technology
That is the raison d’être of Vaadin: Writing pure Java to leverage the vast ecosystem of Java tooling and libraries, with all its benefits of security, performance, and reliability — while at the same time using web-standards technology to auto-render your app in a web browser.
Mobile
Mobile support is required.
The Vaadin collection of widgets have evolved to support touch-surface gestures.
The Vaadin Ltd company previously offered a special package for mobile support, called Vaadin Touch. The built-in support for touch gestures in regular Vaadin widgets rendered that package obsolete and unnecessary.
Cloud & scaling
The services will be offered in cloud.
Scalability is also one main concern.
Your Java-based Vaadin app does live in a JVM on the server-side. Each current user is represented by session object. All the user-interface widgets appearing in the browser have a counterpart in a Java object on the server. You may be keeping further data and functionality in additional Java objects on the server. You may be calling JDBC or Web Services etc. from that server-side as well.
So all of that takes up memory and CPU cycles on the server. You do need to be cognizant of your programming doing caching and placing other burdens on the server. Any resources shared between users must be thread-safe, as a Java Servlet environment is multi-threaded by design.
Robust server hardware (memory, cores) may be needed, depending on the particulars of your app. Or you may want multiple servers with sticky-session load-balancing if you truly have a very large app with very many users.
The Vaadin Ltd company has simulated the use of a Vaadin app supporting thousands of simultaneous user sessions. You can contact them for consultations on your particular situation.
While scalability is an issue to consider, do not jump to conclusions. Think it through, and do some experimentation.
Creating custom widget
If I have to write a new widget in Vaadin how easy or difficult it is to accomplish?
In Vaadin 8, you can indeed create your own widgets. But doing so required learning the use of GWT. Doable, certainly as you can see from the hundreds of published add-ons in the Vaadin Directory. But still some serious work. The Vaadin Ltd. offered training on this.
In Vaadin 10 Flow, the use of Web Components should make the creation of your own widgets much easier. Check out this starter project provided free-of-cost to get you going. See the tutorial, Creating A Simple Component Using the Element API. Key concepts in creating widgets in Vaadin 10 Flow:
Every Vaadin 10 component always maps to one root element in the server-side DOM representation.
The Element API makes it possible to modify the DOM easily from the server side.
Any other issues?
Is there any obvious issues with Vaadin widgets or concepts which might be a blocker for any application?
Not sure what you mean here. I suggest reading through the excellent Vaadin tutorial and manual. It leads you through using all kinds of features in Vaadin.
Having used other rapid application development environments for desktop apps, Vaadin always made sense to me, fit my way of thinking and doing things.
Bleeding edge
For Vaadin Flow, know that Web Components is still new, and somewhat bleeding-edge. Web Components is actually a collection of technologies. Not all of these are supported fully by all browser makers. So some polyfills are still necessary.
Vaadin Flow also makes use of the pair of modern page-layout features that have finally arrived in CSS: Flexbox and Grid Layout.
Only the latest versions of the browsers are coming close to having good support for all these features. See CanIUse.com for particular details.
Part of Vaadin’s purpose is to paper over the gaps between various versions of various browsers, to insulate us developers using Vaadin. So you may not encounter problems in some browsers, but then again you might.
Also, Vaadin Flow does not quite have all of Vaadin 8 features. Some are under development, and some are planned.
Upshot: If you are eager to ship soon and cannot insist on users updating to the latest browsers, use Vaadin 8 rather than Flow.
Leaving Vaadin for GWT
If tomorrow we decide to just switch back to GWT, is that feasible given that Vaadin works with all server code logic?
If you want to use GWT, and you want to write that server-side logic in Java, then Vaadin 8 Framework is the perfect tool for you. I do not see how you would ever want to leave Vaadin.
But if you did leave Vaadin, you would no longer have the glue that connects your GWT in the browser with your Java code on the server. That glue is what Vaadin provides for you. Of course, you can write your Java back-end business logic to be unaware of Vaadin directly. Indeed, Vaadin Ltd provides a Maven-based multi-module archetype for this very purpose. The backend module holds your business logic and database-access (etc.) code, kept separate from the ui module containing your Vaadin-oriented code.
Network traffic
Does the Vaadin method of going to server everytime a concern for applications that are deployed on cloud?
You will need to do some experimenting and profiling to see the memory and cores needed for your particular app. Vaadin can be demanding on server resources as discussed above.
But technically, no tricks or technical limits with cloud deployment. Just plain Java code running, in a JVM. Anything that can run a Java Servlet web container such as Tomcat, Jetty, Glassfish/Payara, WildFly/JBoss, and such can run your Vaadin app.
If you are concerned by the network traffic, yes, there is traffic. When a user uses a widget such as clicking a button or entering data in a field, your server-side Java app is informed so that your app can respond with business logic. So that means frequent network traversal.
You do have options to not immediately inform the server-side when not needed. In doing so, you are controlling some of that traffic. For example, you can choose whether you want the server-side to be informed (and react) for every single keystroke while entering text in a field, or occasionally such as a pause between keystrokes, or only after the user has completed entry in that field. See the [Configuring the Granularity of Value Change Events](https://vaadin.com/docs/v8/framework/components/components-textfield.html section in the manual.
I did fear a problem with Internet performance when I started with Vaadin. But I can say that in my own experience, I was pleasantly surprised, astounded really, to find this was a non-issue for me. For example, in the United States, with a mere Mac mini in a colo in Wisconsin on very fast Internet connection running a Vaadin 7 or 8 app reacts virtually instantaneously on clients accessing household DSL and Cable-TV connections in Seattle, Florida, and Canada. When accessed from Hong Kong, only the slightest delays, generally imperceptible in a data-entry app.
Your mileage may vary, of course. My example above was a dedicated computer. In contrast, cloud providers are notorious for fluctuations in both CPU availability and network delays or latency.
Support
Last but most important, how is forum support and future dev?
Vaadin Ltd appears to be a very healthy open-source company. They sell add-on products, support, consulting, and training. The company has been growing, hiring more staff, and establishing overseas offices (US, Germany) while their home base remains in Finland (Turku, Helsinki).
The various Vaadin products are under very heavy development with many incremental releases, pre-releases, and soon to arrive Long-Term-Support versions. The regularly publish a road map to their development plans. They also provide regular updates on their business and technical issues in their blog.
The Vaadin Ltd company hosts a very active forums site. Both their staff and other users actively use Stack Overflow as well.
I think you should make this decision depending on the architecture of each, because this is the point where they differ the most.
Vaadin follows the Half-Object Pattern and is therefore more comparable to Eclipse RAP (and ZK) than to GWT. You have basically a server-application and you control it from the Browser. Think of a simple Button, its state is hold on the server and in the browser you see a representation of it. Everytime the Button's state changes, it has to communicate with the server in order to update it's state. So this is true for every widget you have.
I must say that I have not much experience with Vaadin or RAP, but imagine how many states your server will have to juggle when you have many widgets and many users who use them at the same time. This may not be a big concern in the cloud, but maybe on a traditional server with limited resources.
That said, you can imagine that this approach is also not very mobile-friendly. Every state-change results in a server round-trip, but on mobile you might have a poor connection or even none at all.
Here I would clearly prefer plain GWT as it can run entirely in the browser and is also usable "offline".
Your other question was about widgets. It is true that GWT does not provide as many widgets as Vaadin, but there are good Widget libraries out there to supplement the stock GWT widgets. The problem is, you can not start with Vaadin and decide later on to switch back to GWT because Widgets written in Vaadin can not be used in plain GWT. But the other way around works, GWT Widgets and self-written widgets are usable in Vaadin.
I would suggest to start with plain GWT, write your own Widgets with UiBinder, it is very very easy. If you feel you would like to use some more complex widgets, look at widget libraries like GWT-Bootstrap or Sencha GXT, they play very nice with plain GWT.
if you want future dev, go with jsf, honestly. It is not the best pick, but you will be at least vulnerable of dying frameworks.
In our project I have to use Vaadin, I would not have decided so. I prefer ZK (http://www.zkoss.org/) or GWT.
Regarding your questions, as far as I can answer them.
Relatively easy, like Swing. You extend CustomComponent and there you go.
Performance. We have performance problems and problems while programming. The architecture had to be rethought several times because of VAADIN specification. In combination with JPA, to me, it is not a pleasure to work with.
Hard to tell. Of course you read everywhere about MVC, loose coupling, etc. But I personally think you always have some roots from your GUI framework that affect some code below. You cannot simply change the framework as plug'n play. I don't know the details, but probably the lifecyle is already different than other frameworks. So the implementation of Vaadin for the communication with the db for example, as when using FormFactory, will affect your persistence layer which you will have to adjust when using another framework. Simply because of the implemented strategy.
I have no experience here.
Vaadin is big in the community and it seems, many people use it. I experienced that the Vaadin team does a string effort in propagating the framework and also is there to answer questions and help you whereever it can. I appreciate that. The documentation is really good.
I personally think you will have to deeply think about the framework and if it does fit your needs.
Before choosing for a big framework think abou, if you want to
- server side programming (ZK, Vaadin, )
- server and client (GWT)
- using markup language and logic (JSF)
What will be your environment setup, like application server, database, etc?
Even though Vaadin is a good product, I would not use it, if I was free to choose.
Ciao
It's better to choose client-side technology like HTML, Javascript or more advanced UI frameworks like ReactJS, Angular instead of server-side technologies. Server-side frameworks are slow in performance and hard to debug for browser issues.
At the moment Iam evaluating java web frameworks. More precisely Iam talking about GWT, JSF2 and apache wicket. One very importent criteria in this evaluation is prototyping.
The prototyping process in my company can be described by the folloing:
The customer can produce GUIs with an easy to use WYSIWYG editor, by drag&drop-ing web components on the corporate predefined website structur. There is also a need for some litte dynamic being like navigation from one frame to another.
So Iam looking for tools. These tools should not only provide nice GUIs but also deliver
some basic code, which can be forwarded to the development. The aim is to avoid missunderstandings between designers and developers as much as possible. More or less the
developers just have to implements the code, but not to implement the optical requirements.
In addition it would be desirable to customize the components thats been used in the WYSIWYG editor. Does anyone know any good tools for the mentioned frameworks (GWT, JSF2, wicket)?
One of the challenges with WYSIWYG tools for UI is that you generally have to pick between rapid prototyping and maintainable code. Even then, as soon as you want to do something that's not supported by the prototyping tool, you can implement it as you would without the prototyping tool, but your round-trip functionality (namely turning your app back into something that can be edited) is broken or crippled unless extra work is done to generate the metadata that the editor needs.
Upgrading between major releases is another issue. Vendors and groups who have developed these tools have a historically spotty record of when they stop supporting older versions, reasonably because of limited resources and sometimes difficult problems with how to track solid innovation happening in the framework itself.
My suggestion instead is to prototype with an RIA prototyping tool like Balsamiq Mockups or use a grid system like 960 Grid to generate rapid prototypes, then use a web development framework that allows your developers to run the code with or without the backend server. Wicket has a tag called that is great for this kind of thing -- web devs can fill a div with stuff that a component should generate, and Wicket devs can wrap the contents of that tag with after they implement it. Both parties can coexist for a long time that way.
Try GWT Designer for GWT.
Introduction
Quick Start Guide
Download
There's nothing like this for Wicket that I know of. The closest you would get to any kind of resource reuse from your customer would be to give them a drag and drop HTML editor - the resulting HTML could then form the basis of Wicket page/panel layout.
if you are planing to use a javascript library, you may use extjs,
http://www.sencha.com/products/js/
they have developed a nice designer
www.sencha.com/products/designer/
there is also a port of ext in GWT
www.sencha.com/products/gwt/
You have to pay for a commercial license if your application isn't open source!
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 10 years ago.
I'm in the planning stage of a web application and I'm trying to choose between GWT and Cappuccino. I have an idea of which one I think is better, but my partner is sold on the other choice. I was hoping to get some feedback on pros and cons for each from people who have used one or the other or both. Thanks in advance for any insight you might have.
Toolkit v/s Framework
GWT is a toolkit. Its strength lies in the tools it provides to create an application. It doesn't provide a framework though. Developers usually build a small framework over GWT to suit their needs. There has been a lot of emphasis on MVP pattern to build apps, but it isn't the only way to use GWT.
Cappuccino is a Framework. It has a prescribed way of building applications. Additionally, it provides libraries to perform high level tasks like animation, drag-and-drop undo/redo etc. GWT doesn't provide any libraries for such tasks, though third party libraries are available.
This means that Cappuccino apps tend to be richer than corresponding GWT apps.
Offline Compilation v/s Runtime Translation
GWT believes in making decisions at compile time. Browser detection, I18N, image inlining, generation of sprites, uibinder template evaluation are all performed at compile time. Deferred Binding allows developers to leverage this concept in their own applications.
EDIT
Cappuccino, by default, does not need compilation. The browser downloads objective-j files, and then the framework translates/interprets them directly at runtime. However, it is possible to compile using jake. You can choose from several minifiers/compressors, including google's closure compiler.
As a result of this architectural decision, GWT apps tend to be faster at runtime than equivalent Cappuccino apps. However, because of the compile time cost, development tends to be slower than Cappuccino. GWT development plugin somewhat eases this pain, but the cost doesn't go away entirely.
Since GWT is a closed-world compiler, it can remove unused code, inline method calls, intern strings and optimize code in ways Cappuccino cannot. If Cappuccino were to introduce a compilation step, it could perform the same optimizations; but to the best of my knowledge there is no way to do the translation at compile time.
With the optional compilation step, this point becomes moot. However, cappuccino applications that do not perform such a compilation will have a poor performance as compared to a GWT app.
Type Safety
GWT is java - and is therefore type safe. Objective J is javascript, and therefore dynamically typed. This has its own advantages and disadvantages, and since it is a religious discussion, I will refrain from making a judgement.
Debugging
GWT provides a browser plugin that helps developers directly debug Java code. In development mode, developers get to see java stack traces. At runtime, however, the generated JS code is obfuscated, and very difficult to debug (though there is a way to tell GWT 'don't obfuscate my code').
Using the super-dev-mode it is now possible to debug the Java code directly from the web-browser.
Cappuccino doesn't have a development mode, which means you have to use existing tools like firebug to debug. Errors are reported by the browser, and to debug code you have to use JS debuggers.
Unit Testing
With GWT, you can write pure java unit test cases that do not require a browser to run. This has obvious advantages - speed and ability to reuse existing infrastructure are some of them. When you do need a browser to test, you can choose from GWTTestCase or HTMLUnit. Its also possible to test using Selenium.
Cappuccino apps can be tested using OJTest. Unfortunately, I couldn't find much documentation on the subject, so can't comment much. Of course, you can always use Selenium to test your webapp.
Interoperability with Javascript
GWT provides a way to talk to existing JS libraries - its called Javascript Native Interface. It is mature and works well, but isn't really intuitive. Objective J is javascript, so you don't have to do anything special to inter-operate with Javascript.
Vision
I can't back this argument, but GWT tends to focus on creating high-performance web applications without caring much about look and feel. They never compromise on performance. Cappuccino on the other hand tends to focus on higher level features and frameworks, and compromise on run time performance.
As a result, Cappuccino apps look richer, but take a while to load. GWT apps load and respond faster, but look boring. You can get around both the problems, I am sure - but that's the way it is out-of-the-box.
Community Support and Backing
GWT is backed by Google. Their commitment to GWT is pretty strong. Newer applications (Wave, Adwords, Orkut) from Google are built on GWT. Google IO has had several sessions on GWT. The user forum is pretty active and responsive, and the toolkit itself is actively developed and maintained by Google and the open source community. The Cappuccino user group isn't as active, and has far fewer members.
I am much more experienced with Cappuccino than GWT, but from the looks of it GWT looks blazingly fast and fairly robust. It is after all backed by a fairly large player in the internet field. The demonstration at Google IO was impressive. Although this might change, GWT apps totally leave Cappuccino in the dust when it comes to load times and deployment size today.
That said, I went with Cappuccino for two reasons: first, while GWT is a classical 'good enough' engineering solution, Cappuccino is squarely targeted at 'only the best is good enough' crowd. I believe that with Cappuccino you can achieve a standard rarely seen on the web before. Not only in pretty pixels, but in raw functionality and power where everything just works at a 'desktop quality' level. Drag and drop, undo stack, fluid scrolling and resizing, split panes, and on and on. GWT is catching up, as seen in Google Wave, but it has a long way to go and Google has not traditionally cared much about polish. This is visible, for instance, in Gmail which is still not only drab looking but clunky in the user interaction after this many years.
The second reason I went with Cappuccino is that Java drives me insane with its inflexible, ridiculously verbose and unreadable style. But that might only be me.
You might be interested in my new GWT UI Framework, CappuccinoGWT
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 9 years ago.
Improve this question
From the following list of frameworks, which one would you use to develop a rich web application and why would you choose it over the others?
Sproutcore
GWT
ExtJS
GXT
SmartGWT
Dojo / Dijit
Flex
Capuccino
Grails
I'm personally tired of browser inconsistencies. If someone else has solved the problem, I'd rather not do it again. That's why I'm getting more interested in front ends like cappuccino and qooxdoo. They are a zero-HTML zero-CSS solution.
These are based on my personal experiences using the frameworks you have mentioned. So yes, it is a bit biased. So as others have said over and over again, define your requirements and which one do you think fits your requirement based on what people have suggested here.
GWT is too verbose eventhough I found many Java developers love GWT because you can unit test it and it's all in Java. But I personally don't like it because it is far from being simple. There are times when I feel I can tweak a little bit with Javascript, but with GWT I am enforced to do it with several lines of Java code.
GXT is too far from GWT these days and you will find it difficult to do things as GXT has its own way of doing things which is way too different from GWT. When complex requirement come up, in the end you are going to go back doing plain GWT. And oh, their technical support is not that good either as I had several bad experiences when asking few questions to them.
Ext-JS is good for simple stuff and the look and feel is really slick. But when things gets more complex, you are going to fight you're way through. Eventhough I have dealt with the GXT tech support, I haven't dealt with the ExtJS tech support since they have different people eventhough it's in one company, so I can't say much.
Flex is nice, really nice. But again it is good for simple stuff. Once things gets more complicated you are going to write lots of actionscript, which is less enjoyable. There are many things that is available out of the box which may be to difficult if you have to code it in Javascript, like multimedia support. And oh, if you are writing for a public website you must consider that not too many user has flash plugin on their browser.
Grails, I'm not sure how you would implement RIA apps with Grails since Grails is just another MVC framework which you need to add your own RIA framework on top of it such as the ones that you have mentioned.
This is strictly a matter of opinion. You will not get any definitive answers from anyone, since anyone that answers will have one or another that they personally prefer.
Try each one for long enough to decide which one is best for your (or your team's) purposes.
That being said, I prefer GWT. Others will invariably disagree with me.
Reasons that I like GWT:
You can share (some) client- and server-side code (as long as your server is written in Java)
GWT makes a lot of advanced performance features really easy (e.g., deferred JS loading, image spriting, CSS obfuscation)
A focus on one-page apps, with third-party support for Places (using the gwt-presenter library)
It's just as easy to add GWT to an existing web page as it is to create a full one-page GWT app
UiBinder allows you to write your UI using a declarative HTML-like syntax; you're not stuck writing Swing-like UI if you don't want to
Browser incompatibilities are (mostly) taken care of by GWT -- you just write Java code, and GWT compiles it to work on every browser
Things that may make GWT not right for you:
If your server is already written in something besides Java, you will still be able to write your UI in GWT, but you'll lose out on some nice features
Compilation time using GWT is a non-trivial cost -- Development Mode mitigates this a lot, but it's still an issue sometimes
As others have mentioned, GWT can be considered "verbose" compared to simple JavaScript libraries like jQuery or ExtJS
Ext GWT has worked well for my project. The premium support has been good.
However the project is for internal use which has allowed deployment to be restricted to one browser on one OS, and no effort has been made to change the default appearance or behaviour of Ext GWT.
Developing entirely within Java is a key benefit as it helps to keep the project manageable as features are added.
I am currently working on a grail/flex hybrid app that is working a lot better than I expected. I have looked at GWT but there were not a lot of books about it at the time and it seemed to stress the leveraging of Swing-like programming techniques which I have never liked. I agree with the comment about trying them all out. Run hello app they all have and measure how hard or easy it is to modify. Also tool (IDEs, Maven, CI...etc) support can be a big factor as well in terms of being immediately productive.
We are using Grails+ExtJS here. Since we try to make an idiomatic ExtJS application, Grails is not fully utilized, though it still makes sense to use Grails instead of, say, JSP, for the server-side part.
Why ExtJS: Because it's a very rich toolkit for GUI-like web applications. Our job is to replace an old Motif GUI, so this is exactly what we need.
Why Grails: Because it gets the job done easily and quickly. For the communication with the ExtJS part, we need a lot of JSON, and in Grails it's like that:
import foo.bar.FooBar
class FooBarController {
def viewFooBars = {
def list = FooBar.getList(session.userId, params.foo, params.bar)
def result = [resultset: list] as JSON
response.setHeader('Content-disposition', 'filename="json"')
response.contentType = "text/json";
render result
}
}
And that's even two or three lines more than necessary...
Unfortunately the answer will be opinionated, GWT in it's purest form is not an eye-candy. That being said, ExtJs GXT is super hunky dory. One of the major issues I face with evolving frameworks is that they are not absolutely defect free, If I remember correctly, GWT 2.0 was shipped out with missing CSS styles for some of the new layouts. I am trying to trouble shoot an issue in ExtJs/GXT since last 5 days :(, frameworks obfuscate a lot of things. I will go with any framework that is absolutely robust and gives appropriate error messages. I haven't worked with others though.
I'd recommend Dojo.
In addition to the massive infrastructure it provides, Dojo 1.6 is also the first (and only) popular JavaScript Library that can be successfully used with the Closure Compiler's Advanced mode, with all the size, performance and obfuscation benefits attached to it -- other than Google's own Closure Library, that is.
http://dojo-toolkit.33424.n3.nabble.com/file/n2636749/Using_the_Dojo_Toolkit_with_the_Closure_Compiler.pdf?by-user=t
In other words, a program using Dojo can be 100% obfuscated -- even the library itself.
Compiled code has exactly the same behavior as plain-text code, except that it is much smaller (average 25% over minifiers), runs much faster (especially on mobile devices), and almost impossible to reverse-engineer, even after passing through a beautifier, because the entire code base (including the library) is obfuscated.
Code that is only "minified" (e.g. YUI compressor, Uglify) can be easily reverse-engineered after passing through a beautifier.
ExtJs is great for creating complex web applications. The API provides anything you can imagine in a webapp and its really easy to extend any component after some time.
You can plug it to any backend (we use django or php) and reuse or extend any component in several different applications.
You'll need severals months to feel comfortable with it. IMHO.
That said, the lib is sometimes a bit too slow for simples uis like a website (then you can use ExtCore). But when it comes to webapps this is not an issue.
Im not a java guy so GWT was not an option for me :/
hope this helps
By day, I am a front-end web developer but in my off time I dabble with other languages such as C, Objective-C, Python, etc. When I first got into web development the idea of web applications was just getting started.
Since then two amazing frameworks have appeared, SproutIt's SproutCore and 280 North's Cappuccino (+Objective-J). SproutCore is being used by Apple for it's MobileMe application and 280 North released 280 Slides. Both of these applications are amazing and they are a testament to what is possible on the web. So the momentum is shifting. Web applications starting to look and act like desktop applications.
So my question is this: should web based applications follow web standards, separation of markup (content), presentation (design), and behavior (functionality) or no?
I am not sure about SproutCore since I have not look at the source code, but I know that if you go to 280slides.com and turn off the JavaScript everything basically disappears. You are left with some meaningless words.
Let me clarify, I understand that web based applications such as 280 Slides is meant to have JavaScript on and not meant to be functional without it but in my day job my main focus is writing clean markup, separating content, presentation, and behavior so that our site and applications can be used by as many people as possible.
It seems like the other people who have answered so far have no idea what you're talking about.
Like me, you've had it pounded into your head to make your web applications as accessible as possible. That is, they should work without scripting and without stylesheets. JavaScript and CSS should only be used to enhance the experience. They should not be required.
SproutCore and Cappuccino are frameworks for front-end development that require the user to have both JavaScript and CSS enabled. Your question is around how we reconcile this with the dogma of the day.
Unfortunately, I don't have a clear-cut answer. I like the fact that SproutCore and Cappuccino (and probably others) are testing the limits of what's possible within a web browser. I also believe firmly that information and services provided on the web should be available to as many people as possible, given the limitations of the technology.
How you approach your solutions needs to be based on a deep knowledge of your user-base. If you're working on an iPhone app, you don't need to worry about traditional web accessibility because the experience is intensely visual. If you're building a web application for a general audience, these new frameworks are probably a poor choice (if you value the widest possible access to your information and services).
Over time, screen reader software is likely to get better at interpreting JavaScript-heavy interfaces, so perhaps this issue will fade. Thing is, something else is likely to "sprout" up in its place.
Javascript is a Web standard — certainly more so than, say, Flash, which was previously (and still often is) used for rich Web applications. In this regard, SproutCore and Cappuccino are giant improvements in my book.
The question here really seems to be how important accessibility is. And that is largely a personal decision based, as Andrew said, on knowing your users. For some apps, accessibility really doesn't make that much sense — 280 Slides is a good example of this. It's a graphic design app that's largely about visual behaviors. It doesn't make very much sense for it to degrade to plaintext. (At least, a text-based app meant to accomplish what 280 Slides does would be really be a completely different thing.)
Yes. It will be difficult at first, but once the codebase matures you will be thankful you followed those rigorous standards.
Edit: An added benefit will be portability to many web-based platform via CSS profiles and whatnot.
The MVC model can be applied just as easily to desktop applications as it can to web based applications. I don't see much reason to distinguish between the two, especially since the line is more blurred in the case of web applications.
I don't know about these particular frameworks, but a lot of web frameworks these days are structured around the MVC model, such as ASP MVC, CakePHP, Ruby on Rails, etc.
Separate as much as you can and it will pay out in the end. When things get complicated and hairy :)
I think they should. Following that type of MVC design allows for changes to be more easily implemented, provides good separation of concern, and is generally easier to understand for newcomers to a project.