Everybody who is interested in the web and smooth user experiences is interested in AJAX.

Games are cool because they are popular and no one asks you why you wrote it.

Okay, some people do but they clearly do not get the point.

1. fits in your pocket
2. contains in-depth description of the html taglib tags that even the big brother of this book is missing
3. very handy to flip through and finds Struts things extremely quickly
   I have something like 6 Struts books now. This one cost less than ten dollars. In my book, that is a bargain.
   This is not the only book on Struts you should get. This book needs to be one of the Struts books you get.

Other books teach you the basics of what you have to do in most any run-of-the-mill Java webapp written with the Struts framework.

This book goes beyond those others, telling you and showing you what you have to do in order to get this weird thing to work or that kind of complicated thing programmed in a really simple way.

While other books teach you what you have to know, this book teaches you what you want to know.

Without digging in quite as deep into nitty-gritty details like a book that focuses on how to write your own Firefox extensions, this book mostly teaches you the big picture – and how to make it shine a little brighter through your Firefox window.

It does show you enough of the basics about creating an extension. So if you already know JavaScript, XML, and a few Firefox specific things – you can do it.

This book seems neat because it covers some really useful technical details – and it has a lot of breadth.

Seems okay. A little dated (Struts 1.1 instead of 1.2) but I have found it helpful in a couple of ways.

CSS is a nice way to let you author your information/prose/data – and then spruce up its looks later on – without touching the original content.

I started using CSS in earnest around 2002, a little while after I started getting into XSL-FO.

CSS is easier to work express what you want than XSL-FO, which lets you be more precise. Since no web browsers directly support XSL-FO yet, it is somewhat on the side lines for the time being – with respect to web page content. That is probably why this book does not cover it.

These days, it is de rigeur to know CSS really well if you are involved with web work in some way. That is why I bought this book.

I also wanted an up-to-date reference with respect to XHTML.

So far, I am slightly disappointed that the book did not include at least short sections on SVG, XUL/XBL, and HTC.

XUL, it is obvious, is not going away. SVG, it is equally obvious, is here.

And Microsoft’s HTC was used to prototype IE 7 so it has some proven usefulness.

Nevertheless, so far I like the book – especially the sections on CSS.

The web is going to really get great when XHTML 2.0 comes out. For now, the closest you can get is XHTML 1. This book covers that and CSS 2.1.

Refactoring – the strategies for making disciplined changes to programs – are like mini architectures themselves. They are architectures of strategies of how to get from one design – to another – safely.

Just like design patterns, they have motivating forces, are dependent on context, and many are defined in terms of the nature/terminology of object-oriented programming.

Eclipse and several other very popular IDEs for Java have included a bunch of commands to do some of the very refactorings described in this book.

It is invaluable to read it. Learn both the refactorings themselves – and the spirit for why, when, and where to do them – not just how.

Being able to change software is just as important as being able to design good software in the first place. Nothing of great size created over a long time just comes together perfectly.

Major course adjustments as well as fine-tuning are required from time to time. This book will make you an expert at carrying out those adjustments.

If you are programming in Java and using Eclipse then you really need to read this book to get the most out of your powerful IDE.

One thing that will catch your eye as you look through this book is that a lot of refactorings have exact opposites. That should tell you right there that simply being able to do a refactoring is not enough.

You also need the knowledge/wisdom to know which way you need to go, and if the code you are regarding is in the better state already. No sense changing the same piece of code back and forth forever! Refactor wisely.

If you have not learned how to use CSS – and all the different things CSS can be used upon/within – then you are really missing out. This goes for whether your fancy yourself a web designer or claim to be a programmer.

Web UIs are pervasive these days. Today, many applications embed what is loosely called “web technology”. This includes CSS and some standard document format(s) on which it can apply its style rules.

The list of document types CSS 2.1 can style is growing:

1. HTML (the old workhorse from the early 1990s – Java Swing components even support it)
2. XHTML (like HTML but pretty much cleaner/better in small but meaningful ways since it follows the simple/consistent XML syntax rules)
3. XML (yes, it can style plain, old XML elements, just set the display: attribute for each of them)
4. SVG (you have heard of graphics, haven’t you?)
5. XForms (the standard way of displaying forms/controls in XHTML 2.0 is also a modular standard that can be used standalone or with other document formats besides XHTML)
6. MathML (even mathematicians have style to their writing)

Java has had the ability to display HTML, and a little CSS, in its Java GUI applications since the late 1990s.

Java application programs can also embed a web server such as Tomcat. It is no big deal. The capability has been there for half a decade.

So anyone programming Java – client or server applications – should learn CSS and one or more of the document languages mentioned above.

Web designers are moving away from deeply nested tables for doing layouts. The only hygienic way to do precision layouts these days is with CSS. Tables have their place – but they do not own the place anymore.

Incredibly easy to read thanks to simple analogies, anecdotes, and examples.

Lots of historical coverage of the problems & solutions that are out there.

This is a book that programmers should probably read and those who are not but have an interest in the subject could probably understand.

Alice and Bob are in here.

Though I have only lightly skimmed this book so far, I can tell I will probably like it more than any other book I have on the subject.

The book has been out six years. Since it is available in paperback, nobody can claim it is too expensive. Probably more expensive not to buy it and read it than to do so.