Tag Archives: GWT

NetBeans 6, Beta 2 ….

Has been released.  Josh Marinacci says he's dumped all old versions of NetBeans AND Eclipse from his system.  Hmm, interesting.  I'm not sure I'm ready to go that far, but I *do* think it's time to give NetBeans another look (I downloaded Beta 1 and played around with that, and it looks pretty nice).  And I'm pretty jealous of all of the disk space Josh was able to free up with his bold move.

So, I was trying to think what I would miss about Eclipse. I thought maybe I would miss the GWT Designer, which does graphical layout for GWT apps.  No, I don't do a lot of GWT development, but it's nice to have the flexibility to do so easily (and I happen to be doing some GWT work now).  But alas, it appears that NetBeans offers such a thing as well.  I'll have to check it out (and I won't feel at all bad about having spent $39 for a year of the GWT designer; it was totally worth it!).

Lots of cool Java news this week!

JavaFX plugin, GoogleGears, and GWT

I just ran across this article, which tells how to use Eclipse for building JavaFX.

And, GoogleGears is all the rage today too.  GoogleGears is a browser extension that lets developers create web applications that can run offline.  VERY cool.  It was rolled out at the Google Developer Days (today, but sadly not offered in Ann Arbor).

Oh, and I almost forgot to mention that Google Web Toolkit (GWT) version 1.4 beta was released too.

Here's Bruce Johnson's (he's the tech lead) blog on the changes:


All in all, a pretty good week to be a Java developer, I think.

UI Smackdown: Session 4

Combining Flex with other technologies

Is it possible to combine Flex with other technologies?  We saw James Ward build a Flex front end for a TurboGears app at CodeMash.  What else makes sense? Those are the questions that we tried to answer in the last session that I attended at the UI Smackdown.

Flex runs on the Flash VM, which has a small memory footprint. It's possible to build a GWT programming model for Flash.  This would generate ActionScript instead of Javascript. That's interesting.  The goals of such would be to reuse components so that you don't have to learn a new interface, leveraging the Flex framework (e.g., tab navigation, etc.).  You would want to use the GWT Compiler, which is written in C/C++.

This would provide good discipline in Javascript, in terms of using libraries and namespaces.  It would improve searchability.  This would be heavy on HTML, rather than AJAX.  One downside of AJAX is that it's not spiderable, hence the reduced searchability.

This is an interesting area which certainly requires more thought. It sounds like James Ward IS thinking in that direction and it will be interesting to see what Adobe comes up with.

UI Smackdown: Session 1

Web App Limits: Real World Experiences

A group convened a session to talk about web applications, and where they break down with real world experience.  The limitations were noted as:
1. Javascript requires testing in many different browsers, but the GWT strives to solve this problem
2. May experience CSS challenges with GWT
3. Limited browser support for multi-media and vector graphics (resulting from lawsuits between Apple and Microsoft?)
4. Drag and Drop onto a scrollable pane generated some headaches for those who had used GWT

The recommendations and observations included:
1. Use Javascript for fast prototyping and then build in GWT once the interactions are discovered
2. Flex can talk to AJAX apps
3. Controls in Flex are builg using vector bitmaps.
4. WPF and Flash allow designer to build whatever they want and the programmer can use it
5. Can encrypt Flex and send over SSL.
6. Can unitttest classes using Flex
7. Javascript, Flex, and WPF build on strengths of the designers
8. Innovation in the browser has stagnated.  By adding in elements other than pure Javascript, Microsoft and Adobe (and others) are able to innovate more freely.

Google Web Toolkit Designer
A great tool for building apps using GWT

It’s a busy week in Ann Arbor!

I’m still trying to finish up my blog from my visit to Microsoft last week (and from the Michigan Celebration of Women in Computing over the weekend), but I wanted to make sure that I mentioned the busy week that we’re having in Ann Arbor this week.

James Ward, Flex evangelist from Adobe, is coming in from Oklahoma City to present Flex both Tuesday night at the Ann Arbor Java User Group (www.aajug.org), at 7:00 (note the earlier time!), and on Wednesday night at the Ann Arbor Computer Society (www.computersociety.org) at 6:00 pm. While James has sent me the same abstract for both nights, he’s said that the Tuesday night event will be more Java-focused and the Wednesday night event will be more about the technology. There’s not much overlap in attendance at the groups but since I’m planning to attend both nights, it will be great to hear something different the second night.

Here’s the abstract:

Sexy Web Apps with Java, Mozilla Tamarin, and Flex

In this session James Ward will do live demonstrations and write code to show how easy it is to build sexy web apps with Java, Mozilla Tamarin, and Flex. The session will cover the programming model, Java Remoting, Pub/Sub messaging & JMS integration, Data Synchronization, Hibernate integration, charting, cinematic experiences, and media integration.

I’ve seen James demo some incredible stuff with Flex. He built a TurboGears widget with Flex at CodeMash. He demo’ed a nice bookshelf photo application there as well (using photos from CodeMash!). And, he showed a demo at the Java Posse Roundup that used transparent pages from an old medical textbook … wow! To be able see the transparent pages turn, and to be able to see through them to the previous page is REALLY cool, and really does give you a flavor for the compelling interfaces that can be built with modern technologies.

We’re really making the best of James’ time while he’s here. In addition to the evening events, Adobe, Microsoft, and SRT Solutions are presenting, “UI Smackdown 2007: Using GWT, Flex, and WPF”. This is a one-day workshop to learn more about all of these toolkits in an open spaces type of environment. We’re going to start off by presenting a quick overview of each, and then the participants will be breaking out into groups of their choosing to work with the various toolkits. The $90 registration fee includes continental breakfast and lunch. There are still a few slots available, so if you still want to sign up, do so right away so that we can make sure that we order enough food!

UI Smackdown 2007 Early Bird Expires Today

If you’ve been planning to attend the User Interface Smackdown 2007 event to explore GWT, Flex, and WPF, today is the last day to get early bird pricing. At close of business today, we’ll be updating the pricing, so if you’ve been planning to attend and have just been procrastinating, the time is now.

We’re also getting really close to reaching capacity for the event. Unfortunately, the “Buy now” buttons for Google checkout don’t seem to support limiting quantity, so we’ve been manually watching registrations.

On a more technical note, I’m going to have to look into tying into the Google checkout API, I think. My wish list for Google checkout includes support for limiting quantity, being able to specify how many items to buy at a given time, and being able to add a comment field, so that people can manually add information about who they are registering. That’s probably a bit much to ask for in the Buy Now button realm, but hey! Anyhow, I’m looking forward to diving into the Google checkout API to see what we can do with it.

And, back on topic: register now if you’ve been planning to attend. Hope to see you there!

Registration link

UI Smackdown 2007 Event Details

UI Smackdown 2007 Explained

Is this wrestling or deciphering software technologies? Definitely the latter!

A few people have asked me about the name we chose for our user interface event on April 4, which will include Flex, GWT, and WPF. Honestly, the name was proposed by one of the participants, and we couldn’t think of one that we liked better!

This will NOT be a confrontational event, and I hope that no one has signed up to witness the World Wrestling equivalent in the software world. Instead, like CodeMash, the idea is to bring together people interested in different technologies and learn an appreciation for what each one provides. We think that this is a huge win for the vendors involved, since it offers an honest glimpse into the perspective that programmers bring to technologies as they evaluate them.

I’m really looking forward to the event. I’ve seen quite a bit of Flex and it’s very impressive. I’ve seen enough WPF to find that compelling as well. GWT sort of serves a different purpose, but we included it because it’s a different approach to the same problem: how do we build user interfaces that customers can use, but that programmers can maintain and understand.

If you haven’t signed up yet, but have been planning to, the time is now (we had some glitches with our registration page, but I moved it to a different site and I think it’s all working now; if you have problems email info@srtsolutions.com and we’ll get you set up). We have had a great response, and we may end up cutting off registrations. The early bird deadline is Monday (March 26), and the fee through Monday is $75. After that, we’re raising the price to $90, but with the rate at which we’re getting signups, I may end up closing registration before we even get to that point. And from my perspective, that’s a VERY good thing. If we need to choose a larger venue for a future event of this sort, that’s just fine by me!

User Interface Smackdown 2007

Explore Google's GWT, Adobe's Flex, and Microsoft's WPF for creating user interfaces

Registration is now open for the User Interface Smackdown 2007, being held April 4, 2007 at the Ann Arbor ITZone (Spark Central). The user interface toolkits that we will discuss and work with include (at least) Google’s GWT, Adobe’s Flex, and Microsoft’s WPF.

I’ve had a lot of fun doing Open Spaces events that Bruce Eckel has hosted in the past year. I exposed Bill Wagner (my business partner and co-founder of SRT) and our consultants to Open Spaces at CodeMash and they all enjoyed the experience as well, so we decided to start doing them locally, and we hope to do about 1 per quarter. Hopefully we will have the next one planned by the time that this one takes place (teaser: we already have some ideas in the works).

We believe that these events benefit the developer community. Not only are they an efficient and interesting way to bring timely knowledge to programmers, but they also bring the community together in a way that fosters continued communication and builds community. This helps everyone.

We believe that innovative user interfaces will be a key differentiator for software offerings in coming years, and learning how to use modern toolkits to build them is essential. We hope that we have a great turnout for this event and that it provides us with the motivation and interest to do more of these in the future, on different topics.

Cost for the event is $75 before March 26, or $90 after March 26 (and at the door, if space is available). Registration also includes continental breakfast and lunch.

This event is sponsored by Adobe, Microsoft, and SRT Solutions.

Hope to see you there!

Java Posse Roundup: Day 3

Thursday, March 8

By Thursday, people were really getting the knack of open spaces conferences. Those who had held back in earlier days were right in the thick of things at this point. People were resisting the urge to lecture, and getting into the collaborative exchange of information that really gives Open Spaces its edge.

The first session of the day, for me, was on UI Design. Joe reminded all of us that it’s a huge mistake to have our data model reflect the UI design, and vice versa. Instead, it’s important to really drill down to what the user needs to do, and solve that problem from a user interface perspective (and to solve the data storage problem in a sound, but separate, way. Nods were given toward OmniSoft’s Graffle product, which sadly I can’t use because it only runs on the Mac.

Next, I attended a session that Tor had convened on nice looking fonts, typography, and pretty user interfaces. This was a bit out of my area of interest, and I had actually thought it was going to be a different session. I hung around for a bit and learned some things about font rendering (like that Java has its own font rendering engine, that Apple uses bitmapped fonts to ensure consistency in scaling, and that fonts look fuller on Macs and PCs than on Linux). I also learned that there’s a different gamma setting on PCs than Macs, by default. At some point, I realized that while this was interesting, I wasn’t really contributing and my interest had waned, so I exercised the Law of Two Feet (a tenet of Open Spaces).

The Law of Two Feet is “uncomfortable” to exercise until you get the hang of it. The idea is that it’s not only your prerogative to leave if you are not interested or participating in a conversation; it’s really your duty. The very presence of a bored or disinterested party brings down the energy of the group. By leaving, the overall energy increases because only those who are REALLY interested are in attendance. I probably would have left sooner, but that this session was in the lower level room and it was pretty comfy down there … complete with couches! Anyhow, I did leave and got some tea and relaxed until the next session. I could have joined another session in progress, but I decided I needed a break instead.

The last session of the day was on the GWT, and I was really interested in that. Robert Cooper has written a book on GWT, GWT in Practice, and he has an refreshing, pragmatic perspective. While he’s clearly a power user, he’s not afraid to say where Flex is stronger, and where GWT and Flex, working together, might offer some advantages.

GWT does play well with other Javascript libraries, like Scriptaculous, Yahoo UI, etc. More GWT wrappers will be available soon as well. Mostly, the toolkit works great for replacing desktop apps with web apps.

I have a friend who writes a lot of server side code and I pinged him when GWT was first released. He jumped on the bandwagon and has been effusive about it ever since. He loves GWT and finds the model very convenient.