What's the benefits if I am using Ext-GWT? Compare to GWT, What kind of benefits EXT-GWT could bring?
If you want your application to look like all the other Sencha applications, then go for it. Sencha comes with a set of tools and widgets that might help you make a faster start, but at the end of the day, you will need a deeper understanding anyhow, and climb that hill.
My 2 cents : go for GWT pur et dur.
for maximum flexibility
for better results
but probably a steeper start.
From the sencha site:
Sencha Ext GWT takes GWT to the next level, giving you high-performance widgets, feature-rich templates and layouts, advanced charting, data loaders and stores, and accessibility, and much more.
I was using the widgets in a project which is nice if you need something fancy not in GWT-only.
As someone who has used both extensively, I can attest to the amount of features added by GXT... ...but, at a price. Its deferred layout system is efficient, but it's a steep and sometimes frustrating learning curve, especially if you want to support IE<8.
Note that I haven't used GXT 3.0, but used 2.X for a large and successful enterprise application. If you do not write some kind of web-based unit tests (selenium recommended), you will eventually get to a point where you spend more time fixing layout bug regressions than you do creating new code.
GXT can kickstart your initial development because you can produce feature rich widget very quickly (Grid is especially nice), but when it comes time to start extending and augmenting the default widgets, you're going to hit brick walls with very little documentation.
Another big gotcha... GXT models internally serialize using a Map<String, Object>, which means that any types not explicitly serialized elsewhere in your RPC will give you errors when put in a GXT model. The workaround there is to put a private, unused field of the type you want serialized (enums were my biggest pain). Finally, gxt models are NOT default java serializable, so if you want to store them in sessions or pass them around on the server, it's not going to go well for you.
All that said, once you get the hang of GXT, and provided you don't dig too deeply into its guts, it is a great tool. The widget sets themselves are very nice...
Basically, if you intend to create a monolithic, feature rich, complex app where you need lots of control over how things are rendered, GXT will probably get in your way.
If you want to bang out a shiny app over the weekend, don't reinvent the wheel, and just use whatever works.
Related
I am looking to build a GWT based web application. Being new to GWT, am looking for suites that provide the best GWT widgets (in terms of user experience, variety, styles, etc.), to help build a web app.
I have come across SmartGWT, but looking for other options/suggestions.
Thanks in advance!
I've done apps in both GWT and SmartGWT. My observations, for what it's worth:
SmartGWT has all sorts of cool features, out of the box. It's easy to be seduced by the SmartGWT showcase.
GWT is converging on SmartGWT, and quickly. For instance, the new DataGrid
can stand up against the SmartGWT ListGrid and come away looking good.
In order for GWT to look good though, there has to be real skill in the
developer. SmartGWT can make anyone look good, it seems, but to make
GWT shine takes skill.
Once you have that level of skill, though, there's no looking back.
GWT seems to me to be much more flexible, a consequence of the building-block approach. SmartGWT is more monolithic.
SmartGWT's design has some portability issues. I successfully took a pure GWT app I made and re-worked it (minimal effort) to run nicely in a BlackBerry PlayBook browser. I took a
SmartGWT app I had made at about the same time, and half the widgets
didn't work.
For an enterprise level solution I'm working on, I'm using pure GWT and I don't regret having made that choice.
I would suggest using standard gwt widgets. Simply because,
1)they are best documented,
2)they are highly customizable via css
3)from what I observe they provide the best performance
4)you dont need to learn a whole new framework built on top of another framework
but if you insist on using a framework then I suggest you take a look at this question
My advice to you is to consider your needs. Plain GWT and SmartGWT both are the best supported, so you need not look for more (unless of course both fail in what you want).
Go to their respective showcases and see what they offer and how it fits your requirements.
If gwt satisfies all your UI requirements, my advice is to choose it over SmartGWT. gwt beats SmartGWT in learning curve and documentation anytime. Also its faster(my opinion). If gwt doesn't satisfy your needs and SmartGWT does, then you should consider making the switch.
I have a year experience in smartGWT, when we started our first gwt lessons, they said use the basic gwt features and build own framework otherwise we can encounter errors which may lead to dead-ends. We considered the idea, but for the project (since we already had deadline) decided to look after some extension of gwt. We found smartGWT. The showcase was really convincing. Remember these are widgets, the basic logic of your system is still up to you.
In case if you start using smartGWT: If you don't use JSON but some normal list of java structures prepare to get hard hours/days to get use to datasources, grids, and few other components. Seriously, it had ridiculous problems (for example switching two configuration code line without reason makes work the listgrid), BUT before you drop the entire idea to use it, after a while it starts to work, and it becomes really impressive and comfortable. This is a kind of work "make it once, will work hundreds of times".
In my opinion:
don't start use smartGWT if you want to make a system which is not too complicated.
start use it if you need complicated system with lot of different features, if you don't have the time to develop everything for yourself: many components are ready in smartGWT.
By 'web developer' I mean a software developer having a sound
understanding of web fundamentals (HTTP, HTML, CSS, JavaScript and
Ajax).
By 'successful GWT developer' I mean someone who can produce
high quality and polished looking GWT apps in timely fashion.
My department is gearing-up for a project that will require the development of a number of single screen RIA web apps. These will front enterprise server components implemented in Java. Our UI prototype was developed using ExtJS and was successful (in terms of speed of development and producing a professional, polished looking UI that integartes well with a service oriented API implemented using Spring-MVC + Jackson). However, in gearing-up to develop the actual product we have realised that our department's skills profile isn't ideal for ExtJS. We are strong on Java but relatively weak on web developers. The development of the UI prototype demonstrated that you really need fully feldged web developers to get to grips with ExtJS, since they will spend a significant amount of time grappling with CSS and JavaScript issues. As a result, the question has arisen as to whether we might be better off going with GWT (combined with a library that offers a level of polish comparable to ExtJS, such as SmartGWT). Obviously this assumes that GWT is significantly less demanding in terms of web development skills. To what extent would GWT + SmartGWT allow our Java developers to crank out high quality RIAs without them having to acquire anything more than a basic appreciation of the web fundamentals listed above?
If we decide to explore GWT further we'll do another prototype, but in the mean time it would be very interesting to hear the opinions of experienced GWT developers.
My experience is that you can get away with a lot without advanced web skills, but the end result is a pretty bland looking app, but even worse, you'll find yourself struggling to achieve all the dynamic effects you want.
As an example, my app has a DataGrid on the main tab. That could be done easily enough using pure GWT. But then I wanted to put a checkbox under the DataGrid widget that the user could use to select "single line mode", in which the rows are one line each -- any data in cells that would have word-wrapped just disappears at the edge of the cell. Hit the checkbox, and the rows collapse to one line each, then hit it again, and the row heights expand to whatever size is needed to display all the data in the cells. There isn't a method for that. What you have to do is adjust the row style of the DataGrid to add or remove the CSS element "white-space:nowrap;". So you add a ValueChangeHandler to a CheckBox widget (GWT skills) that modifies a CSS style of the DataGrid widget (web skills).
Without web skills, you'll find yourself hitting walls in trying to achieve the look-and-feel (and even dynamic behaviour) you want. Having said that, you can find these sorts of answers easily enough on the web. The key thing to remember is that just because GWT doesn't seem to have a method for something, that maybe it's really a web issue, not a GWT issue, and that you have to remember to think outside of the GWT box to solve your problem (instead of throwing up your hands, blaming GWT for lacking a feature, and hoping something like SmartGWT will solve all your problems).
The fact that every GWT widget has a plethora of methods for setting, adding, and removing styles, and the very rich integration via ClientBundles and UiBinder and the like, means that this was always the intent.
GWT is a very capable framework and can be used to produce great results such as Pictarine, but as the developers of Pictarine indicate:
Another thing that was not obvious to us when we started with GWT was that a java developer needs an intimate knowledge of HTML/CSS if he/she wants to go beyond the basic user interface provided by the GWT widgets.
I'm not quoting this to discourage anyone. Basic interfaces are indeed within reach with GWT without much HTML/CSS knowledge. GWT, however, leans on web languages and so in a non-trivial application familiarity with JavaScript, HTML, and CSS will come handy. Personally, using GWT has been continuously deepening my JS/HTML/CSS skills as I've been searching for ways to enhance my GWT projects, which in the end has been very rewarding.
I typically work on web apps that will only be used by a small group of well-controlled people, but now find that I'm writing something that has the potential to be used by a very large population. This means that the design and "look" will be very important to the success.
While I can certainly code up something functional, it ain't gonna look pretty, so I know that I'll need to get an outside designer to make things look good. Never having worked that way before I had a few questions about the mechanics of how this happens and how to try to make things easier.
We do Java, so when building a rich interface, we use GWT. I know that when working with designers, they typically provide images of what the interface should look like without any type of "useable" output. My question is how best to bridge that gap between a simple drawing of an interface to a fully functional realized one.
Any thoughts are appreciated.
Well, "it depends", as always.
Nowadays, I don't think you can work wit someone who simply provides PhotoShop mockups. At least not at your level. Mockups are simply too static, and translating those mockups to actual pages that actually work with different browsers properly is a skill set all its own.
So, you need someone beyond simply a designer, especially if you are planning any javascript wizardry, animations, or other dynamic elements that don't capture at all well on a static image.
What you really want is an "operational" mockup. Static HTML files that look and behave as best as can be done to what the UI designer wants to do, including transitions, work flow, etc. This artifact can be run through all of the stake holders as a live mockup, letting folks "Feel" the site.
Once you have these HTML files, you can then do your part of backfilling these pages with actual server side content. Obviously you can start early working on models and working with the designers so as to have services ready to support the site functionality, but you shouldn't be committing any real time in to actual pages for the site.
As for interacting with the designers, I talk more about that over here: How can I make my JSP project easier for a designer to work with
I worked on a project very much like this. We had "comps" which were pictures of what the interface would look like. We identified common objects and build modules. Then built pages (this was for a web app) from modules plus any elements that were unique to that "comp".
A couple things to keep in mind that will make life much easier: use the comps/drawings as more of a recommendation rather than set in stone design. Try to identify common pieces early on and reuse code.
Also, designers aren't user experience gods. They often have a good idea of how things should work, but if you are close to your product and have a lot of product knowledge, don't be afraid to tweak the design as you and your group see fit. One thing that designers typically lack is product knowledge. They know a lot about general user experience and how a site should work, but they often won't know the in's and out's of your use cases and products.
If you are working with GWT, you should look for designers who are expert in CSS. Apart from, may be, the main layout of the website, all the application components like form fields, dialogs, tabs and grids etc. will need to be styled using CSS.
If the designers are not experienced in working with GWT, share the GWT's documentation about styling with them. It's a good idea to read these yourself as well. Specifically explore the GWT's theme-ing system.
Also try to make use of UiBinder as much as possible. This would allow you to stay as close to traditional HTML based design while still enjoying the GWT high level object oriented interfaces (both widgets and DOM).
Optionally you might want to tell the designers that GWT image bundles will automatically do "CSS Sprites" so they don't need to worry about page load performance issues related to images.
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
I have read that gwt-ext is slow and it seems too bulky. How does this compare with Ext-GWT? Are there any other libraries out that can easily handle dragging, resizing, minimizing?
In my opinion there are no real worthy GWT widget libraries that I want to even consider. If there is a widget missing you can always try to get one included in the incubator, this way it will maybe end up in the GWT distribution one day.
The bigger, impressive looking ones tend to be a wrapper for an existing JS widget library. Which means that you have to pass on many of the benefits of GWT.
Others like Rocket GWT are a complete rewrite of existing widgets which ties you to another abstraction. That means that if you need extra widgets outside of the Rocket ones you will need to use widgets that follow different design principles.
I tend to stick to the default ones and I use the incubator widgets but I always try to keep those dependencies to a minimum since these are still changing dramatically (changing classnames, packagenames, complete design changes, ...). You do not want to keep on modifying existing code.
In most cases I just create my own widgets that does what I need and nothing more. That takes a lot less time to create than if I have to implement a complete API that would cater a lot more usecases.
Have you looked at http://www.smartclient.com/smartgwt/showcase/
The controls are licensed as LGPL, but advanced server site libs are only included in the professional edition.
we're having some success with Mosaic from the GWT incubator. You'll wish for better documentation, but once you get past that you'll find useful widgets (split panels, etc.) that you can mix with gwt's basic widgets.