Ryan Dewsbury

author
Greenhorn
+ Follow
since Nov 07, 2007
Cows and Likes
Cows
Total received
0
In last 30 days
0
Total given
0
Likes
Total received
0
Received in last 30 days
0
Total given
0
Given in last 30 days
0
Forums and Threads
Scavenger Hunt
(keep public parts private until JForum day)
expand Ranch Hand Scavenger Hunt
expand Greenhorn Scavenger Hunt
Moderation Tools

Recent posts by Ryan Dewsbury

It looks like chapter 8 will be released as a shortcut in a few weeks.
Flash can do some fancy graphic things that are not possible with JavaScript. It is really the only option for things like media players, advertisements, and games.

However I've seen some use of it as a front end for non multimedia applications usually as the front end for a Flex app. Yahoo maps is a good example of this. In my opinion this is not the way to go, compared to Ajax, for several reasons. One, flash is backed by one company while Ajax is based on web standards. It's unknown how its marketshare will change, especially with Microsoft pushing Silverlight. Two, it uses custom controls for everything. These controls will look slightly different from your OS controls, this is bad for user experience. Ajax apps use the browser's basic controls as a foundation and these are typically the same controls users find throughout their OS. Three, as Lombardi says, flash is still a plugin and does not have the same distribution as web browsers.
10 years ago
GWT
You can find some of the tools available for use with GWT here:

http://code.google.com/webtoolkit/tools.html

I've found that using Eclipse pair with GWT's hosted mode browser is a great development environment.
10 years ago
GWT
I wouldn't say that GWT does what JSF does. JSF tackles some hard problems with developing application views that are generated on the server. This is a really hard problem because with every action the view needs to be rendered and transferred to the client. Models for creating user interfaces have been around for a while but web user interfaces, being generated on the server, are inherently harder to build and require a solid infrastructure like JSF.

Applications build with GWT take a different approach and avoid the difficult problem of building interfaces on the server. They are thick clients. Like desktop Java clients. They have their own internal architecture that is decoupled from the server. They contact the server less than a traditional web app.

You can think of GWT apps as sharing the distribution benefits of web apps while sharing the feature rich capabilites of desktop clients.
10 years ago
GWT
George, very much so.

It's mostly client side and it scales much better than many JavaScript frameworks I've used.

I've used it on the server for GWT RPC. The RPC implementation scales well. I've used it on a single server serving about 300 calls per second with low CPU.
10 years ago
GWT
It depends what type of applications you want to build.

Although JSF apps sometimes fall into the category of traditional web pages this isn't necessarily a bad thing. Many web sites/applications don't need anything more than this. If you're adding Ajax to JSF you are still maintaining the server side template generation- the overall view architecture is still JSF.

GWT does not use server side template generation for its architecture but instead is run completely in the browser. The application communicates to the server through API's which are typically XML, JSON, or GWT RPC. This is a newer model for web application design which performs better and gives a good user experience.

I hope this answers your question.
10 years ago
GWT
All three are great for user interfaces. I'm sure you can create equally good UI's with any.

GWT however is in a different category. Although it does do Ajaxy user interfaces it is more than just a user interface library. It aims to provide many tools to bring real software engineering to Ajax applications. I think it accomplishes this well.

If I were to draw a sketch it would simply be three columns, one for each technology. Each would have a box in their column for user interface. GWT would have additional boxes for:
- server interoperation (HTTP, XML, JSON, GWT RPC)
- internationalization
- code obfuscation
- code optimization
- automatically cross browser (even the code you write)
- unit testing
- eclipse (or any Java IDE)
- modularization and java organization/OOP
- easy application versioning
- performance (image bundles, caching considerations)
- code generation

There's quite a bit. Also the GWT engineers are great and constantly working on improving the compiler which means your code automatically runs better with new releases.
10 years ago
GWT
Which free tools in particular?

JavaScript frameworks?
- GWT is a compiler making smaller, faster, and browser independent JavaScript .

Java front ends?
- GWT runs entirely in the browser relieving the server from generating new HTML for each HTTP request. Much of the application state can move to the browser letting the server concentrate on the application instead of rendering.
10 years ago
GWT
Both GWT and JSF aim to provide a user interface for a backend. You could mix the two by having GWT modules run within JSF pages. The JSF page would be generated on the server and the GWT module would run on the client once the rendered page is downloaded.

The disadvantage to mixing the two technologies is that you have a fairly substantial barrier between the two sets of code: one runs on the server and the other the client. So you need to use web technology, XML or JSON, to communicate between the two. It is probably easier to use a GWT RPC servlet on your server instead of communicating directly to JSF.

If you're starting a new project I would recommend choosing one technology over the other. I would side with GWT since you can push quite a bit of state to the client side making server performance better and at the same time decoupling the client application from the server.
10 years ago
GWT
I've had great experiences with GWT. But I never became a great JavaScript developer. GWT was a huge help in forgetting about JavaScript issues and moving forward with application development.

GWT does support java.lang and java.Util. This gives you the basic Java types including collections and exceptions. Number and date formatting were added with the 1.4 release and I'm sure more support will arrive. One thing to note is that the code must run in a browser so supporting more complex Java packages like database drivers isn't possible.
10 years ago
GWT
For the browser question. GWT does a great job at handling browsers differences. I write and test on a Mac in the safari enbedded browser and the application always works in Firefox, IE, and Opera.
10 years ago
GWT
Blueprint is a great app that's built with GWT. Here's a demo: http://www.youtube.com/watch?v=-f-YC_qaQ-8

Google uses GWT for Google Checkout, Google Base, and Google Mashup

Others include:
http://www.groundhog.com.au/epo/
http://www.dotemplate.com
http://www.queplix.com
http://www.portfoliodirector.com
http://beta.contactoffice.com
10 years ago
GWT
The plugins are helpful for getting things started. However, it's pretty simple to get a GWT app running in eclipse (in about a minute): http://code.google.com/webtoolkit/gettingstarted.html#NewEclipse
10 years ago
GWT
Hi Josh,

I'll try and sell you on GWT and my book.

First, are you sold on Ajax applications in general? They have the advantage of giving your users/customers a better user experience than they would get on a traditional web page (no waiting for page refreshes). They can perform better than traditional web application since they don't need to load as much data, can reduce the number of server round trips, and can move some of your application state to the browser relieving your server load somewhat. They're also easier to deploy than desktop applications with less dependencies.

Ok, now you want Ajax for your client side. If you know Java and want something that's easy to learn you should use GWT. GWT provides a library that lets you use the Java tools you're familiar with (JUnit, Eclipse, Tomcat, etc). You can also use the Java software development techniques you and your team are comfortable with.

If you already know JavaScript you may need some extra reasons to use GWT. GWT is not a code generator- it doesn't just take your Java and churn out equivalent JavaScript. GWT is a full, complex compiler. It takes your Java converts it to an abstract syntax tree (AST), optimizes the code, cuts redundant code, then converts it to a JavaScript AST and optimizes and cuts some more. The result is a very compact, and very fast JavaScript application. Faster than what you could do by hand. It would be very hard to make sweeping optimizations across an entire JavaScript code base. Also, when using JavaScript you want to maintain code readability, which sometimes contrasts with the need for performance. I've tested the Dojo mail sample and the GWT mail sample to compare performance, both of similar complexity and the load time alone was 200 ms for GWT and 6 seconds for Dojo. You should also check out this post for an example of a teams experience with GWT vs JavaScript: http://googlewebtoolkit.blogspot.com/2007/10/lombardi-blueprint-built-with-gwt.html

Ok, so now you're thinking that GWT may be pretty good. Should you buy my book? You can find a way to get started with GWT on their website. They have a few sample applications and documentation for their library. This is all I needed to get started. However I've been working with GWT for a year an a half so far and have learned quite a bit more. You need to put the toolkit documentation in context. I put the user interface library in context by overviewing it's use in many applications in ch.2. I should the many techniques of communicating with a backend using the GWT tools in ch.3. I show you software engineering techniques for GWT in ch.4. In chapter 5 I show advanced techniques on using the toolkit effectively including server performance considerations. For just this first half you get quite a bit of GWT experience in about 300 pages. The second half goes into detailed application development case studies on 5 sample applications where touch on just about every way that GWT can use a browser and interact with the web. It's a great book and it has something for every stage you're at when you learn GWT.


Hope this helps!
10 years ago
GWT
It's partly like Swing. It's lightweight and has a user interface framework.

It's specialized for creating Ajax applications. You write your client side application in Java and GWT compiles it to JavaScript so that it runs in all of the popular browsers (Firefox, IE, Safari, Opera), without being dependent on a JRE. Ajax applications have easy deployment.

It's usually compared to other JavaScript libraries, or server side view technologies like JSP. Compared to these it brings Swing-like development to web app interfaces. This means you can build your applications with Java tools (eclipse, refactoring, performance testing, unit testing etc).

It's easy deployment through Ajax with real software engineering through Java.