Customer Reviews

The Definitive Guide to SWT and JFACE

5 star:		(7)
4 star:		(2)
3 star:		(1)
2 star:		(2)
1 star:		(1)

 

 

I won't be needing another SWT book in a while... "The Definitive Guide to SWT and JFace" is indeed definitive and proved to be a nearly perfect choice for starting my journey inside Eclipse's much hyped GUI toolkit(s).

The book starts from scratch, explaining the history and motivation for a different approach to a GUI toolkit (SWT's native peer widgets vs. the emulated widgets of Swing, etc.), proceeding to your typical Hello World app with a single window and a single label, and ends up covering most everything I can think of needing to build even a relatively complex GUI using SWT and JFace. The book is a huge tome, partly because it includes listings of all the various methods provided by the classes introduced along the way. On one hand, it's a good thing because the book is pretty much all you need (i.e. a decent replacement for Google;), and on the other hand, the book would be a lot more pleasant to read if you'd drop a few hundred pages...

One thing I specifically liked about the book is that the authors have done a good job employing screenshots where needed -- especially in the chapter about layouts.

I'll definitely recommend this book for anyone looking to learn SWT. I'm not really a GUI developer (only having done Swing for personal stuff) and the book works for me as an introduction, tutorial, and a reference.

This is the second book that I have read on SWT. The other was Addison Wesley's book "SWT: The Standard Widget Toolkit", which is in the Eclipse series. That was a short book that flew through the topic. This is a much more in-depth work.

Both books share the same introductory style. They walk through the toolkit from front-to-back and demonstrate each concept and widget by showing code and screen shots. Each book suffers from the same long term problem in that it cannot be used as reference material since neither book provides an appendix that would serve that purpose.

That being said, I still prefer this book because it is much more in-depth and presents a shallower longer learning curve than the Addison-Wesley book.

Much of the beginning chapters in SWT are simply API listings - WORTHLESS! I've got those online...don't need them in a book, especially since they are not as complete as the JavaDocs. Otherwise, not bad. I'm looking for better...

This is an excellent book for both the beginner and the professional developer. If you need to write an application and are planning to use SWT but are not a guru, you will want to get this book. It does a great job of explaining SWT, what it is, why it is that way, and how to use it.

Each section of the book provides a topic for discussion, a code example and a complete description of all the classes and methods used. I particularly appreciated the code examples and the tips for real world implementation. The code is clean, complete, and easy to understand.

I found this book easy to read. The author interspersed just the right amount of theory, history, and commentary to break up the details and keep me interested. It is obvious that he has a comprehensive understanding of the subject matter. The surprising part is how adept he is at communicating this knowledge to the reader.

Having being treated to a text called Windows Forms Programming for C# by Chris Sells in late 2004, and considering that's pretty much the closest book in spirit in terms of covering a high-level Windowing API and is relatively well-known, I'll go right ahead and use that as a metric:

I am surprised to find no coverage of SWT and Java 1.5's threading abilities. I wanted to see a coverage of how to handle long-running worker threads that must call delegates that run on the UI-thread (like a web services caller threaad telling the gui-thread to update the progress update bar to show 75% completed). I wanted to see coverage on how to send events information back and forth between GUI thread and the worker threads. It's one of my favorite chapter in Sells' book because without it it is very difficult to write a responsive app. This is criticial in this day and age with the decent amount of web services and distributed computing being used in Intranets and Internets. If Harris and Warner are willing to write an extra chapter on this very topic, I would be greatly in their debt. We are all waiting for this chapter! I guess some of you will say, wait for Doug Lea's next book, but I trust Harris/Warner to get to the point faster and better--and stay on topic (I am not sure if Doug Lea would bother with SWT). I am hoping there's an answer to this, because I need to use this asap.

There are some other surprises I find distasteful: data access and binding of data recordsets to grids are no where to be found.

These are the main reasons why this book gets a four star. Because people like me are spoiled.

Anyway, back to the book review:

Real-world cross-platform development is a tough subject. If you ask most people, they'll relunctantly say the best way to go about it is to write platform neutral c++ model/controller code and write the view code in Qt or Gtk/MFC or WinForms/Carbon or Cocoa. Nasty.

It goes without saying most small development shops simply can't budget serious competence in one, let alone three major GUI frameworks. This is not counting all the trouble you have to go through to evaluate count-less so-so [for one reason or another] libraries (wxWidget, MainWin, Swing, OpenStep API, Flash, Mozilla) just to arrive at the point where you can clearly say aha, I really want MFC/Carbon/Qt after all.
[And let's not even get into strictly system programming libraries, for which there are several dozens on the sourceforge galaxy alone.]. So for light work, where you aren't trying to please 500 million users right away (Internet Explorer, Outlook Express) or even 200,000--you really want something like Java 1.5+SWT:

> One productive language.

> One well-supported effort to map a common gui api to all major windowing systems while preserving native looks.

> A quick build that produces three executables. One for RedHat Linux. One for Mac OS X. One for Windows NT 5+.

Which is why I am really happy Sun and IBM is trying so hard to make this option happen. I build small softwares for a relatively small audience. With IBM's contribution of SWT, all we need now is a good text that cover it thoroughly--from the perspective of developers--not the library writers. The Definitive Guide to SWT and JFace gives you just that.

At times, I can see how some of the other reviewers might say, "It's just table listings rehashing documentations", and if you compare this book to Chris Sells' book you may wonder the same thing--but I think it's still an excellent try and the authors add something to the docs. I'll point out a few examples:

* In the "Selecting Files for Open and Save" they went out of their way to write the correct version of how to handle over-writing an existing file. Hey, just imagine if the authors said nothing... ;-)

* Throughout the book they document what the behavior will be if you did something undocumented: they'll mention when you shouldn't subclass SWT; they post questions to the eclipse group to clarify some of the bad decisions that had to be made and they tell us what we should do about it.

* They explore some patterns they expect real world programmers will likely try (like Decorations, which is like a half-implementation of MDI), and warn you ahead of time what you can expect to find or even whether you should use it.

The best part about them adding a bit of details is that you'll likely dig through the MSDN with Sell's book (which is not a bad thing), but you'll probably have everything at your finger-tips with Harris/Warner--so is it a bit wordy? Is it too referency? Maybe--see for yourself. :-)

This is a great book, and I wouldn't hesitate recommending it. It's a key to a world of cheaper better cross-platform development--walk--no run to your bookstore and get it!

Java has two major families of widgets. The first was AWT. But it suffered from many drawbacks. The second is Swing. Much nicer. But still slower than native applications. And when native GUI libraries change, you have to wait for someone to explicitly code in these changes into the Swing library.

The authors show here the alternative of SWT. It grew out of Eclipse. But SWT was so well received that it now ranks as an independent effort. The length of the book is a reflection of how SWT is a full graphics library. Anyone who has dealt with any other graphics library will be unsurprised by this. The nitty gritty of going through and explaining all the widgets. I am not going to attempt to cover these. Except to say that if you are already programming in AWT or Swing, then, roughly, once you understand SWT, you should be able to quickly convert to the new classes.

Another reason for the book's length is that there are many code listings. Good for learning. But a lot of these are entire programs in their own right, complete with "static void main" entry points and numerous import statements. Nice for users needing runnable examples. But you can well imagine what all the necessary boilerplate does to the text's heft!

The book also offers JFace. An elegant abstraction that can be used on top of SWT. If you are learning SWT, then it might be easier to skip JFace on a first reading. After gaining fluency in SWT, consider adopting JFace to ease future development. A purist might say you should try it all together from the start. I demur. SWT has enough raw material to keep you busy. Pragmatically, attend to it first.

If your main question is how to place widgets on your screens, then this book is excellent. But if, however, you would like those widgets to actually trigger events, then this book is a damned disappointment. They have a general chapter on events but for widget after widget, their examples show you how to place the widget on the page but not how to get its events. You can write code to trigger events but try to do something useful with those events and you will be greatly disappointed.
Also, if you were hoping for some guidance or examples on how to use the 'asyncExec()' or 'syncExec()' methods, you will be disappointed. There is nothing. So, if you need anything beyond the basics, don't waste your money.

if you are looking for something to walk you through widget by widget..holding your hand this is your book . Excellent reference and very clear structure.
Good to have by your desk when you need to look up something and dont like reading javadocs from the source ...

This book is a reasonable introduction to the APIs to create and use SWT and JFace widgets. It will not help you get much beyond the simple examples in the book. Most of the book recapitulates the JavaDocs that are available online. While you can certainly get started in SWT and JFace with this book, I prefer two other titles for that purpose: Professional Java Native Interfaces with SWT/JFace (Programmer to Programmer) and SWT/JFace in Action: GUI Design with Eclipse 3.0 (In Action series).

Whichever book you choose to start with, you will need more. I am not aware of any good resources beyond the beginner level. I had to learn by experiment how to fit the event model into an architecture, how to use it with large sets of graphical elements, and how to communicate data among the parts of a program when you get bigger than the tiny tutorials in the book.

The book is full of mistakes and outdated old eclipse version, which it uses. I bought it and I regretted by the fact written by the English Major person not at least computer science major at minimum.

I regretted I bought it.