Lessons learned: SmartGWT 2.3 – Component-Library for Google Web Toolkit (GWT)

I used SmartGWT in our last project (duration: 6 months) – that is a component library for the Google Web Toolkit (GWT). I wanna share my experiences with that component library in the following. I show pros and cons of SmartGWT. Then I explain why I would use only a the client side of SmartGWT in future projects. I used SmartGWT Power 2.3 and GWT 2.0. All information is my personal opinion!

I used SmartGWT 2.3 in our last project (duration: 6 months). I wanna share my experiences with that component library in the following.

IMPORTANT: All information is my personal opinion! We bought the SmartGWT Power license, but we used SmartGWT without commercial training or commercial support. Regard this, when you read my stated CONs!

What is SmartGWT?

SmartGWT (http://code.google.com/p/smartgwt) is a component library for the Google Web Toolkit (GWT). Four different licences exists. The visual components are free (LGPL). Three further licences exists (see http://www.smartclient.com/product). These licences offer several additional features and components such as data binding, a “push”-implementation or Hibernate integration. We chose the Power Edition. SmartGWT is maintained by SmartClient (http://www.smartclient.com/smartgwt). SmartClient also offers commercial support.

Technically, SmartGWT is a wrapper framework for the JavaScript library of SmartClient. The whole architecture is described within the documentation of SmartGWT. To summarize: SmartGWT has a end-to-end application architecture where the client-side is for free and the server-integration is commercial. Of course you can just use the client side of SmartGWT, then you have to implement the server-side integration by yourself. In our project, we used GWT 2.0 and Smart GWT 2.3 Power.


– Many good components (almost everything you can imagine). Look at the showcase: http://www.smartclient.com/smartgwt/showcase. All components are displayed including source code examples.

Verbose documentation and API. Every class has good documentation.

– Support for many technologies and frameworks (Hibernate, JMS, REST, WSDL, Microsoft Excel, and so on).

Good performance. About 5000 data entries are inserted daily into one table. Thanks to “Live-Scrolling”! The initial loading of the web application takes some seconds, but that is no problem of SmartGWT, but a characteristic of every client-centric Rich Client / Rich Internet Application.


– You have to learn a totally new API. You know GWT, you know JPA, Hibernate or JDBC? Does not really matter! You just use the SmartGWT API. That is a problem especially for getting started and for maintenance, because other developers also first have to learn one more API.

Almost no public information available (books, tutorials, blogs, articles, talks at conferences, best practices).

No tutorials for realizing some (at least a little more complex) use cases. [UPDATE January 2011:] SmartGWT EE 2.4 released including much more extensive documentation and a good quick start guide!

Commercial support is expensive. First we wanted to buy support (for some hundred dollars we thought), but it costs approximately as much as the SmartGWT Power license itself.

– Sometimes bad forum support. You get an answer to almost every posted question. But that answer often does not help. They ask you things such as “why do you want to do that”. Or they say: “use our tool and do XYZ with it” three times, although again and again I told them this suggestion does not work. After a few answers to a question the final answer is: “you need training, buy our support”. So you can either buy the support or try to find a workaround by yourself – and that can take a long time because you do not know the internals of SmartGWT and there is no public information such as a book, which you can “ask”.

– Promises to reduce boilerplate code because it automatically does the connection and integration to the database (create, read, update, delete) – that is true. But solely if you do not want to change anything and just use the basic behaviour. If I wanted to change just a small piece, I updated the automatically generated, huge XML mapping files or used setter-methods within the Java Code. If I just re-generated the mapping file, custom changes (e.g. specific WHERE-clauses) were overwritten, too. I could not find a better way. Thus, I do not see any benefit in using this server-side integration of SmartGWT instead of plain Hibernate or JDO and GWT RPC or REST communication. You just have one more abstraction layer to learn.

– Just a wrapper about a JavaScript framework instead of a native GWT implementation (for a counter-example see Ext GWT: http://www.sencha.com/products/gwt). That is no problem, if you just want to use the components. It is tougher, if you want to extend them. (Another myth is a worse performance because of this fact. We did NOT have any performance issues because of this fact)


At first glance, SmartGWT is a gift for you. The components are integrated in your web application easily. Your prototype is realized very fast (with dummy data instead of a real datasource). But the server-side integration is a lot of effort.
I had a lot of problems to solve and workarounds to find. Of course, you also have problems with other frameworks, but you have public information to look at for solutions.

Finally, SmartGWT did not save any development time (in my opinion! Some team members have another opinion and think it saved development time). Additionally, the project cannot be maintained by other developers, expect they also invest a lot of time in the SmartGWT API.

Would I use SmartGWT again?

Yes and no.

The components are great! They are easy to integrate and save a lot of development time. So I would use the client-side again.

The server-side integration is time-consuming and has no advantages for our team. If we had used JDBC, MyBatis or Hibernate for persistence and GWT RPC or REST for client-server-communication, then we would have finished the project with the same expenditure of time. But with some advantages: We know what we do. SmartGWT is one more abstraction level, and that is not an advantage in my opinion. Also, other developers can maintain the web application in the future, because they already know Hibernate or EclipseLink or Toplink (if you know one OR-Mapper, you can use them all).

Finally, I (again: me, not other team members) would use the client-side again, but not the server-side. Paradoxically, SmartClient earns money solely with the server-side stuff or the (proportionally too expensive) support.
SmartGWT is a very nice component library, but maybe the guys at SmartClient should rethink about their business model, if they want to acquire more customers.

Do you have the same expericences? Or do you disagree? Please make a post and tell me…

Best regards,
Kai Wähner

Dont‘ miss my next post. Subscribe!

We don’t spam! Read our privacy policy for more info.
If you have issues with the registration, please try a private browser tab / incognito mode. If it doesn't help, write me: kontakt@kai-waehner.de

  1. Kai, some of your criticisms are out of date and some are.. well it’s hard to see where you’re coming from. I’ll respond to each: No public information available (books, tutorials, blogs, articles, talks at conferences, best practices).No tutorials for realizing some (at least a little more complex) use cases.The SmartGWT QuickStart Guide was released shortly after the version Kai was using (2.3). It contains materials that get you all the way to doing complex joins that allow editing – much further than most tutorials with other products take you, because far more is done for you in SmartGWT. http://www.smartclient.com/releases/SmartGWT_Quick_Start_Guide.pdf Alos, if you look at the Pro/EE Showcase (Kai linked only to samples for the LGPL edition of the product):

    http://www.smartclient.com/smartgwtee/showcase/ You’ll see many examples of tough use cases handled with very little code: master-detail with full load and save to Hibernate, multi-row transactional drag and drop, etc. In other products’ Showcases you’ll typically find read-only samples with canned datasets, or at best, simple CRUD for one enitity with no customization. We feel that SmartGWT goes much farther that other products in addressing tough use cases in samples and tutorials.Promises to reduce boilerplate code because it automatically does
    the connection and integration to the database (create, read, update,
    delete) – that is true. But solely if you do not want to change anything
    and just use the basic behaviour. If you have to change just a small
    piece, you have to create huge XML mapping files (as with hibernate or JDO). So, the benefit is gone in almost every enterprise project.Have to really emphasize this: this is absolutely, 100% percent completely false. The fact that you ended up writing some kind of "mapping files" suggests that you badly misunderstood how the product is meant to be used and did something unnecessary. Isomorphic itself and Isomorphic’s many customers build extremely large, complex enterprise applications and we never end up with weird extra mapping files.We’ve carefully designed the server framework so that you can leverage the automatic CRUD functionality and yet be able to override any part of it easily. Here again one should look at the QuickStart Guide, which explains how you can write Java code to get involved in any phase of the automatic persistence behavior. You have to learn a totally new API. You know GWT,
    you know JPA, Hibernate or JDBC? Does not really matter! You just use
    the SmartGWT API. That is a problem especially for getting started and
    for maintenance, because other developers also first have to learn one
    more API.
    This "totally new API" is what automates away all the boilerplate code
    typical of direct use of JDBC, Hibernate, etc. For example, the following one-liner provides full CRUD connectivity to a
    target SQL database, and automatically provides default component definitions
    for grids, forms, detail viewers and other UI components based on SQL metadata. This can then
    be customized at fine granularity without throwing away any of the automatic behaviors:
    <DataSource ID="contacts" serverType="sql" tableName="contacts" autoDeriveSchema="true" />And, you are always free to drop down to direct Hibernate or
    JDBC usage, in fact, we make it very easy to have SmartGWT call pre-existing Java methods where you are directly using Spring / Hibernate / etc (via DMI – see the QuickStart
    Guide).The only part of this that’s true is that SmartGWT’s widgets are different
    from core GWT widgets, although very little effort is required to learn the differences (it’s
    the same concepts, just different property names generally).Commercial support is unbelievably expensive.
    First we wanted to buy support (for some hundred dollars we thought),
    but it costs approximately as much as the SmartGWT Power license itself.Often bad forum support. I am amazed by this critique. Here are Kai’s actual posts (user KaiW) so you can judge for yourself: http://forums.smartclient.com/search.php?searchid=373665Kai's team declined to purchase a support plan, yet the support team helped him with a number of issues, even delivered a bug fix in 2 days. Second, as far as pricing, we’re typical of other similar plans from competitors. Don’t be fooled by what appear to be unlimited support plans that are actually credit-based.

  2. @Charles:

    Thanks for your extensive comments. I do not disagree with a lot of your post, but remember: This is our experience! Some things you posted may be true, e.g. this one:

    [quote] Have to really emphasize this: this is absolutely, 100% percent completely false. The fact that you ended up writing some kind of “mapping files” suggests that you badly misunderstood how the product is meant to be used and did something unnecessary. [/quote]

    Yes. Maybe you are right! Maybe we did not understand some part of the product.

    But the problems we had to solve were not in any tutorial or guide (by the way: I did not post most of our problems). And the forum support could not help us with some of these problems. So maybe you can do this without mapping files, that is great! But unfortunatelly we could not make it, also if it may be possible!

    So again: this is my experience with the product after one and a half persons worked some months with it (WITHOUT training or commercial support). I do not want to make things worse if they are not, I just wanted to report OUR experiences! To make this more clear, I will add this information to the beginning of the article!

  3. Thank you kai for posting your experience, I found it helpful! And thank you to Charles Kendrick for unintentionally showcasing the difference between trying to help other people with something useful and trying to sell something.

  4. The bizarre quote about money and power wasn’t left by me (obviously).

    Mike, take a look at Kai’s article where it was posted at Dzone – we got to the bottom of his problem and why he thought he had to create “huge XML mapping files” – he misunderstood how the framework was meant to be used in a way that is now prominently covered on the very first page of the QuickStart Guide’s chapter on the server framework.


    Telling people to look at the QuickStart Guide was the right answer in terms of helping people, and the only one that could be given since Kai had not given any specifics about why he thought he had to create mapping files.

    1. I deleted the “spam post” by the anonymous guy pretending he is you…

      Well, also after looking at the QuickStart guide, our developers could not realize OUR use case without changing the huge XML files to add operation bindings. Maybe it is also possible in our (complex) use case, but we could not find out how…

      So my conclusion is still the same as before: SmartGWT is powerful and has great widgets, but if you use the server-side too, then you should always buy the support!

      Best regards,
      Kai Wähner

      1. Kai you still seem to be assuming that you’re going to be generating large XML files to disk, then editing them. But we show right at the beginning of the Server Framework chapter of the QuickStart Guide that there would be no need for a large XML file at all – literally a one-liner is enough.

        The relevant except is right here, at the bottom of this post:

        I should also point out, you can extend the XML descriptor with your own properties, and you can dynamically provide the XML descriptor to the system as well. So even if you perceive a need to put any kind of redundant information into XML (honestly we’ve never seen such a use case), you can easily provide the information dynamically and eliminate that redundancy.

  5. Meanwhile, Smart GWT 2.4 (LGPL and EE) is available. Besides some very good new features such as offline capability or some more powerful components, the quick start guide is much more extensive than some months ago. I really appreciate that!

    Best regards,

    Kai Wähner (Twitter: @KaiWaehner)

  6. I also tried SmartGWT (LGPL version only). I played with the portlet sample and it was easy to embed GCharts inside the SmartGWT portlets.

    But when it comes to database/server connection it was not that easy. There are no samples how to use the datasource with the LGPL version of SmartGWT and since GWT RPC is not recommended I didn’t use it either.

    After 2 hours I gave up and stick to Vaadin. The integration of the GWT chart took some time but the documentation (integrating GWT widgets) helped a lot. The documentation of Vaadin is way better than SmartGWT’s doc.

    Since Vaadin is a server-oriented RIA, database connection is plain Java (JDBC, OR mapper…) and thus easy and communication between GWT chart and Vaadin also pretty straightforward.

    SmartGWT has a huge widget library and it might be powerful in conjunction with its proprietary server stuff. But Vaadin is easier for Java developers using the standard tools. In addition Vaadin’s documentation is much better and you get working results (server-client communication, database access, AJAX client behavior) at no costs compared to the need for the commercial license of SmartGWT.

    1. Hey Dieter,

      I have no practical experience with Ext GWT. But probably, most of my pros and cons are true for Ext GWT, too. You also have to learn a new API, you also have great widgets, and so on…

      One difference is, that Ext GWT is a real Java / GWT framework while SmartGWT is “just” a JavaScript-Wrapper. But this does not matter, except you want to build you own widgets (and because there are so many good widgets, you probably do not have to build your own widgets).

      You should try out both and compare their widgets to decide whether you want to use a component library instead of plain GWT, and then decide which one to choose by comparing especially the widgets and server-integration.

      Best regards,

      Kai Wähner (Twitter: @KaiWaehner)

  7. I enjoy S’GWT day by day! 😉

    Sure, both client and server side require some learning effort. logically. I do not plan to write my own widgets as S’GWT gives me all I want, so GWT compliance here is not an issue to me. Using the declarative power of the S’GWT container widgets I don’t even miss any user interface builder.

    My only issue so far is the initial load of the isc js files. For 99% of the scenarios this is not a big thing, in 1% it is and I don’t know how to solve this. I tried to load only a subset of those files but at the end of the day I don’t think that this is a useful approach. Maybe GWT optimizations are also an issue to S’GWT as it uses JS stuff (SC) rather than native GWT code but so far I do not face any run-time issues (once the isc files are loaded).

    Meanwhile I created a powerful class library, integrated several own Web services, with extended S’GWT controls and really love to think about UI design and workflows, software architectures, re-usability and patterns rather than cross-browser issues, signature/data flattening and structuring, CSS nightmare, untyped, non-namespaced JS, etc.


  8. I’ve worked with the SmartGwt components for the last year, and even though I now have a working app, I’ve spent the last 6 months regretting my choice of components. There is no denying that the data-bound components are handy, but there are so many bad sides to this lib that totally outweigh the good ones, so in the end it doesn’t really matter if the back-end connectivity is simple or not.

    For me, the bad points have been:

    1. The interfaces are totally bloated, disorganised, inconsistent and frustrating. The design of the api is really poor, and this is visible in the vast amount of questions in the forum of the type “what method should I use to do foo?”.
    2. Isomorphic support (paid licence) sucks like nothing else. My opinion is that if you pay for someone to help you, they should help you when you need it. Isomorphic seems to be of the opinion that if someone pays you, they’re suckers and should not be helped, even in the least. Honestly, I’ve yet to report a single bug and get a satisfying answer to my problem. At best they ask you to provide a stand-alone test-case, but even when you do there is very little help coming out their end. As a company, they’ve very much failed to make me want to buy anything of theirs ever again.
    3. The showcase is too limited. At first glance, the showcase looks very impressive, with over 300 different samples. At closer glance, this is all superficial. There are very few good examples of data bound components using JSON, nothing at all on dynamically generated and data-bound forms, and there are several cases where the code in the sample does not render the same behaviour as that in the sample.
    4. As soon as your use-case diverges just a little bit from what is in the showcase, things turn really ugly. I, for example, have a tree where the same element can be present at several places at once. This is the nature of my data, but since the tree component in smartgwt doesn’t allow duplicates, my duplicates are simply removed, which has the effect that my data is incorrectly rendered. The workaround is utterly tedious, with manually generated id-strings and a lot of back-end nonsense to make sure that any changes made to one version of the same object gets propagated to all the rest of the versions in the tree. The resulting code is nothing short of monstrous, and it really isn’t my fault.

    In the beginning I would recommend people to use SmartGwt in their projects, but nowadays I just advise them to stay far, far away. I wish someone had given me that advise a year ago…

    1. Mia, I’m having some trouble believing that you are a real person who has actually used our product. Our competitors have a habit of posting fake reviews.

      My apologies if this is an incorrect assessment, but it would be very simple to convince everyone here:

      1. can you point to just one instance of a standalone test you provided that demonstrated a bug that wasn’t fixed? Because we very often provide overnight fixes for bugs, even if the user reporting it doesn’t have support

      2. if there is any sample that doesn’t work outside of the showcase, congratulations on being the first ever to find it! Can you point out which one?

      3. there’s a huge number of Showcase samples related to dynamically generated and data bound forms – in fact I’m not clear what you could mean by this since all the samples show Java code – so it’s all dynamic already? I’m not sure how anyone could have worked with our product at all and say something like this – could you clarify?

      4. the tree allows duplicate nodes, just not duplicate node ids. On a number of projects we’ve dealt easily with duplicate nodes, I’m not sure how you ended up with “monstrous” code, but I feel pretty confident a simplification was available. If you can share details, I can help.

  9. first thx to all for this very informative discussion.

    i am at the beginning of a very huge project (public, statistical analytical front end). now i have to chose a technology: since i don’t want to write a single line js and or html i ended up with gwt-based frameworks. i made a first prototype with smartGWT (including hand made jpa integration via gwt-rpc).
    the first days of development were pure fun: very fast good looking results thx to the showcase. but when it came to slightly change/ adapt the showcase scenarios the development becomes a pain (so i absolutely agree with mia’s and kai’s critics about documentation and support).
    But especially i agree with “The interfaces are totally bloated, disorganised, inconsistent and frustrating” (since now i made about 5 -“what method should I use to do foo?”- question and the answers were mostly bad).
    one example for this “inconsistencies”: i spend hours to give single widgets the correct size. generally setWidth100(), setHight100() does not the size to 100%. it somehow depends on the widget it self and the parent(s layout) and their size settings – for me it was pure trial and error to get the layout i wanted.

    at this very moment i tend to throw away my prototype and rethink about technologies. any advices where to look? in between i glanced over to vaadin and at first sight the “book of vaadin” differs some how to “smart gwt quickstart guide”.

  10. Hey, thanks for your comment.

    First, you have to decide if you need a client-centric or server-centric approach! Please use Google if you do not know the differences.

    If you need a client-centric web-framework, I do not know any good alternatives to GWT (besides JavaFX 2.0, but that is not released yet), if you want to develop with pure Java. Other alternatives are e.g. Adobe Flex or Microsoft Silverlight, but then you could also learn / use HTML and JavaScript instead of learning another scripting language.

    If you need a server-centric web-framework and want to develop with pure Java, there are two good alternatives: Vaadin (as you mentioned) which also uses GWT-widgets, and ZK. Create a proof of concept with both and decide which one you prefer…

    It would be great if you let us know your experiences and decision!

    Best regards,
    Kai Wähner (Twitter @KaiWaehner)

  11. at first side (read introductions from zk and vaadim) – i would promptly say my choice is vaadin. because vaadins client side is gwt based and mixing vaadin components with gwt components seem to be possible (this was nearly impossible with smartGWT) it may be able to choose the point between server and client centric approach?!

    my guess is that “client centric” scales better with user count (correct assumption?). as i mentioned yesterday it is a public application mostly to present statistical data. an important question to be answered would be what component will visualize the data (probably olap cubes).

    1. Sorry, no edit button in my blog yet. I have to install another WordPress template or a plugin some time…

      The server-centric approach generates all HTML / JavaScript at server side after each request, you have lot more communication between client and server. Server centric programming may be good e.g. for security reasons. One other advantage is that you can use all Java classes without problems (remember: using GWT there is a black list, you cannot use all Java SE classes – because the GWT compiler has to create JavaScript from your Java code).

      The client side approach loads the whole UI to the client at the first start. You have a better user experience because of shorter loading times (exception: the first request). Offline support is not possible without any kind of client-centric (JavaScript) stuff.

      In the end, client centric means Javascript. You can of course also use a server centric framework and solve some client centric problems (every web framework supports at least a JavaScript library such as jQuery), nevertheless. Thus, there are many projects where you can create a good solution with both approaches!

      Personally, I would also prefer Vaadin to ZK. Nevertheless, I recommend you to use both for some hours and code a simple application with them. Then look if the framework offers all components you need. This is one of the huge advantages of SmartGWT and ExtGWT. They have many awesome widgets.

      Best regards,
      Kai Wähner (Twitter @KaiWaehner)

      1. Hello,

        “Personally, I would also prefer Vaadin to ZK. This is one of the huge advantages of SmartGWT and ExtGWT. They have many awesome widgets.”

        I’m precisely trying to choose between Vaadin and ZK and if i rely only on the argument that SmartGWT and ExtGWT have the huge advantage of bringing awesome widgets then i would choose ZK as it also has a lot of awesome widgets too, especially compared to Vaddin. So, i’m very interested in your arguments explaining your preferences and the advantages of Vaadin over ZK (except the licence).

        1. I cannot give any technical arguments why I would prefer Vaadin over ZK because I do not have real project experience with them. I just played with both for some hours.

          One very important aspect is the community of a web framework. In the last year, I have read many articles and tutorials at online portals and magazines about Vaadin, it is very present at IT conferences and books are available / in work. Some interesting addons are available, e.g. a Spring Roo plugin. Nothing of this is present for ZK. The only thing I read or hear about ZK is new release announcements several times a year.

          Another very important criteria besides the community is the availability of good widgets. Thus, if you say, that ZK offers most or all widgets you need for your project (and Vaadin does not), then I would suggest you to create a proof of conceot with ZK, If everything is fine, use ZK for your project, otherwise try Vaadin.

          Best regards,
          Kai Wähner (Twitter: @KaiWaehner)

  12. for our project we came to a decission: we will use pure gwt.
    main reasons are:
    – all big widget libraries seem to have some lockin effects (unable to mix them, to mix single widgets?!)
    – on what i have seen so far pure gwt let me choose how server/client-centric the app will be (i only have to put more/less logic to client/server package)
    – there are single widgets / small widget libraries that could easily integrated with gwt
    – in the long run we will be able to create every widget we want on top of gwt(we don’t need very fancy prototypes)

    are there any flaws within that list or that decission at all (beside subotimal english :-))

  13. Hey,

    well, you are right about the locking effects and the flexibility regarding client / server communication. None of your states is wrong!

    Of course, you also can create every widget by yourself, but here you have to be aware that this is much more effort than using the available, powerful widgets of SmartGWT or ExtGWT.

    As we have seen, there a pros and cons for using a component library. You have to decide what is the best solution for your project…

    Best regards,
    Kai Wähner (Twitter: @KaiWaehner)

  14. Good article with very interesting comments. I have built a small (free) application using SmartGWT LGPL (v 2.5 nightly build). I have a mixed experience with the product. I’m sharing my experience here.

    The first thing I want to say is that their support is among the worst I’ve ever experienced. You’ll know what I’m saying if you browse through the first few posts on their forum. You’ll also notice a significant number of posts with absolutely no response at all. The moderator of the forum (screen name Isomorphic) is shockingly rude. I’m not saying this from personal experience, but the way I see other members getting treated on the forum. If you happen to even utter a word against their product or service in their forum, then be prepared to get publicly ridiculed. After going through few such posts, it made me extremely reluctant to post anything in their forum unless I was 200% sure that it was a bug, and even then, sometimes there was no response or help. The support aspect has made me reluctant to buy their commercial offering.

    Otherwise, they have a good product with great widgets (at least as far as the client side is concerned) . But once you divert from the standard use cases presented in their showcase, things can become excruciating frustrating, especially if you are without commercial support (like me). I have wasted countless hours trying to overcome bugs and issue for which I did not get any response in their forums.


    1. My experience is the same as yours, YTS. Communication from Isomorphic is surprisingly rude, condescending, and impatient. It seems that all of their existing documentation is flawless, answers all possible questions, and is easy to find; asking questions is just a waste of their time.

      After looking at all of their wonderful widgets I was ready to plunk down the money for the pro license… until I started dealing with their people. It took a lengthy e-mail conversation to convince one of their sales/support people that there is a problem in one of their samples; I had to actually link to a post by them in their own forum to prove it to him after repeatedly being told that I was wrong.

    2. YTS, Isomorphic Support receives a steady stream of compliments and thank-yous from our users. Just this morning I count 6 so far – one user said 40 virgins for you! which gave us a nice laugh.

      If someone disparages our product, we will indeed defend it, and if they are wrong, generally we’re going to politely tell them so.

      In contrast some of our competitors simply edit their forums and delete anything negative about their product.

      We never do this. We feel we are doing the right thing by engaging in a civil, spirited debate.

  15. We used SmartGWT Pro in a customers project and we really liked it. Yes, there are some aspects which were not easy to learn (especially the server-side features), but all in all the result was good. The customer now likes the application and we would choose SmartGWT again.

    At the beginning we had big problems with the data source concept. Because of this we implemented our own custom data sources (jpa with database). After doing this everything worked fine for our use cases.

    Again, SmartGWT is a powerful framework but compared to other commercial frameworks the documentation IS definately bad. The first weeks are very hard to learn because of this documentation lack. After some time you learn the good and the “bad” things of SmartGWT.

    You should definately have a look at SmartGWT.

  16. I use SmartGWT right now, in many different small application in our 100+ person company.  The widgits are very well integrated.  And of course the showcase is brilliant.
    I’m an experienced java developer and I would likely never need the server side suite.  So I am content to use GWT-RPC.  I’ll probably tackle learning command patterns next before trying to do anything else.  I love sql and would hate anything that got in my way of manipulating the data directly.  Of course, we are a small company after all, I manage the servers, etc.  
    Again, I highly recommend SmartGWT.

  17. I agree that I woul never EVER use the server side components again, and I would think very hard about using the client side again.  There are so many other options out there that I’d rather just leave these guys and never look back.

    You mention the paid support a few times.  Don’t buy it.  The answers you get for the premium support are just as arrogant andcondescending, and they still respond with answers like “why do it that way?” or “you’ll have to prove it.”. A member of my team has found no less than 10 bugs in their API, which they promise to fix in nightly builds, but don’t always follow through on.

    Let’s talk other extras too. The charting package or analytical package.  Guess what, for several hundred dollars you get a charting package that 1. Doesn’t graph negative numbers, 2.Doesn’t allow for customization of axis labels.  Really useful right?

    I have been using this product for almost aIyar, and I would have abandoned it given the time for a rewrite.  Please if you’re reading this stay away from Isomorphic.  Like theauthor said, it looks like a gift, but it is far from being that.  You will do better with another library or even, dare I say it, Flash!

  18. thnak you for fast replay, i dont know if it is a good place to ast such question or not ?!  i need a complete tutorial about smartgwt lgpl and i want to ask you as exprienced java developer what is the best , secure , fast jee fremwork , again thank you

  19. Hi,
    thank you for your post. I’ve just started to use smartgwt. There are two questions that I cannot find an answer for:
    1. is there a posibility to add an image to a shape(DrawOval for instance)
    2. Can I crop an image?
    thank you

Leave a Reply
You May Also Like

When to use JavaFX 2 instead of HTML5 for a Rich Internet Application (RIA)?

These days, we are starting a new project for realizing a Rich Internet Application (RIA). One of the first questions is: Which technologies and frameworks shall we use? The backend will be Java or another modern JVM language, as we are mainly experienced Java developer. In most use cases, we also prefer web frameworks, which allow to code mostly in Java, as many of us just have basic knowledge regarding HTML and JavaScript. A decision has to be made for the upcoming project: Shall we use HTML5 or JavaFX 2 for realizing the web client? We took a look at pros and cons, which are listed below in this blog post.
Read More