Title
Author
Publisher
ISBN
Reviewed by
Review text
Category

Your search returned 96 matching documents



Emergent Design: The Evolutionary Nature of Professional Software Development
by Scott L. Bain


Addison-Wesley
1 edition
March 2008
448 pages
Reviewed by Ulf Dittmer, May 2008
  (9 of 10)


The author states in the preface that he'd like to push software development as a profession forward by promoting a set of methodologies that are universally recognized as beneficial. This reviewer thinks he achieves this goal admirably and wishes he had had access to a book like this when he first started out with object-oriented software development professionally.

A number of what might be called best practices are examined as to why they're useful, how they might best be applied, and how they deliver value in conjunction with other best practices. Some of these are well-covered by now (e.g. coding style and patterns), others are somewhat newer (like refactoring, the open-closed principle, unit tests and test driven development). At each step the author uses a combination of concrete code (mostly in Java, but easily understandable to everyone) and abstract UML-style diagrams to illustrate what is happening, and what difference a particular technique makes.

One important recurring theme is that the waterfall model of software development is truly dead, and that change of all kind needs to be embraced in a project, especially including changing requirements. Every software professional will recognize the value of being able to cope with change, and in this book that's part of the core message at each step. I recommend the book to get fresh perspectives and new ideas about various parts of the development process, both for developers and managers.

Discuss book in the Saloon — More info at Amazon.com


Adobe AIR for JavaScript Developers Pocket Guide
by Mike Chambers, Daniel Dura, Kevin Hoyt, Dragos Georgita


O'Reilly
1 edition
April 2008
204 pages
Reviewed by Balaji Loganathan, May 2008
  (8 of 10)


I was trying to learn Adobe AIR and was looking for some good set of learning resources. I found the book "Adobe AIR for Javascript Developers" from O'Reilly by and started reading it online. A cool book, the authors have done great job on presenting the topics as an easilit readable pocket guide. Soon after reading this book, i felt i got the right resource i want for now.
I found this book a bit more than a usual pocket guide.If you are a beginner and don't know anything about AIR, then this book is the best bet.The chapters were well organized to take you from novice stage to advanced stage in AIR.Covers ADOBE AIR 1.0Chapter I and II of this book teaches you many information and technical details about the AIR which might lots of time if you have to get it from Internet.The authors have given lots of code snippets while explaining a topic instead of lots of theoretical text. Some thing that programmers always look for.This book also gives an insight about Webkit engine, architecture of AIR and the security model of AIR. The most interesting part in this book is the "Mini cookbook". The mini cookbook chapter contains worked out samples with complete code explanation. It includes samples that can help you understand (from AIR perspective) Application Chrome, Windowing, File API, File Pickers, Service and Server Monitoring, Online/Offline, Drag-and-Drop, Embedded Database, Command-Line Arguments, Networking, Sound.This book is worth buying for its content coverage and its also very cheap.

Discuss book in the Saloon — More info at Amazon.com


JavaScript for Programmers (Deitel Developer)
by Paul J. Deitel, Harvey M. Deitel


Prentice Hall PTR
1 edition
March 2009
448 pages
Reviewed by Campbell Ritchie, April 2009
  (8 of 10)


Before buying, go to the Deitel website (www.deitel.com) and see whether there are text samples (there weren't when I reviewed the book). Deitel books have their own characteristic style which some people (myself included) like and others detest. Much of it consists of showing examples of the technique, and explaining how it works, line by line. I personally find this an effective way to learn.

As well as JavaScript, the book covers introductory XHTML, style sheets (CSS), XML and rich internet applications with AJAX.

The examples are clear, simple, and easy to understand; I often learn by copying and changing them. The book is clearly printed in greyscale and sturdily bound. I have even dropped Deitel books in the street without losing pages! I only found 1 misprint. It is generously supplied with links to other resources, and appears to be up to date.

The "Programmer" books appear to be taken from the corresponding "How To Program" books, with some of the simpler stuff taken out; they assume a "programmer" knows what a browser is, and (see page 307) what an IEEE785 number is! This book appears to be the "client-side" half of a "How To" book. Many of the twee drawings of ants have gone, too, and unfortunately there are no exercises at the end of the chapters.

I recommend buyers look at the "How To" book, ISBN 0131752421, and see how it compares for value for money.

Discuss book in the Saloon — More info at Amazon.com


Assemble the Social Web with zembly
by Gail Anderson, Paul Anderson, Todd Fast, Chris Webster


Prentice Hall PTR
1 edition
December 2008
400 pages
Reviewed by Jeanne Boyarsky, March 2009
  (5 of 10)


"Assemble the Social Web with Zembly" is the official book for Zembly. It shows how to use Zembly for Facebook/iPhone/flickr/Zillow/Dapper. Parts of the book read a bit like a commercial. For example chapter one spends eleven pages giving roughly the information you would get at a free conference talk. Then it gets more informative.

The introduction says the audience is people who either know or are willing to learn JavaScript. They do give references for those who don't know it yet. I had some difficultly with the intended audience. A good part of the book is step by step - almost as if the audience is new to the web (here's how to edit your profile, here's how to add a contact, etc.) Then periodically the book shows reams of JavaScript code. Something I'm not fond of in a coding book let alone a more general one.

A few places refer to features that are in beta or may change before release. Despite the disclaimer, this seems out of place in a book.

I did like how the book didn't assume you've built widgets before. The list of Facebook integration points was particularly interesting. I also really liked the activity diagram in the iPhone chapter.

The book had it's moments that I liked and didn't like. Overall I was neutral on it.

Discuss book in the Saloon — More info at Amazon.com


Learning Dojo
by Peter Svensson


Packt Publishing
1 edition
November 2008
264 pages
Reviewed by Jeanne Boyarsky, February 2009
  (7 of 10)


"Learning Dojo" gets you up to speed on using DoJo widgets quickly and efficiently. While the book does cover some advanced JavaScript concepts like closures, you should be comfortable with JavaScript before you start out.

The book was well organized. It starts with the basics of how to use the library and widgets. Later on, internationalization, theme and locales are covered. The example of a basic threading error in AJAX was helpful because it showed WHY approaches wouldn't work. I particularly liked the chart in chapter on with the "selling points" of Dojo.

While I did find one font error (page 28), if this is the biggest error I noticed things are in good shape. There was also a bit of wasted space. For example the almost two pages of character codes (listed one at a time) could have been a table to save space. These are just nits though and don't interfere with readability. And the authors does abbreviate code where possible. The examples build on each other so it isn't too overwhelming reading all that code.

Overall, I did learn a lot from the book. The "real world" examples have a good scope to them - a CRUD example is something many people do! And I really liked the unit testing widget. I learned of several sites to bookmark. Finally, Packt gives some money to the open source project when they sell copies of the book - a very neat concept.

Discuss book in the Saloon — More info at Amazon.com


Ajax - The Complete Reference
by Thomas A. Powell


McGraw-Hill
1 edition
February 2008
654 pages
Reviewed by Jesper de Jong, May 2008
  (9 of 10)


This book is about writing Ajax web applications. It consists of four parts: Core Ideas, Applied Ajax, Advanced Topics and appendices.The first part explains what Ajax is and describes different ways of implementing Ajax in considerable detail. It describes some pre-Ajax techniques for implementing dynamic web applications, discusses the XMLHttpRequest object, data formats such as XML and JSON and goes quite deep into the issues that you will encounter when using the different techniques. In the second part, a number of concepts are presented by developing an Ajax library. There are chapters about networking, security, user interface design and website and application architecture. In the third part some more advanced techniques are described, such as calling web services.

What I especially liked about this book is that it goes deep into the details if needed. For example, differences between web browsers are described in detail. The book isn't just a cookbook that explains step by step how to build an Ajax web application - it focuses on making robust and secure applications that will work well on the different browsers and operating systems that are out there.

I would highly recommend this book to people who are developing serious Ajax web applications. This book contains a lot of valuable information, I certainly learned a lot by reading it.

Discuss book in the Saloon — More info at Amazon.com


jQuery in Action
by Bear Bibeault, Yehuda Katz


Manning Publications
1 edition
February 2008
376 pages
Reviewed by Ernest Friedman-Hill, April 2008
  (10 of 10)


jQuery is a Javascript framework that aims to let you think structurally and conceptually, rather than worrying about syntax and other details. In that largely succeeds, and so does this remarkable book.

Every technical book should be like this one; having written a few myself, I know that's a tall order. "jQuery in Action" is concise but clear, humorous but not silly, and answers all the questions it raises, quickly. The reader is never left wondering "But what about..." for more than a sentence or two. The authors clearly gave a lot of thought to pedagogy, because things are explained in a clear way which progresses naturally from chapter to chapter. Factor in the extremely readable style and the handsome diagrams, and it's easy to see why reading this book is a sheer joy.

For each major feature of jQuery, this book provides a "Laboratory page", a kind of interactive HTML playground where you can try the feature out using different options. The remarkable flexibility of these pages is a testament to both the power of jQuery and to the imagination and creativity of the authors.

Perhaps the most commendable feature of "jQuery in Action" is its unflinching honesty. Too often authors are selling you on a product, and they'll gloss over rough spots to win you over. These authors don't do that. They present their topic as it is, describe its merits, and let the reader decide.

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
February 2008
376 pages
Reviewed by Katrina Owen, September 2008
  (9 of 10)


jQuery in Action is rock-solid documentation, well-written, and easily assimilated - even for a relative neophyte such as myself. The book is not a how-to write JavaScript book, but it does contain an appendix which helps readers who are less than proficient in JavaScript to get up to speed.

While the book starts out with the very basics of selecting elements and interacting with the DOM, the text rapidly progresses to much more complex uses, including animations, ajax, and how to extend jQuery with plugins and custom functions. It includes non-trivial examples (yeah!) and 'labs' where the reader can get their hands dirty and experiment in a controlled environment.

I'm certain that readers with a good background in JavaScript (object-oriented, unobtrusive, robust JavaScript - not the cowboy stuff) could whip through this book in a day or two and be well on their way to using jQuery library to build elaborate applications. After reading through the book once, I spent several months slowly digesting morcels of it, writing a lot of code, and reading (and re-reading) sections as the need arose.

I keep the book handy as a reference, as I am constantly 'almost' remembering how to do something or other.

My first real project using jQuery was transforming a relatively brittle (and very confusing) homegrown ajax application to use jQuery. One of my colleagues commented that the code now "reads like a story". Bear, Yehuda - you guys are making me look good. Thank you!

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
February 2008
376 pages
Reviewed by Jeanne Boyarsky, June 2009
  (9 of 10)


"jQuery in Action" grabbed my interest and kept it. This was a great contrast to the previous book I read - "Learning jQuery 1.3" which made me want to pull my hair out at the copious HTML code. By contrast, the longest "jQuery in Action" code example was 3.5 pages and there were only a few approaching this length. The vast majority were significantly shorter and all were easily digestible.

Note that this review is for jQuery in Action 1st edition which covers jQuery 1.3. If you go to the publisher's website, you can buy the second edition which covers jQuery 1.4. While only three chapters of the second edition are available, you can see them as they get written. Plus it includes the e-book for the current edition. If I were buying the book now, I'd choose this arrangement. It's a great idea on the part of the publisher as it solves the "I want to read a good book about jQuery now but don't want the latest edition ASAP."

The book comes with some "labs" that you can download to try out concepts. I really liked following along and trying out the selectors/effects interactively. There was an emphasis on good coding concepts such as Unobtrusive JavaScript and Progressive Disclosure throughout. I really liked the emphasis on idioms and good techniques. I also liked how there was a page on why browser detection is bad before showing how to do it.

Discuss book in the Saloon — More info at Amazon.com


Head First JavaScript
by Michael Morrison


O'Reilly Media, Inc.
1 edition
January 2008
650 pages
Reviewed by Katrina Owen, May 2008
  (9 of 10)


Head First JavaScript starts off by illustrating why JavaScript can be useful (adding pizzaz, interactivity, and excitement to a website), and then goes about leading the reader in experiments, exercises, and games which introduce various aspects of the language: variables, scope, objects, control statements, and events. The book also introduces debugging and very basic Ajax.

The irreverent Head First style cleverly disguises the fact that you will walk away from the book understanding 'stuff'. This is not a recipe book, and it is not a code mill. The examples are for one purpose only: trick your brain into understanding a concept. The exercises do the same thing - often adding emotional spice by letting you walk straight into a trap (a typical mistake made by most novices), and then helping you understand exactly why you made that particular mistake on the very next page.

Did someone say "Just in Time" learning?

If you are a JavaScript guru, the book will probably be an entertaining read, but not much more than that. If the extent of your javascript knowledge is copying and pasting scripts written sometime prior to y2k and then tearing your hair out when they don't work the way you need them to, then this is the perfect place to start gaining the proficiency you need to start writing your own scripts from scratch.

Head First JavaScript is a great foundation, and will have you reading and enjoying more advanced texts in no time.

Discuss book in the Saloon — More info at Amazon.com


Ajax Security
by Billy Hoffman, Bryan Sullivan


Addison-Wesley Professional
1 edition
December 2007
504 pages
Reviewed by Ulf Dittmer, February 2008
  (9 of 10)


With the advent of more sophisticated client-side web apps -- facilitated by AJAX and the JavaScript XmlHttpRequest object -- have come more numerous and more easily discovered security issues. As the authors point out, AJAX combines the vulnerabilities of traditional web apps and web services.

This book is billed as "The Hands-On, Practical Guide to Preventing Ajax-Related Security Vulnerabilities", and it delivers admirably on that count. It covers in detail the wide range of attack possibilities - from traditional web attacks and JavaScript hijacking over client-side storage and offline vulnerabilities to request origin issues, mashups and even CSS. An analysis of two JavaScript worms and a couple of chapters presenting tools to help test AJAX application and popular AJAX frameworks round out the book. Many illustrations and code examples help convey the subjects, as do details of what to look out for in particular browsers or server software. It's hard to picture a web worker (be it developer, tester, producer or manager) that doesn't take away something (and more likely quite a bit) from this book.

It's written in a style that makes it easily approachable, and complex topics are explained well. Although some of the later material assumes knowledge of the earlier stuff, most chapters can be skipped if the reader isn't interested in a particular topic, and revisited later. I recommend the book to every web professional.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
December 2007
504 pages
Reviewed by Jeanne Boyarsky, January 2008
  (10 of 10)


Anyone involved in developing/testing AJAX should read "AJAX Security." It covers preventing a hacker from attaching your application. The audience includes developers, QA and penetration testers. While there are code snippets, they are explained well. While managers aren't in the target audience, I think they could benefit from understanding the concepts presented in the book.

The book begins with a brief review of AJAX architecture with an emphasis on security. The writing style is quite engaging including a chapter walking you through an attack from a hacker's point of view. All the major known categories of attacks are included including resource enumeration, parameter manipulation (with SQL and XPATH injection), session hijacking, JSON hijacking, XSS, CSRF, phishing, denial of service, etc.

I particularly liked the analogies to things that happen in the physical world such as resource injection into a roommate's "to do" list and hijacking another customer's paid order in the deli. These made it easy to visualize the problem even for people who don't code often.

The authors were realistic and included the limitations and drawbacks of each tool/framework mentioned. I liked the chapter analyzing two major JavaScript worms including the source code. This really hit home on the importance of certain practices!

All information was up to date as of printing including comments on all four major browsers (IE, Firefox, Opera and Safari.) They even mentioned the HTML 5 specification. The book is not server side language specific, which was nice.

Discuss book in the Saloon — More info at Amazon.com


Pro JavaScript Design Patterns
by Ross Harmes, Dustin Diaz


Apress
1 edition
December 2007
269 pages
Reviewed by Jeanne Boyarsky, April 2008
  (9 of 10)


"Pro JavaScript Design Pattens" is a useful read regardless of whether you have a JavaScript or server side language background. An advanced topic that appeals to such varied audiences is tough to do, but the authors succeed admirably. In fact, I can't do such a job, so read the chapter that applies...

JavaScript developers:
The book covers how to write good clean object oriented code in JavaScript. It introduces concepts that are not present in JavaScript along with how to simulate them. The sections on when to use a given pattern are well written.

Server side language developers:
The book covers how to implement in JavaScript the design patterns we are accustomed to. Before getting to this, there are several chapters on JavaScript idioms which are very useful. There were also a couple patterns that a server side developer might not have encountered because the server side is not so memory constrained.

Everyone:
The book also covers tradeoffs of using the patterns. I appreciated where they mention the slight performance hit and how to check/profile if it is a problem for you. All patterns were described clearly and succinctly. There were some real examples as well. At times, it is a bit code heavy -- one example had 1.5 pages of implementation details that had nothing to do with the topic at end. Overall, I think the book was great. If you have a significant amount of JavaScript code, the concepts in this book are critical.

Discuss book in the Saloon — More info at Amazon.com


Advanced Ajax: Architecture and Best Practices
by Shawn M. Lauriat


Prentice Hall PTR
1 edition
October 2007
384 pages
Reviewed by Jeanne Boyarsky, January 2008
  (6 of 10)


"Advanced AJAX" is targeted towards AJAX application architects. Note that readers should be comfortable learning by reading code. For example, chapter 1 has two pages of code for a GUI widget. This seems heavy for a conceptual book. Elsewhere, the main idea got lost in six pages of view code.

I liked the non-technology specific sections. Browser tools included Safari and Opera plugins. All the "hot" security topics were covered (SQL injection, XSS, CSRF.) Tradeoffs were listed for different alternatives. Performance included CPU, memory and bandwidth. Trying out examples on the companion website was nice.

Many server side techniques were PHP specific, such as SQL injection. While six pages of code is good for PHP developers, I was surprised. The code was readable without being fluent in PHP, but unnecessarily narrows the audience. The 15 pages of screenshots/description on the PHP documentation tool could have been used for another topic. Wouldn't a PHP developer already know how to use PHP?

While I liked the presence of an accessibility chapter, I was confused. WCAG/Section 508 were introduced clearly early in the chapter. For the rest of the chapter, I wasn't clear on what pertained to WCAG, what was 508 compliant and what was coming in the future.

If you are a hands on PHP AJAX developer interested in architecture, this is an excellent book. Non-PHP developers or people who want to focus on architecture (rather than code) are better off with a different book.

Discuss book in the Saloon — More info at Amazon.com


Enterprise AJAX
by David Johnson, Alexei White, Andre Charland


Prentice Hall PTR
1 edition
August 2007
496 pages
Reviewed by Ulf Dittmer, November 2007
  (7 of 10)


The subtitle of the book -- "Strategies for building high performance web applications" -- nicely sums up what this book is about: Not so much a tutorial about AJAX that takes the reader from 0 to 100%, but rather a collection of topics that relate to AJAX-based web applications, bundled into book chapters. The chapters span a wide gamut, from basic browser technologies like CSS/DOM/JavaScript and XMLHttpRequest, to more advanced stuff like the design of JavaScript code, Web Services, and the handling of sizable chunks of data within JavaScript. The book also covers issues of the software development process as they relate to AJAX applications, like usability, prototyping, testing and project risk management. Three case studies round out the book, but don't provide much additional insight.

If a chapter isn't of interest to the reader, it can generally be skipped without impacting the understanding of later material. Everything is explained with plenty of code examples, along with explanations of what gotchas to look out for when running under different browsers.

The book would have benefited from a more thorough proofreading. As it is, an annoyingly large number of typos, duplicated words and sentence fragments, and even incorrect picture captions and footnotes, have crept in. Nevertheless, the authors clearly know their stuff, and break it down into pieces that are easily digested and readily applied. Just about any web developer will get useful ideas out of Enterprise AJAX, no matter how big his projects.

Discuss book in the Saloon — More info at Amazon.com


Ajax Construction Kit: Building Plug-and-Play Ajax Applications
by Michael Morrison


Prentice Hall PTR
1 edition
July 2007
312 pages
Reviewed by Katrina Owen, August 2007
  (7 of 10)


This book is aimed at people who make web pages for fun, and have little to no (java)scripting experience. If you haven't the faintest idea what Ajax is and does (I didn't when I picked this book up), you may emerge with understanding and excitement. This book will help the uninitiated realize just how many slick tricks can be accomplished with Ajax.

The Ajax Construction Kit promises to hand you working Ajax goodies. It delivers on this promise! It also provides you with a good understanding of how to tweak and nudge the applications provided, so that you can incorporate them into your own websites. If you wish to transform the goodies to any significant degree, or learn how to build your own Ajax applications you will need to find a different set of resources. This book does not set out to teach you how to program.

The book comes with a CD which has the source code for all the goodies in the book - AND a working webserver for your convenience in the form of a Live CD. If you would rather work in your own, familiar, environment rather than Ubuntu Linux, it also provides both the code and a server which you can install locally on a Windows, Mac, or Linux variant.

The author does apologize a lot when things get technical. Come on! We love this stuff, and it is presented well, so it isn't the least bit scary.

Discuss book in the Saloon — More info at Amazon.com


Ajax Starter Kit
by Phil Ballard


Sams
1 edition
June 2007
224 pages
Reviewed by Christophe Verre, September 2007
  (7 of 10)


This kit comes with an Ajax Quick Start Guide and CD.

First of all, the Quick Start Guide, which actually is a book called "Sams Teach Yourself AJAX in 10 Minutes". You'll get introduced to Web technologies, such as HTML and JavaScript. Then starts a fast paced Ajax introduction where you will learn what Ajax is. It goes straight to the point so don't expect detailed explanations, but nothing should leave you clueless. There is a nice chapter on Ajax common traps, which explains what you should take care of when developing in Ajax. I wish there were such a chapter on debugging too. Finally, you are introduced to some common Ajax libraries, like Prototype and Rico.

The CD contains sample files, utilities, Ajax libraries, and an amazing PDF file. This PDF contains six books in one. You get the "Ajax Quick Start Guide", "Sams Teach Yourself (STY) JavaScript in 24 Hours", "STY XML in 10 Minutes", "STY HTML in 10 Minutes", "STY CSS in 10 minutes", and "STY PHP in 10 minutes", all in the same PDF.

All in all, this Starter Kit gives you a quick overview of what Ajax is. If you're impatient to know about Ajax, this 200 pages guide will suit you. If you don't know anything about HTML, CSS or JavaScript, then this package can be handy. If you are looking for something more practical, you will need some other materials, as there is no good tutorial in this guide.

Discuss book in the Saloon — More info at Amazon.com


Ajax in Practice
by Dave Crane, Bear Bibeault, Jord Sonneveld


Manning Publications
1 edition
May 2007
456 pages
Reviewed by Jeanne Boyarsky, June 2007
  (9 of 10)


The back cover says that "Ajax in Practice" is a "second generation" book. The book covers a mix of problem/solution descriptions for common problems, Ajax tips and advanced JavaScript techniques. The cookbook style is useful if you are trying to implement a specific Ajax effect. The book touches on a number of libraries/toolkits where appropriate. It also covers integrating with existing Ajax libraries.

The book assumes you know basic JavaScript, CSS and HTML. If you are new to Ajax, I recommend reading a "first generation" book like "Ajax in Action" first. This book is a lot easier to follow if you have some exposure to Ajax. In particular, the problem/solution style involves learning by reading a lot of code. This is overwhelming on the first shot. I had to pull out my copy of "Ajax in Action" to follow parts of it. While some of the examples are long, they don't include unnecessary code.

I liked that the book has a common flow to it. Even though there are seven authors/contributors, the style is the same and it makes sense. I learned a lot about specific uses of Ajax along with examples/techniques of good Ajax code. This should definitely be the second Ajax book you read!

Discuss book in the Saloon — More info at Amazon.com


Pro CSS and HTML Design Patterns
by Michael Bowers


Apress
1 edition
April 2007
494 pages
Reviewed by Katrina Owen, May 2008
  (9 of 10)


I absolutely love this book. I have two copies of it - one at work, one at home.

The author focuses on browser compatibility, and accessibility to screenreaders. I have been disappointed only once - when I thought 'accessibility' included those who do not use a pointing device. But that is more of a javascript question than CSS/HTML, and therefore falls outside the scope of the book.

Most CSS/HTML code I see employs the "programming by coincidence" model. Add a rule here to fix something that doesn't quite work there, use a negative margin here, maybe a browser-specific hack there. In the end, it works. It might even look pretty good, but invariably, the result is unnecessarily bloated.

Pro CSS and HTML Design Patterns makes it possible to code deliberately. It provides a solid fundamental understanding of how elements and rules interact, and especially how the same element or attribute will behave differently in different environments.

In several cases, it has saved me hours of trying to achieve something which simply cannot be done in the current specification. At the same time, it has provided enough information to find a different approach that does work.

The book is very systematic, and while it is a great read cover-to-cover, it functions very well as a reference volume. The 'patterns' format (name/problem/solution/pattern) makes it very easy to locate the exact information you are looking for.

Summary: Buy this book. Read this book. I mean it.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
April 2007
494 pages
Reviewed by Jeanne Boyarsky, July 2007
  (9 of 10)


"Pro CSS and HTML Design Patterns" is a valuable reference for using CSS on your website. You should be familiar with reading or writing CSS and have some experience with HTML for this book to be readable. In particular, you should feel comfortable with CSS syntax and high-level concepts.

The book is still useful if you know CSS "a little" -- you may have to read parts a few times. In particular, there are a few places were terms are defined after they are used. It's a bit of a catch 22, for the author as introducing those terms relies on the initial sections. There aren't many of these and all becomes clear by reading the patterns twice.

I liked the style of having code/screenshots on one side and the pattern/description/limitations on the other side of each two page set. This consistency made the book easy to follow. I particularly liked the emphasis of making the patterns accessible to people using different browsers, screenreaders and with Javascript disabled.

Some of the design patterns are teaching patterns to understand concepts and terminology. The rest are techniques you could want to use when designing a web page. Some techniques are self-contained, like styling text. The end of the book builds more complex patterns out of those that came before. The box model and layout ones are quite valuable.

The companion website lets you play with each pattern. In summary: buy this book!

Discuss book in the Saloon — More info at Amazon.com


ppk on JavaScript
by Peter-Paul Koch


New Riders
1 edition
September 2006
528 pages
Reviewed by Jeanne Boyarsky, October 2006
  (9 of 10)


"ppk on JavaScript" fills an interesting void with the focus of today's JavaScript books. Most books either focus on "JavaScript in 21 Days", "JavaScript -- Complete Reference" or "AJAX". This book covers techniques for creating clean and accessible JavaScript functionality.

The book's stated audience is someone who knows at least some JavaScript -- a beginning level or up. Basically, you should feel comfortable reading and understanding code. I think the book might be a little overwhelming for a beginner to understand. A beginner could read it twice; once right away and once after reading another JavaScript book.

The author views JavaScript as a technique to add usability. He shows how to create "unobtrusive" JavaScript. In other words, the JavaScript stays out of the HTML page and the page works without JavaScript, albeit with less functionality.

Eight case studies (real life examples) are used throughout the book. The author points out why he selected certain techniques. He also notes bugs and where he would have done things differently. I particularly liked the emphasis on separation of concerns.

Keyboard users are also discussed from an accessibility point of view in several chapters. In other chapters, only users without JavaScript enabled were discussed. I would have liked a little more consistency with how accessibility was treated.

Overall, the book was very good. The tips were useful and I enjoyed the emphasis on design. And AJAX is discussed from the point of view of how it was used before it was called AJAX.

Discuss book in the Saloon — More info at Amazon.com


JavaScript & AJAX - Learn JavaScript and Ajax the Quick and Easy Way
by Tom Negrino, Dori Smith


Peachpit Press
6 edition
September 2006
512 pages
Reviewed by Pauline McNamara, January 2007
  (4 of 10)


My opinion about this book would be much higher if it had not claimed to be a learning book. The intended audience are people with basic familiarity of HTML, and the authors "don't assume that you know anything about programming or scripting." If you fall into this category, I'd wouldn't recommend this book.

It starts with a couple gentle introductory chapters, followed by a very dense syntax dump in the third chapter. The intended reader may survive the sink or swim approach, but I suspect they're more likely to give up after that chapter. The now requisite Ajax chapter towards the end seems quite out of place, again because of the context of non-programmers just picking up scripting.

The rest of the book is a collection of useful examples in a cookbook style, with line-by-line annotations of the code (however not explaining the syntax specifically). If you learn by watching, or if you already write code and are looking for a good JavaScript cookbook, you'll be happy to have this on your shelf. If you've never coded a loop before, you'll need other books to really learn the mechanics.

Strengths: good cookbook for experienced programmers, sprinkled with useful tips (albeit buried in code explanations).

Weaknesses: way too much information that a learner has to take on faith, narrow column format drastically reduces code readability.

Discuss book in the Saloon — More info at Amazon.com


HTML, XHTML and CSS
by Elizabeth Castro


Peachpit Press
6 edition
August 2006
456 pages
Reviewed by David O'Meara, October 2006
  (9 of 10)


My first impression was that the page layout was strange for a book, but then I realised that the layout and presentation of data was the point of the book, so I stopped worrying and went with the flow.

It treats HTML and XHTML as the same thing, only distinguishing one from the other when a specific point needs to be made. This was a nice way to start as it removes the mystery of XHTML and allows the reader to concentrate on getting things displayed. I was also interested in the way the book worked from basic structure to applying ids and classes without introducing styles. These aren't introduced until chapter eight where you (hopefully) already have a feel for basic structure, layout, and markup.

The book races through the easier parts of HTML and I guess it could be possible for a complete novice to get lost, so pay attention in the first chapter. The book is rated for 'intermediate users' though, so complete beginners may want to be wary. The good news is this leaves room at the end for bonus content like character encodings, problem solving, marketing and RSS.

It is easy to see why this is a popular web design book. Topics are laid out in a no-nonsense manner that makes everything look easy and achievable, there is plenty of content without being heavy, and the layout provides the flexibility for colored examples and additional points of interest. Also, don't overlook a web book that is printed in color!

Discuss book in the Saloon — More info at Amazon.com


AJAX - Creating Web Pages with Asynchronous JavaScript and XML
by Edmond Woychowsky


Prentice Hall PTR
1 edition
August 2006
432 pages
Reviewed by Ulf Dittmer, September 2006
  (3 of 10)


This book misses the mark of explaining where and how to use AJAX.

Less than half the pages deal with AJAX itself; the rest is taken up by introductions to (X)HTML, JavaScript, XML, Path, XSLT and Ruby (on Rails) - technologies that are related, but which the brief coverage here doesn't do justice. Furthermore, pages upon pages of HTML element/attribute listings, DOM methods or XSLT functions don't further the insight into AJAX.

The sole in-depth example is a shopping cart application, which is fine, but plenty of simple ready-to-run examples that show various aspects of working with AJAX would help much more. Other examples use outdated techniques like XML islands and hidden frames, which muddles the picture further.

The authors' style of writing also gets in the way. It's probably supposed to be easy-going, but includes a stream of witty and self-deprecating remarks that detract from the content, and by the 10th repetition of "this is all mad-scientist stuff" this reviewer was yearning for some actual stuff, not fluff.

The chapters of the book that do talk about AJAX provide a decent introduction to the XMLHttpRequest object, and how to use it to transfer information back and forth from the server. It?s all bits and pieces, though, and no big picture is ever provided. Anyone who was inspired by Google Mail or Google Maps to build AJAX apps will not know where to start after reading this book.

Discuss book in the Saloon — More info at Amazon.com


Practical Ajax Projects with Java Technology
by Frank Zammetti


Apress
1 edition
July 2006
528 pages
Reviewed by David O'Meara, September 2006
  (8 of 10)


I have read some AJAX books and enjoyed them, but they typically concentrate on the client side and coverage of what occurs on the server side, if any, is generally PHP or a smattering of almost anything. But I'm a Java guy. The book I've been looking for would have not only the server side examples in Java, but would also use Java as the basis of discussion on client-server communication and the tools available to ease the whole process.

The examples cover a variety of interesting projects and technologies, but the coverage of CSS, JavaScript, Servlets etc is very light as to be almost non-existent. Some of the sample code has been cut and paste without too much scrutiny, so they are often bloated by useless or even empty javadoc blocks but this is more of a annoyance than a real problem. Appendix B has several pages of useful links, but I would have liked to have seen this as a closing chapter of the topics that didn't warrant complete coverage.

Interestingly, while core AJAX books tend to favour the client action and be light on what happens on the server, this book leans the other way. If you are looking to buy a single book to cover AJAX this will cause you a problem, but now that you are fore-warned if you get the correct combination of client and server AJAX coverage you'll be well served for your future needs.

Discuss book in the Saloon — More info at Amazon.com


Pro Ajax and Java Frameworks
by Nathaniel T. Schutta, Ryan Asleson


Apress
1 edition
July 2006
336 pages
Reviewed by Balaji Loganathan, October 2006
  (8 of 10)


The authors have taken good efforts to neatly introduce, analyses and compare various javascript tools specifically meant for AJAX.

The flow of the book is well managed and its very reader friendly.

This book is definitely a one stop reference for knowing what development tools, editors, libraries available for supporting AJAX in Java web applications.

Comes with 50MB examples source code. The source code has been configured to easily deploy and test using ANT.

This book mostly addresses the freely available AJAX tools.

Few drawbacks I found:
A lot of pages have been spent on describing and comparing between java frameworks, the authors could have avoided it since this book about using AJAX in java framework.
The code listings in the chapters (like html, javascript, jsp) were not well formatted, so it very difficult to read.
The authors gives more preference to JSF framework which is again not the context of the book.
That's it.

Since the book is published recently(July06), this book covers many latest AJAX and JAVA Framework products, so its saves your time on finding a right tool for your AJAX based websites.

I don't want to write again the table of contents of this book but want to mention that you will sure learn all the bit and pieces that you need have for setting up a AJAX based java web applications.

Discuss book in the Saloon — More info at Amazon.com


Beginning JavaScript with DOM Scripting and Ajax
by Christian Heilmann


Apress
1 edition
July 2006
512 pages
Reviewed by Andrew Monkhouse, September 2006
  (9 of 10)


Up until now, most JavaScript books I have seen have not really described how to be a good JavaScript programmer - most of them have lead by example (which is how many JavaScript programmers I know learnt JavaScript). Unfortunately learning JavaScript by simply viewing other people's code without understanding why it was written the way it was could also lead to learning by bad example.

Christian Heilmann's "Beginning JavaScript with DOM Scripting and Ajax" is different - it teaches the reader the concepts that will help them to become a good JavaScript programmer. Perhaps more importantly, it teaches how to use JavaScript, CSS, DOM, and Ajax in a degradable manner, so that all visitors to your web site will be able to access it. Christian explains not only the guidelines for developing good code, but the reasons why it is important.

Christian's passion for creating maintainable, standards compliant, usable websites is clearly visible in his writing. Throughout the book he reiterates key issues that good programmers should know, and demonstrates them in his code.

This is an excellent book on JavaScript, and one that I will thoroughly recommend to anybody new to JavaScript programming. I also recommend it to anyone who plans to make their website more accessible to a wider audience (and who doesn't want that?).

Discuss book in the Saloon — More info at Amazon.com


Pattern Languages of Program Design 5
by Dragos Manolescu, Markus Voelter, James Noble


Addison-Wesley Professional
1 edition
May 2006
624 pages
Reviewed by Jeanne Boyarsky, May 2006
  (7 of 10)


"Pattern Languages of Program Design 5" is the latest in a series output by the PLoP (pattern languages of programming) conferences. A pattern language is a group of higher order design patterns that go together to form a vocabulary for a specific problem.

Each chapter stands on its own and is written by different people. This makes the format all over the place - each chapter is somewhat different. Some of the content is fairly specialized. There are chapters on real time systems, radio and pattern writing. While all of these are fascinating, they are unlikely to appeal to the same group of practicing developers.

At times, the book feels academic. It is probably supposed to as it is on introducing new patterns to the world. I felt there was a strong emphasis on contributing to PLoP and writing new patterns.

That said, each chapter was very good on its own. The authors were all interesting and explained the topic clearly. There were good examples and the quality was high.

I recommend this book if interested in PLoP or pattern writing in general. If you've read #4 in the series, you will definitely find this one enjoyable. If not, I would recommend starting with #1 in the series. There are some backward references to earlier books, so it would be easier to follow.

Discuss book in the Saloon — More info at Amazon.com


Design Patterns in Java
by William C Wake


Addison-Wesley Professional
second edition
April 2006
480 pages
Reviewed by Frank Carver, May 2006
  (9 of 10)


It's hard to review this book without mentioning "Design Patterns" by Gamma, Helm, Johnson and Vlissides (known as "Gang of Four", or "GoF"). Both start with a general intrduction, describe the same 23 patterns, and even have an index of patterns inside the front cover..

That said, it's the differences which matter. .

GoF chose mainly UML and C++ to describe the patterns in detail. This book considers how these patterns can be used in Java. That in itself is significant (at least if you use Java), but there is also a strong difference in style between the two books..

GoF is dry and academic, sometimes requiring a lot of study to understand and apply abstract pattern descriptions. This book, on the other hand, is much more lively - full of worked examples, self-test problems and puzzles, all set in the context of a fictional firework manufacturer. This makes it a much more enjoyable read. And if you get stuck, the solutions are all in the back..

However, this easy-reading, approach has a negative side. The patterns are so comfortable and copyable that subtlety can be missed. Take Flyweight, for example. Admittedly this is one of the rarer patterns in the wild, but in this book it seemed more like a recipe for one particular usage than an exploration of possibilities..

In summary, GoF is a crusty classic worthy of anyone's bookshelf, but this book provides a useful and practical introductory step for anyone working with Java.

Discuss book in the Saloon — More info at Amazon.com


Professional Ajax
by Nicolas Zakas, Jeremy McPeak, Joe Fawcett


Wrox
1 edition
February 2006
432 pages
Reviewed by Ernest Friedman-Hill, March 2006
  (8 of 10)


"Professional Ajax" shoots from the hip. Go ahead, scour the web. Find every forum, article, or review about Ajax that allows users to post comments. You'll find a common complaint: "We've been doing that for years, we don't need a fancy new name." These guys understand this comment. They know what they're doing here, and they've got the battle scars to prove it. Call it what you want: Ajax, Web 2.0, or just business as usual, these authors know how to get the job done.

You won't find oversimplifications here: the authors don't skimp on details as they describe what goes into Ajax applications and show you how to build your own. The book concludes with a large and lovely guide through the process of developing a realistic Ajax-based email client similar to Gmail.

This is a nice pragmatic guide to coming up to speed with what's happening in interactive Web application development. You won't go wrong with this book.

Discuss book in the Saloon — More info at Amazon.com


Foundations of Ajax
by Ryan Asleson, Nathaniel T. Schutta


Apress
1 edition
October 2005
296 pages
Reviewed by Gregg Bolinger, December 2005
  (8 of 10)


The first round of Ajax books have hit the shelves and Apress is trying to make their mark with Foundations of Ajax. A thin book with only 273 pages including the index, Foundations of Ajax hits the mark with its recipe style format and examples.

Foundations of Ajax starts out the way most tech books do with a bit of history and primer for what's to come. Most people familiar with web applications and design can probably just skip chapter 1 and possibly 2. But don't skip anymore. Chapter 3 jumps right in with your first fully functional Ajax enabled web page and it doesn't let up. Some of the examples are dynamic tool tips, textfield autocomplete, dynamic drop down lists, and my favorite, the progress bar. The elements of each example are well explained and easy to understand but aren't diluted with pages of theory and why's. This book is all how.

The last few chapters all deal with tools for the developer to help make Ajax development easier. It talks about Firefox extensions, JSUnit, and lightly touches on some Ajax frameworks though no working examples of any of the frameworks are shown.

The book was not without its faults, however. There are syntax errors lightly scattered throughout some of the examples. This was frustrating because I had to debug javascript for someone else's errors. The book also assumes a fair amount of Servlet knowledge and J2EE web app deployment know how. While I'm all for examples in Java, this does limit the books potential customer base. Ajax is pretty much server side technology agnostic. It can be used with ASP, PHP, J2EE, Ruby, and many others. And while the book does touch on this fact, newbies to Servlets will find running the examples difficult.

I whole heartedly enjoyed this book and it really wet my appetite for Ajax and how I can use it to improve my own applications UI and provide a better experience for the end user. I'd highly recommend this to anyone wanting to learn the "Foundations of Ajax".

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
October 2005
296 pages
Reviewed by Lasse Koskela, November 2005
  (8 of 10)


"Foundations of Ajax" is the first book I've read about the technology, regardless of the astonishing hype it has received lately. It was an easy read, I learned a lot, and, while I was left wanting something more, still, I'd say this is a great book for getting started on Ajax.

The first half of the book runs through a quick history of web technologies and gives a pretty balanced view on the "why" and "why not" of Ajax, explains the fundamental technologies and techniques, and showcases some typical Ajax features like auto-completion, auto-refreshing pages, and a file upload progress bar. While at times the pace of the discussion seemed a bit slow even for myself (not being too familiar with JavaScript in general), I found the fundamentals given on XMLHttpRequest and DOM to be very valuable in terms of understanding what's happening "under the hood" when using those fancy Ajaxian features.

The second half of the book is more focused on tooling. The authors have done a huge favor to the reader by showing how to debug and test JavaScript code, although I had to re-read a page or two of the jsUnit chapter after falling off the sled on how and where the tests are actually executed. The first appendix gets an honorary mention as well, as I found the list of cross-browser compatibility tips to be extremely useful.

The downside to the book, in my opinion, is that while the second appendix does enumerate a long list of Ajax frameworks, only Taconite (the authors' own framework) is presented in any detail. Frankly, I would've wanted to see the authors present even short examples of more "mainstream" frameworks such as Dojo and Prototype. Somewhat related to this, while after reading the book, I feel I have a good foundation for Ajax and would certainly be capable of putting together some fancy Ajax widgets, I'm afraid I wouldn't get as much "done" as I could if the book would've allocated more inches on using state-of-the-art Ajax frameworks. Having said that, I knew that that wasn't a goal for the book so it's not really too big an issue for me.

In summary, a great book for building a foundation on Ajax technology. Get it, read it, hack on some JavaScript, and then go learn the latest and greatest Ajax framework.

Discuss book in the Saloon — More info at Amazon.com


Apress
1 edition
October 2005
296 pages
Reviewed by Ernest Friedman-Hill, September 2005
  (9 of 10)


Ajax is an unusual beast. It's not a product. It's not a standard. It's not a tool. It's not a proper noun -- it's an acronym. Instead, Ajax is a collection of techniques for building highly interactive Web based applications using industrial-strength JavaScript and asynchronous communications, and it's taking the Web development world by storm. This is one of the first books to appear on this hot topic, and it's a good one.

"Foundations of Ajax" takes you through the whys and wherefores of Ajax, as well as the meat and potatoes, at a brisk pace. The examples are crystal clear. Multi-language code as used in Ajax is hard to describe clearly. Choosing a particular language for server-side code might have alienated some readers unfamiliar with that language. This book uses fixed XML files to sidestep the problem, which leads to startlingly simple descriptions.

I found the second half of the book even more valuable. The last few chapters talk about tools and techniques for building real-life professional-grade applications. There is excellent, detailed information about documenting, unit testing and debugging for JavaScript, debugging Ajax communications, and using some of the newfangled Ajax frameworks that have begun to appear. These chapters credibly demonstrate that it's possible to treat JavaScript as a Serious Programming Language.

In sum, I think that "Foundations of Ajax" is an excellent piece of work which belongs on every Web developer's bookshelf.

Discuss book in the Saloon — More info at Amazon.com


Ajax in Action
by Dave Crane, Eric Pascarello, Darren James


Manning Publications
1 edition
October 2005
680 pages
Reviewed by John Wetherbie, December 2005
  (8 of 10)


Ajax In Action is a code-driven introduction to the collection of technologies and techniques that are known as Ajax. The book has many code examples and the last five chapters take you through the development of some Ajax applications including combo boxes, type-ahead help, and adding Ajax to a portal site.

The authors emphasize that developers and architects need to have a different mindset when developing applications that use Ajax versus traditional web applications. An asynchronous (the first A in Ajax) web application will act differently than a traditional web application and needs to be thought about and designed differently. There will also be more JavaScript code to manage and the authors emphasize good coding and code management techniques.

I enjoyed the chapter on performance and the fact that it focused both on speed and memory use. The appendices cover Ajax tools for your toolkit, an excellent JavaScript overview, and Ajax-related frameworks and libraries. The appendices are really good but I appreciate that their information is located such that it does not break the flow of the book.

This book is a very good overview Ajax and its technologies. It assumes you are reasonably familiar with JavaScript, CSS, DOM, and how web applications work. My one complaint is the feeling that the discussion of patterns and refactoring for a developer not familiar with these tools was a little light and could have been beefed up a bit.

I received a complimentary copy of this book for review.

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
October 2005
680 pages
Reviewed by Jeanne Boyarsky, December 2005
  (10 of 10)


"Ajax in Action" is not only an excellent book on Ajax, but the best JavaScript book I have ever read. The authors note early on that Ajax is a process, not a technology. This theme permeates the book. There is an emphasis on requirements, design, implementation, testing and maintenance. So the book shows how to do a real project, not just how to code.

Keeping with the real project theme, there is information throughout on refactoring and design patterns. The authors present low level coding idioms as well. All this creates a language for coding Ajax applications. The second half of the book walks you through the entire development process for five sample applications.

The book targets a wide audience range, from enterprise developers to self-taught scripters. Basic concepts are explained concisely for newcomers and experienced developers may skim certain sections. However these sections are a very small part of the 600+ page book.

An appendix covers an introduction to JavaScript. While you would want to supplement it with materials from the web, it clearly covers the advanced topics that are hard to find elsewhere. There are also introductions and tips on CSS and DOM. In short, I learned a ton about non-Ajax development and page manipulations too.

And the book even has a screenshot of JavaRanch! I was expecting a good book when I saw Bear and Ernest's comments on the back. But it still managed to exceed my expectations!

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
October 2005
680 pages
Reviewed by Valentin Crettaz, September 2005
  (9 of 10)


Over the past months, the Ajax commando has been actively pursuing its revolution on the web petitioning for a richer and more standardized interaction model. Everyday, the commando manages to substantially increase its headcount by enrolling a growing number of frustrated developers who were promised to an execrable future.

With "Ajax in Action" out of press, the commando will now be able to drastically accelerate its evangelization process. The word is spreading that this book is a tremendously useful field guide specially written for developers in the trenches waiting for the killer solution that will help them build cutting-edge web applications of unprecedented quality. After showing how to switch from traditional to Ajax web development, the authors present the core techniques underlying Ajax as well as a couple design patterns and how these fit into the Ajax development model. Furthermore, the book also contains great best practices that can considerably enhance the user experience and that teach you how to design Ajax applications with security and performance in mind. The second part of the book is fully dedicated to presenting five hardcore examples (live search, etc.) whose main goal is to provide developers with ready-to-use off-the-shelf Ajax components that can be seamlessly integrated into any web application.

Whether you are frustrated by low tech web development or you are willing to discover how the potential of Ajax is greater than the sum of its parts, swallow this 600 pages bible and join the commando now.

Discuss book in the Saloon — More info at Amazon.com


Manning Publications
1 edition
October 2005
680 pages
Reviewed by Ernest Friedman-Hill, September 2005
  (9 of 10)


Ajax is a Web programming technique for developing rich, interactive interfaces using only JavaScript, HTML and CSS on the desktop. It's changing the landscape of the Web, and this book will help you gear up to be part of the revolution. Renaissance men David Crane and Eric Pascarello show you how to weave together the pieces that make up an Ajax application: JavaScript, server scripts, HTML, CSS, and XML. They teach you the tools and techniques you'll need to develop industrial-strength applications using JavaScript.

This is really two books in one: first, it's a look at the Ajax technologies and prescriptions for their effective use. There are detailed discussions of relevant design patterns and of strategies for designing usable and secure applications. There are substantial discussions of a number of Ajax frameworks, libraries, and development tools, as well as developer features of Web browsers that you've probably never learned about but can't live without.

The second half of the book is a cookbook, with detailed blueprints for concocting your own versions of several Ajax showcases: dynamic double combo boxes, typeahead select boxes, and Web portals with selectable, draggable portlets. There are even recipes for assembling standalone Ajax applications that use existing third-party Web services as a back-end. The cookbook builds on the earlier parts of the book by applying the design patterns and refactoring techniques therein described.

If you're serious about helping to revolutionize the Web, you need this book.

Discuss book in the Saloon — More info at Amazon.com


Prefactoring
by Ken Pugh


O'Reilly
1 edition
September 2005
238 pages
Reviewed by Jeanne Boyarsky, December 2005
  (8 of 10)


The term "prefactoring" is supposed to mean using things you learn from your own experience or the experience of others to improve new programs. The book "Prefactoring" revolves around approximately 70 requirements and design guidelines. The stated audience is anyone who understands the basic concepts of OO. It is good for a beginner who has read some or a practicing developer who wants a reminder of best practices.

Most of the book follows the development of a fictional system. The guidelines are sprinkled throughout as appropriate. The author is realistic in noting that many exceptions to the guidelines exist. A few are illustrated within the context of the fictional system. However, I found the user of some guidelines left much to be inferred by the reader.

The guidelines focus on abstraction, separation of concerns and readability. An appendix cross references them well. The fictional customer was realistic in demands, which was nice to see in a book. Overall, the book read well, was factually accurate and provided a good walkthrough of the thought process in a sample design. But on the book's focus of guidelines, it left me wanting more depth.

Discuss book in the Saloon — More info at Amazon.com


Succeeding with Use Cases: Working Smart to Deliver Quality
by Richard Denney


Addison-Wesley Professional
1 edition
May 2005
336 pages
Reviewed by Jeanne Boyarsky, August 2005
  (8 of 10)


"Succeeding with Use Cases : Working Smart to Deliver Quality" walks you through four quality engineering disciplines: quality function deployment, software reliability engineering, model based specification and use case configuration management. Most of the book is readable by project managers, while model based specification (pre conditions, post conditions and invariants) is of special interest to developers and testers.

As you can guess, the book assumes you already know about use cases. For the most part, the authors are good about going into detail without making any further assumptions of your background. Examples include concrete numbers and the diagrams are excellent. Once chapter does get theoretical and use algebra, but it is immediately followed by a practical application.

Personally, I found the reasoning and walkthrough of the ROI example to be most valuable. The book does read like a short textbook and academics are explicitly mentioned as one of the target audiences. However, you can tell the book is written by someone who has been through it personally. Overall, I found the book to be a valuable read.

Discuss book in the Saloon — More info at Amazon.com


Head First Design Patterns
by Elisabeth A. Freeman, Eric Freeman, Bert Bates, Kathy Sierra


O'Reilly
1 edition
October 2004
676 pages
Reviewed by David O'Meara, November 2004
  (10 of 10)


Make sure you read the introduction so that you know what you're getting into, and to realize you're getting into something great. Rather than being a group of books with little real point of difference, the Head First principles - outlined in the introduction - are geared towards presenting real problems and real solutions with real learning. But we're supposed to be talking about Head First Design Patterns.

The list of patterns presented is small compared to other books, but this works well since the coverage is more about learning the basic patterns well with a solid understanding. Also of great value is the way each pattern is taught by presenting common problems with the obvious, but wrong, solutions and then leading you out of the hole you dug and highlighting the important steps towards a better and more maintainable solution.

I was particularly impressed how the presentation of each pattern was built on solid Object Oriented concepts. But rather than assuming you know these advanced concepts, they are integrated into the learning exercise and presented as a cohesive bundle. The book is also structured so it refers back to and reinforces both the pattern and OO lessons as you progress.

It's hard to find real fault with the book. At times it jumps between topics, is repetitive and a bit irreverent, but this is all part of the formula and exactly what is promised.

Beginner or experienced, you better be careful or you might learn something.

Discuss book in the Saloon — More info at Amazon.com


Java Testing Patterns
by Jon Thomas, Matthew Young


Wiley
1 edition
October 2004
424 pages
Reviewed by Jeanne Boyarsky, October 2004
  (4 of 10)


"Java Testing Patterns" is one of those books where it appears nobody edited. Java class/method names and acronyms are used in lower/upper case interchangeably. Writing class names in all lowercase in a Java book doesn't inspire much confidence in the accuracy of the rest of the book. There are many typos and inconsistencies that make it hard to read.

The formatting is also very poor. The code looks good in Eclipse, but not in the book. Lines wrap without indentation. Similarly, UML diagrams are randomly split into pages. They are supposed to be on the web, but they aren't yet.

The intro states a target audience of "software engineers, engineering managers and software testers." This book is heavily reliant on reading code. After the first few chapters, I don't think managers or testers would benefit.

Speaking of code, I think the code is too verbose and complicated -- especially for a book. A few times, a simple JavaBean's source takes up one to two pages. One DAO takes up 12 pages. There is a test method with 16 branches. These examples make understanding quite difficult.

Now as for what the book does well. There are five good chapters on patterns. However, two are in essence the Factory and State patterns. The appendices are very good too. I wouldn't buy a book for three chapters and some appendices. Other books cover the material better. I would not recommend this book in its current edition.

Discuss book in the Saloon — More info at Amazon.com


Fearless Change - Patterns for Introducing New Ideas
by Mary Lynn Manns, Linda Rising


Addison-Wesley
1 edition
September 2004
273 pages
Reviewed by Ilja Preuss, October 2004
  (10 of 10)


Did you ever struggle to introduce a new idea at your workplace that would make everyone's life easier? Did you ever wonder how some people actually manage to introduce changes? Then this book is for you.

"Fearless Change" starts by explaining why change is so hard and what we typically miss when we approach change, followed by an excellent introduction to the broad concept of patterns in general.

The "patterns for introducing new ideas" are then introduced in a sequence of chapters, each dedicated to a specific phase of the change process - from testing the waters, over getting the first people on board, to convincing the masses and finally keeping the implemented change alive. One chapter solely discusses how to deal with resistance.

Four experience reports (one about the introduction of the J2EE patterns) then show how the patterns have been successfully used in concert. The third part of the book contains an alphabetical catalog, describing every aforementioned pattern in detail.

The whole book is quite entertaining to read, every chapter being to the point and at the same time filled with clever quotations and examples from the trenches. On each page you sense it's not only the experience of the two authors that is to your disposal, but also that of dozens of people they talked with during the years.

If you want to have an impact on how things are done at your workplace, you should put this book at the top of your reading list.

Discuss book in the Saloon — More info at Amazon.com


Refactoring To Patterns
by Joshua Kerievsky


Addison-Wesley Professional
1 edition
August 2004
400 pages
Reviewed by Corey McGlone, October 2004
  (9 of 10)


A high quality reference for those that want to gain some direction to their refactoring. That's what Joshua Kerievsky has managed to create with this book. This book assumes that you already know about refactoring and even states clearly that this book is best read with Martin Fowler's "Refactoring" as a reference. With that prerequisite in mind, this text does an excellent job of introducing the process of using refactorings to fix code problems by introducing patterns into your design.

Some of the strongest points include: editing, organization, and clarity. My hat goes off to the editor(s) of this book as I found very few errors even though this book contains a lot of "real world" code. Organizationally, this book does an excellent job of making itself useful as a "read-through" book for those that want to immerse themselves in the topic and as a reference book that can sit on your shelf until you need it.

One word of caution about this book is that it originally started as a paper and grew from there. Especially throughout the first few chapters of the book, this is very evident. Constant references to works done by other authors and numerous footnotes can, at times, become a bit distracting from the overall message.

Overall, this is an excellent book and, if you're into extreme programming and refactoring, it's one that you're going to want to have on your shelf.

Discuss book in the Saloon — More info at Amazon.com


Software Architecture Design Patterns in Java
by Partha Kuchana


AUERBACH
1 edition
April 2004
416 pages
Reviewed by Lasse Koskela, August 2004
  (9 of 10)


Design patterns used to be the hottest topic around a couple of years ago. One of the side-effects was the "Applied Java Patterns" book which I very much liked and used to recommend to anyone looking for a "GoF" replacement using Java for code examples. Not anymore. From now on, I'm recommending Kuchana's "Software Architecture Design Patterns in Java".

Why am I so pleased with this book? What makes it any different than other design pattern books? Well, first of all the volume is huge. Kuchana's book covers all the original Gang of Four patterns plus another 20 or so patterns, including a couple of multithreading related patterns. Second, the text itself is very readable and doesn't cling too much on fancy words. The explanations are concise and to the point. Further kudos goes to dealing with such frequently asked questions like the difference between Factory Method and Abstract Factory.

To list some things I didn't like about this book, I have to say that having exercises without sample answers in the back was a tiny disappointment and I would've preferred a bit more condensed font for the code listings. That's about it.

All in all, a very good choice for filling the gaping design patterns encyclopedia slot in your bookshelf. Highly recommended.

Discuss book in the Saloon — More info at Amazon.com


Fast Track UML 2.0
by Kendall Scott


Apress
1 edition
March 2004
350 pages
Reviewed by Dirk Schreckmann, May 2004
  (8 of 10)


As described on the back cover of the book, the target audience of Fast Track UML 2.0 includes folks with previous visual modeling knowledge, perhaps including UML 1.x experience. In the book, the author does not attempt to describe the differences between UML 2.0 and UML 1.x, or to point out the new features. Instead, in a content-packed 161 pages, Kendall, with a "fresh look" at UML 2.0, describes well what a typical developer would want to know about modeling with this improved language.

Normally, when a book's title tries to convey that it's going to teach me something "really fast" or "in just XX hours", I won't even pick it up. In this case, from reading a few of his previous books, I trusted that the author, Kendall Scott, had probably put together another good book worth reading, and he did. In this book, I was looking for something that would quickly bring me up to date with UML 2.0, while still serving as a good reference manual into the future, as I sit down for some fancy picture drawing, also known as visual modeling. This is that book.

I would definitely recommend this book to anyone looking for a well-written, easy to follow and understand, concise UML 2.0 reference manual. If you're a career designer, note that this book does not describe in full detail, the complete syntax of UML 2.0. That said, if you're drawing fancy pictures using syntax not described in Fast Track UML 2.0, then perhaps that's a sign that you're models are too detailed. If you're brand new to the study of OOAD looking to develop these skills, this book alone probably isn't what you're after, though it would still serve well as a supplement to another material geared towards teaching OOAD. As a bonus, the book is priced well.

Discuss book in the Saloon — More info at Amazon.com


Enterprise Patterns and MDA: Building Better Software with Archetype Patterns and UML
by Jim Arlow, Ila Neustadt


Addison-Wesley Professional
1 edition
January 2004
528 pages
Reviewed by Lasse Koskela, February 2004
  (8 of 10)


Enterprise Patterns and MDA is the third and latest book related to OMG's Model Driven Architecture. However, as the title implies, it's not all about MDA. In fact, the most significant focus of the book is actually patterns, specifically business patterns and archetypes.

The authors start the journey by introducing concepts and techniques such as archetypes (universal, recurring "things") and archetype patterns, and Model Driven Architecture. Furthermore, the authors have dedicated one chapter for describing a technique called Literate modeling (combining traditional visual modeling with an accessible business context provided via a narrative text, for example).

Up to this point (vicinity of page 116), the authors' writing style has been flawless, in my opinion, and easy to read. From chapter 4 onwards, the authors have provided a huge pattern catalog for archetype patterns. The catalog has been divided into chapters around archetypes such as Party, Order, Customer, and so on. Each archetype pattern introduces a business context, a high-level overview model, and descriptions of the related archetypes, their properties and related activities.

I didn't go through even nearly all patterns in the catalog. However, I feel confident that I will dive into the catalog looking for insight when moving to a new problem domain on a new project. Enterprise Patterns and MDA is a nice resource to have on your bookshelf.

Discuss book in the Saloon — More info at Amazon.com


Software Configuration Management Patterns
by Stephen P. Berczuk, Brad Appleton


Addison-Wesley Professional
1 edition
November 2003
218 pages
Reviewed by Ilja Preuss, October 2003
  (7 of 10)


How can a small to medium sized team effectively work on a shared code base, and still provide stable releases to the customer? That is the question this book deals with.

It starts with an introduction to configuration management and patterns. The following 16 patterns provide solutions to common problems and constitute the core of the book. Finally there is a short discussion of popular tools.

Parts of the text are a little bit dry and could have made use of more examples. The book also basically confines itself to the use of tools and ignores alternative, organizational solutions. By and large though, it contains well comprehensible information about an important topic.

Discuss book in the Saloon — More info at Amazon.com


Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
by Gregor Hohpe, Bobby Woolf


Addison-Wesley Professional
1 edition
October 2003
736 pages
Reviewed by Lasse Koskela, December 2003
  (10 of 10)


Enterprise Integration Patterns is part of Addison-Wesley's new Martin Fowler Signature Series, which Fowler's Patterns of Enterprise Application Architecture (PoEAA) is also a part of. I was very satisfied with PoEAA and the same can be said about Enterprise Integration Patterns. It has the potential to become a classic.

The authors' writing style is a pleasure to read -- no ambiguous statements, no unnecessary babbling. The book is structured to suit both cover-to-cover reading and a "dive-in" approach for situations where you're looking for a solution to a particular problem. After an introduction to the field of enterprise integration, and a discussion of why the book concentrates on the messaging integration style in particular, the reader is given a hierarchical catalog of patterns revolving around a small set of "core" patterns. The book's coverage is in my opinion very well scoped.

I must also praise the look of the book; besides the layout being familiar from prior works and the proven pattern catalog structuring, the authors have used graphics very efficiently. Not only the authors define a vocabulary for integration patterns, but they have also come up with an expressive visual language for illustrating the patterns using simple notations that can be easily drawn without CASE tools.

I found only two downsides for this book. First, the title can be slightly misleading as the book focuses on messaging as an integration style and only briefly mentions alternatives such as RPC, file transfer, and shared databases. However, I don't know a single person who doesn't read the back cover before buying a book, so I wouldn't count this as a big issue. Furthermore, the reason for focusing on messaging is thoroughly argued in the book. The second downside is the code examples, which are presented using varying languages and products and seem somehow disconnected from the text.

In summary, Enterprise Integration Patterns is a great book. It's worth reading and re-reading if you're working with systems integration projects or writing integration software yourself. Yet another book that makes me think, "I wish I had it back then..."

Discuss book in the Saloon — More info at Amazon.com


Data Access Patterns: Database Interactions in Object-Oriented Applications
by Clifton Nock


Addison-Wesley Professional
1 edition
September 2003
512 pages
Reviewed by Matthew Phillips, October 2003
  (8 of 10)


This book is an excellent addition to Addison-Wesley's Software Pattern Series. At some point every software application is going to have to access data. The patterns in this book will be invaluable when its time to write data access code.

I really like the book's organization. While you don't need to read it cover to cover, it makes it very easy to do by putting the most common patterns first. Using the decoupling patterns alone will allow me to greatly improve my code.

While all of the patterns are written with a relational database in mind, there is no reason why many of these patterns could not be applied to flat files or any other data store. The author left all the patterns open to easy interpretation in that sense.

This book is all about documenting data access patterns. If you are new to patterns, this is probably not the book you want to start out with. After you read a more introductory pattern book, you really should consider adding this book to your library.

Discuss book in the Saloon — More info at Amazon.com


Learning UML
by Sinan Si Alhir


O'Reilly
1 edition
July 2003
304 pages
Reviewed by Thomas Paul, October 2003
  (7 of 10)


O'Reilly publishes a selection of books as their "Learning" series. These books tend to be geared to the programmer or student unfamiliar with a technology who is looking for a good introduction. "Learning UML" is a worthy addition to this series. This book is not a complete introduction to the topic of UML diagrams but for the programmer or student wanting to get a good understanding of the basics of UML this book will serve very nicely.

The book starts with an explanation of why we model code and then gives a brief introduction to UML. The author then discusses the most commonly used UML diagrams. Class and object, use case, component and deployment, sequence and collaboration, state, and activity diagrams are each given a chapter. How and why each diagram is used is explained with sample diagrams designed to show the most common usage. There are exercises at the end of the main chapters with solutions for the exercises in the back of the book. The exercises are designed to help you to check whether you have understood the information in each chapter.

If you are looking to become an expert in UML then there are other books that will serve that purpose. At a little over 200 pages, this book gives enough information for most students and developers without overwhelming them with the multitude of diagrams that are available in the UML.

Discuss book in the Saloon — More info at Amazon.com


Enterprise Java with UML
by CT Arrington, CT Arrington


Wiley
second edition
June 2003
512 pages
Reviewed by Thomas Paul, June 2003
  (7 of 10)


This book takes you through the development of an application from proposal to implementation. In alternating chapters the authors explain the use of UML for a particular step in the development lifecycle and then demonstrate what they just explained to develop a sample timecard system. The best part of the book, which is not significantly different than the first edition, is the first half in which the authors discuss requirements gathering and object oriented analysis. The book is worth the price for this first part alone.

The second half of the book has been expanded to discuss new J2EE technologies. The chapters on evaluating technologies are good as far as discussing how to evaluate technologies but the actual analysis is weak as they ignore candidate technologies such as Struts in favor of their own homegrown HTML production framework. They also fail to explain why EJBs are a better choice for their sample application than simply using Servlets/JSPs/JDBC. The final section on design gets bogged down with too many pages of code listings and not enough explanations for the code.

Arrington has done a very good job explaining UML although some familiarity with UML notation (or at least a handy manual) would be helpful. If you already own the first edition then you can ignore this edition. If you don't own it then you will definitely want to read this book. This is a must have book for any Java architect/developer doing OOAD.

Discuss book in the Saloon — More info at Amazon.com


Wiley
1 edition
January 2001
480 pages
Reviewed by Thomas Paul, February 2001
  (9 of 10)


Trying to develop a Java application without first developing a model can lead to a poorly designed application that fails to fulfill the needs of users, lacks reusability, and is difficult to maintain. The Unified Modeling Language (UML) was developed as an open standard notation to assist developers in modeling OO applications. As enterprise developers we are finding that we are expected to be able to design applications using the UML, explain UML diagrams to our users, or be able to develop applications from UML diagrams. The UML can be difficult and confusing to use and many of the books available fail to clearly explain the proper use of this development tool. "Enterprise Java with UML", by CT Arrington is an excellent introduction into the complexities of the UML. Arrington takes us through the entire lifecycle of a sample EJB application (a timecard system) from requirements gathering to implementation. In alternating chapters he explains the use of the UML (use cases!, sequence diagrams, class diagrams, etc.) for that step in the development cycle and then uses what he just explained to develop the timecard system. Along the way we make technology decisions, develop our design, and ultimately convert our design into actual code. By the time we are done the UML has become a new tool in our toolbox. Arrington has done a very good job explaining the UML although some familiarity with UML notation (or at least a handy manual) would be helpful. This is a must have book for any Java developer wishing to learn the UML.

Discuss book in the Saloon — More info at Amazon.com


The Unusually Useful Web Book
by June Cohen


New Riders
1 edition
June 2003
408 pages
Reviewed by John Wetherbie, June 2003
  (10 of 10)


The Unusually Useful Web Book could have been titled The Book You Should Read To Help You Plan, Design, Build, and Maintain A Successful Web Site. Everyone who is on a team developing or maintaining a website should read this book and then re-read it frequently to keep the information and lessons fresh.

This book provides an overview of the processes, the techniques, and the technologies that can (and should) be used to develop and maintain a successful web site. If you are looking for an in-depth technical book on HTML, CSS, or other specific tools this is not that book. Buy this book anyway! It will be worth it.

The book is divided into four major sections: Planning Your Site, Designing Your Site, Building Your Site, and Maintaining Your Site. Each section has good information that you can use right now whether you are starting to create a new site or are involved in the maintenance and upgrade of an existing site.

A conscious effort was made to make the book look and feel like a website. This approach works very well. Sections are short, important points are highlighted, and I found myself following "links" to more in-depth information on topics that were of interest to me. This book lives up to its title by being full of unusually useful information and also being unusually readable. I think this book is going to be an instant classic.

Discuss book in the Saloon — More info at Amazon.com


Designing with Web Standards
by Jeffrey Zeldman


New Riders
1 edition
May 2003
456 pages
Reviewed by John Wetherbie, November 2003
  (8 of 10)


Designing with Web Standards by Jeffery Zeldman has two main points: 1) using web standards will save you and your clients time and money and; 2) you can achieve great effects by using web standards. The author takes the practical view that using web standards is a good thing but isn't dogmatic about it. The majority of examples in the book focus on a "hybrid" strategy that makes web sites compatible with older browsers by using tables to provide some of the layout structure in conjunction with CSS.

The first four chapters provide an overview of where web design has been and where it is currently with the advent of XML. Even if you aren't into history I highly recommend reading the latter part of chapter four for the pointers to resources on the web.

The second section focuses on constructing the design of a web site using the "hybrid" approach mentioned above. The reader is introduced to the differences between HTML and XHTML, to CSS, problems you will run into with various browsers and their solutions, accessibility, and the DOM. Designing a site only using CSS for controlling the presentation is the topic of the last chapter in this section.

I found the book an enjoyable read. This book is more for web designers who don't have much experience with CSS. I would also have liked the book to have more on "pure" CSS approaches but can understand the author's pragmatic viewpoint.

Discuss book in the Saloon — More info at Amazon.com


Core J2EE Patterns: Best Practices and Design Strategies
by Deepak Alur, John Crupi, Dan Malks, Deepak Alur, John Crupi, Dan Malks


Prentice Hall PTR
second edition
May 2003
528 pages
Reviewed by Thomas Paul, August 2003
  (9 of 10)


There are two obvious changes between this second edition and the first edition of this book. First, some new patterns have been added mostly dealing with web services. Second, the book has been released as a hard cover book, presumably because the publisher expects this to last on your shelf as long as the original "Design Pattern" book. The new patterns dealing with web services are a welcome addition to the book although anyone who is interested in this subject will probably want more detail such as found in Paul Monday's book.

Part 1 is an introduction to design patterns and the J2EE platform followed by a catalog of design considerations, bad practices and refactorings. Part 2 is the collection of design patterns and strategies. Each pattern is described in a format which will remind you of the GoF book. Since this has become the standard ormat for presenting design patterns this should not be a surprise. The patterns are well thought out, explained clearly, and demonstrated with some good code samples. If you have the first edition you will be very impressed with the improvements made in this new edition. It appears that virtually every pattern has been reworked to make the pattern easier to understand and use.

This is the book that every J2EE architect and programmer should have on their desk. Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.

Discuss book in the Saloon — More info at Amazon.com


Prentice Hall PTR
1 edition
June 2001
496 pages
Reviewed by Thomas Paul, November 2001
  (10 of 10)


Not another line of code for Servlets, JSPs, or EJBs should be written by anyone who hasn't read this book and understood the concepts explained. This book is about best practices in designing and coding J2EE applications. The lessons explained here were developed by the Sun Java Center based on their work in the field. As they developed applications for clients they noticed that the same problems occurred over and over again. This book documents the standard solutions to solve these problems that were built as a catalog of design patterns and best practices.

Part 1 is an introduction to design patterns and the J2EE platform. Part 2 is a catalog of bad practices (the authors describe these as, "less than optimal ways to solve problems"), and refactorings (ways to correct these problems). Developers working with poorly designed J2EE applications will find this section especially helpful.

In Part 3, fifteen separate design patterns and strategies are explained. Each pattern is described in detail with the motivation for using the pattern and the design goals to be achieved. UML class and sequence diagrams are included along with detailed code examples that serve to further clarify the pattern. These patterns aren't theoretical constructs but rather are practical strategies that can be applied to real world applications. Using the strategies in this book will make you more productive and your code easier to understand and maintain.

Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.

Discuss book in the Saloon — More info at Amazon.com


MDA Explained: The Model Driven Architecture--Practice and Promise
by Anneke Kleppe, Jos Warmer, Wim Bast


Addison-Wesley Professional
1 edition
May 2003
192 pages
Reviewed by Thomas Paul, October 2003
  (7 of 10)


If you are interested in Model Driven Architecture (MDA) but you don't have a clear grasp of what it is or where the designers of MDA see it heading then you might want to pick up this brief, well-written description written by three authors who are well acquainted with MDA.

MDA is the concept of using models developed using a modeling language (UML) to generate real applications. This book can be seen as a high level overview of MDA and at 150 pages it is a fairly easy and quick read. The authors show both what is available today (not too much) and what might be available in the future (perhaps all applications will be generated from models). The authors do try to make the book practical by showing how you can use modeling tools to at least build skeletons of code that can be the start of code development. MDA brings a new set of acronyms but this book explains each of them without too much pain.

So how much of what is discussed here is needed by a typical developer or designer? Probably not too much. But if you want to keep your eye on the future of IT then this book is well worth the read. Perhaps one day writing code will be thought of the same way we think of writing machine language. When that happens you will be able to say you knew it was coming.

Discuss book in the Saloon — More info at Amazon.com


Web Bloopers: 60 Common Web Design Mistakes, and How to Avoid Them
by Jeff Johnson


Morgan Kaufmann
1 edition
April 2003
344 pages
Reviewed by Jessica Sant, June 2003
  (9 of 10)


If you get paid to develop a website, you should have this book. As the title says, "Web Bloopers" (along with its companion website www.web-bloopers.com) details 60 of the most common (and annoying) design mistakes committed by web developers and then tells you how to avoid them.

Each blooper is explained in words as well as in pictures (snapshots are taken of various sites around the web), and then the author explains why the blooper is so bad and how to avoid it. As with any design, there are trade offs, sometimes you have to commit one blooper to avoid another, but as long as you realize that's what you're doing, you're gold. This book is very well organized. The title of each blooper is a good summary of the problem. The index in the back helps you to quickly find examples both good and bad (and it also lets you see if you're company has been made an example of) the author even points out some blooper's in his own publisher's website).

If everyone who is responsible for creating websites took the time to read this book, think about the user, how intuitive their site is, and how easy it is to glean information from it, the Internet would be a much nicer and friendlier place. I highly recommend this one.

Discuss book in the Saloon — More info at Amazon.com


Web Services Patterns: Java Edition
by Paul B. Monday


Apress
1 edition
April 2003
352 pages
Reviewed by Thomas Paul, August 2003
  (8 of 10)


Now that we have read all the books on the basics of web services and have a good understanding of how they are supposed to work it is time to get down to actually trying to create some decent designs for our web services applications. That is where this book fits in. The book shows how to apply design patterns to a web service architecture in order to solve common design problems. If you are designing a web service architecture you will want to read this book before drawing another UML diagram.

The book starts out by looking at the design patterns used in web services itself. This part of the book was interesting but not overly useful. The next part, making up most of the book, covers design patterns that you are likely to need in developing web applications. This part of the book is excellent. Each pattern is discussed in detail and then demonstrated in a case study that is developed throughout the book. The book covers twenty different patterns so there is bound to be one that is applicable to your application.

The book contains only snippets of code from the case study so you will need to download the code in order to get the full value of the case study. The reader of this book should be comfortable with web services and design patterns in general and be ready for an in-depth discussion of web services architecture.

Discuss book in the Saloon — More info at Amazon.com


JavaScript & DHTML Cookbook
by Danny Goodman


O'Reilly
1 edition
April 2003
576 pages
Reviewed by Eric Pascarello, May 2003
  (8 of 10)


JavaScript & DHTML Cookbook is a unique recipe that will teach you the most discussed topics in JavaScript and DHTML. The book is set up like a forum. A question is asked, the answer is given, and a discussion follows. The method this book follows is great for those who learn from vast examples on a broad range of topics.

The book looks at regular expressions, arrays, cookies, strings, objects, and much more on the JavaScript side. The DHTML side explains how multiple level menus are made, contextual menus, navigation trees, event handlers, validation methods, style sheets, and much more. The book discusses browser compatibility and problems that it may cause. In the discussion, solutions are proposed to counteract those problems.

This book is great for the person that wants to jump into the DHTML realm of programming and does not want the weighed down basics of JavaScript coding. This book will not teach you how to program JavaScript from the fundamental level, but it will teach you how to make scripts that are powerful and compatible!

Discuss book in the Saloon — More info at Amazon.com


How to Do Everything with JavaScript
by Scott Duffy


McGraw-Hill
1 edition
February 2003
448 pages
Reviewed by Eric Pascarello, March 2003
  (9 of 10)


"How to Do Everything with JavaScript" is a great book for everyone, from the beginner to the expert who needs a good refresher. This is one of many books on JavaScript I have read and this definitely will not leave my desk. "How to Do Everything with JavaScript" can be used as a reference for difficult topics, or a quick guide to the fundamentals of JavaScript. The book topics are covered in great detail with well thought-out explanations and examples. Classes, arrays, functions, objects, DHTML, browser compatibility, debugging your script, frame communication, and countless other things are delivered in manageable chunks which make this book a great resource. Many of the basic questions asked in the HTML and JavaScript forum can be answered just by reading this book!

Discuss book in the Saloon — More info at Amazon.com


Speed Up Your Site: Web Site Optimization
by Andrew B. King


New Riders
1 edition
January 2003
528 pages
Reviewed by John Wetherbie, May 2003
  (8 of 10)


Ever been on the web waiting for a page to download and thinking it was never going to finish? It's a pretty safe bet that the answer is "Yes". It is even possible that you are responsible for creating one of those pages (or even an entire website of them). If you want to make the webpages you create load faster, run, don't walk, to get Speed Up Your Site: Web Site Optimization.

This book presents techniques for optimizing your webpages by optimizing the HTML, CSS, JavaScript, and images that compose them. Speed Up Your Site shows you where and how to cut the unnecessary bytes from your pages. As the author says in the Introduction: "every byte counts." This book will make you stop and think about how you construct webpages.

The book starts with some theoretical background and then dives into optimizing HTML/XHTML, CSS, and JavaScript. The remaining sections cover optimization for graphics and multimedia, search engines, server-side techniques, and compression. There are also five case study chapters that provide additional insight into the techniques presented. The many references that point the reader to additional information are a very nice touch. I definitely learned a great deal reading this book and think you will, too.

Discuss book in the Saloon — More info at Amazon.com


Maintaining & Evolving Successful Commercial Web Sites
by Ashley Friedlein


Morgan Kaufmann
1 edition
December 2002
442 pages
Reviewed by Eric Pascarello, May 2003
  (8 of 10)


Maintaining & Evolving Successful Commercial Web Sites is for people that have a small commercial site and want to make it grow. The book talks about how to manage the data that your website contains and the data it receives from your customers. The book explains the importance of repetitiveness between each page of the site so the site can be easily navigated. This book explains in detail Customer Relationship Management (CRM) and how to apply it to your website. Also, there is a section on how to manage meetings with your client/boss so you are time efficient. The section I found very helpful was how to measure and report how your site is doing. It shows you what statistics are important and where you can get services to keep this information.

The book is laid out in four sections that can be read separately. It is an easy read and explains each topic in great detail. The book contains real-life examples and shows how they are implemented. This book will not tell you how to make a web page, but it will tell you the tools you will need to make it flourish.

I would also highly recommend this book to all the clients out there that own a website and have no clue what is going on. After reading this book, you will be able to ask your web designer questions on improving your site, you may even be able to understand what the web designer means when he throws XML, ASP, CRM, CMS, or CGI into the conversation. This book allows you to get more from your site while spending less time working on it.

Discuss book in the Saloon — More info at Amazon.com


Webmaster In a Nutshell
by Stephen Spainhour, Robert Eckstein


O'Reilly
third edition
December 2002
520 pages
Reviewed by Corey McGlone, February 2003
  (10 of 10)


Webmaster In a Nutshell is a conglomeration of reference materials for today's web developer. Nary a web development project goes by when you're not called on to remember something that you'd done so long ago that you can't quite remember how it goes. That's where this book comes in. Webmaster In a Nutshell covers everything from HTML syntax to dynamic content to server performance and everything in between. Keep in mind that this is not a become a webmaster in 24 hours book. Unless you've done a good amount of web development in the past, it's doubtful you'd get much out of this text. The reference materials are great, but this text is not designed to teach you to be a web developer. Rather, it's a handy reference for the jack-of-all-trades that is today's web developer.

The writing is very straightforward and little time is spent on introductions of topics. In most cases, a topic will have just a couple pages of introductions followed by many pages of reference materials. With the exception of PHP and XML, which are covered heavily in this text, it's doubtful that you'll learn any technologies from scratch with this book. However, as a reference for technologies that you already have experience with, this book succeeds brilliantly. It covers a wide range of technologies and is remarkably complete and concise everything a webmaster could would want in a reference text.

Discuss book in the Saloon — More info at Amazon.com


Apache: The Definitive Guide
by Ben Laurie, Peter Laurie


O'Reilly
third edition
December 2002
536 pages
Reviewed by Matthew Phillips, February 2003
  (5 of 10)


If you are looking for reference material to sit on your bookshelf, you can't go wrong with this book. If you want learning material this book might help, but I would look elsewhere.

The title is very descriptive. All the directives are in here and organized pretty well to make a great reference. There are sample configuration files throughout the book so that you may see how the directive should look. The book covers extending Apache with Perl scripts, PHP, Java, and Cocoon.

I did have some problems with this book. Although the back cover refers to it describing Windows support, I found the coverage of using Apache on Windows to be lacking. The coverage of connecting Tomcat to Apache used Tomcat 3.2. There was also an obvious bias on the part of the authors against Java technology. I downloaded the source code, but there were no instructions on how to unarchive it in Windows or how to use it. I am sure I will refer to this book when I need to know something about Apache, but if you really want to learn the ins and outs of Apache to become a professional webmaster then look elsewhere.

Discuss book in the Saloon — More info at Amazon.com


Java Enterprise Best Practices
by Jason Hunter, Bret McLaughlin, Hans Bergsten, et al


O'Reilly
1 edition
December 2002
288 pages
Reviewed by Ajith Kallambella, March 2003
  (8 of 10)


An appetizer that leaves you hungry for more.

Patterns and best practices have been around for a long time. They solve problem domains not directly addressed by the language itself ie., repeatable solutions to family of application development issues -- be it architecture, deployment or testing. For a complex platform like J2EE, use of best practices can make or break a project.

Just what the doctor ordered - Java Enterprise Best Practices is a collection nuggets of wisdoms. It is a compendium of idioms classified based on various enterprise Java areas written the most acclaimed authors in the field (Jason Hunter, Bret McLaughlin, Hans Bergsten et al). Ranging from most widely used EJBs to the latest additions such as JMX and JSTL, each chapter presents the reader with most widely accepted norms of using technologies such as - EJB, Servlets, JDBC, XML, RMI, JMX, Internationalization, JSP, JavaMail. Chapters on XML and RMI are the best of the lot.

I was surprised to note the omission of JMS, given that its popularity when compared with other things such as JMX or JSTL. The last chapter on performance tuning lacks depth and reads more like hastily scribbled notes.

Can best practices be argued? Absolutely! The first chapter of the book says just that. It is important to bear that in mind while you read through the chapters.

While a seasoned J2EE developer idioms may find a few things trivial, it is quite a good reference to keep handy if you are developing real-life applications.

Discuss book in the Saloon — More info at Amazon.com


Patterns of Enterprise Application Architecture
by Martin Fowler, et al


Addison-Wesley Professional
1 edition
November 2002
560 pages
Reviewed by Junilu Lacar, March 2003
  (10 of 10)


Simply put, you can't go wrong with a Martin Fowler book and this one is no exception. If you climbed the mountain to get advice from the IT guru at the top, he'll probably quote from this book.

Born on the web and rarefied by reviews and discussions with Fowler's colleagues and peers, including JavaRanch bartender Kyle Brown, this book is full of ideas that will help you make decisions related to enterprise applications architecture.

Writing in the same easy-to-read style as his past works, Fowler presents over fifty patterns that are mainly focused on layered architectures. And while Fowler readily admits that none of the ideas are new, developers, experienced or otherwise, will nonetheless benefit from the collective wisdom and experience of Fowler and all who contributed to the book.

To get the most out of this book, be sure to read the introductory chapters and understand the author's intent. There are many code examples, mostly in Java with a few in C#. I doubt though that you can use the code without some sort of tweaking; they are all meant to show the core of the pattern. Ultimately, you have the best understanding of your requirements and you have to make the decisions that affect your application's architecture. To paraphrase Fowler, don't use the examples as glorified macros but as a way to stimulate your own thinking. And believe me, this book has more than enough to get you thinking.

Discuss book in the Saloon — More info at Amazon.com


Addison-Wesley Professional
1 edition
November 2002
560 pages
Reviewed by David O'Meara, March 2003
  (9 of 10)


It's a patterns book, it's by Martin Fowler, and it's good. But how good is it?

It is actually two books in one. This is discussed in the book, but the second half is a list of patterns including the information required to make them useful. Reasonably standard, except that the patterns are presented in a language neutral manner that gives Java developers a view into the .Net world and vice versa.

The best part is still the first section. There is a general discussion on enterprise applications including common problems and ways to solve them depending on the way it shows up in your application. Not all of it will be new to everyone, but I'd challenge anyone not to learn anything. Even if you don't agree with all the solutions posed, it has very concise coverage of the problems.

There appeared to be the assumption of a respectable level of experience in the reader, so the book may not be useful to programmers with less than 3-5 years under their belts. This isn't necessarily a down side, but it should be considered if you're considering purchasing the book.

Now a small complaint. Although the first section was great, it discussed the patterns from the section in too much detail. There were some patterns I wasn't familiar with and some that I knew by different names, and it made some sections confusing.

Still well worth a place on the shelf.

Discuss book in the Saloon — More info at Amazon.com


Agile Software Development: Principles, Patterns, and Practices
by Robert C. Martin with contributions by James W. Newkirk and Robert S. Koss


Prentice Hall
1 edition
October 2002
529 pages
Reviewed by John Wetherbie, January 2003
  (9 of 10)


Agile Software Development is a great Object-Oriented Design book that presents it's subject in the context of Agile Development. The book delivers solid design and programming advice in a very "light" style. Not light in that it avoids technical detail! No, Bob seems to have taken the principles of agile development and applied them to the art of technical book writing.

The book is divided into six sections and has four appendices. There are many UML diagrams and lots of code examples in C++ and Java. If you don't know UML two of the appendices will introduce you to it. The book takes a top down approach. You are first given a quick overview of agile development practices. I particularly liked the Testing and A Programming Episode chapters from this section. The second section presents five high-level design principles that every developer should learn and apply.

Case studies dealing with a payroll system, weather station software, and testing software are then presented. Each case study section starts by discussing the design patterns that will seen in the case study. Section Four discusses subdividing the payroll system into packages. Six principles and a set of package Dependency Management metrics are covered. The book wraps up with the two UML appendices mentioned above, a comparison of two imaginary developments, and an interesting article by Jack Reeves.

In my opinion Agile Software Development Principles, Patterns, and Practices is the best OOD book out there.

Discuss book in the Saloon — More info at Amazon.com


Bug Patterns In Java
by Eric Allen


Apress
1 edition
October 2002
264 pages
Reviewed by Sujatha Rajagopalan, October 2002
  (7 of 10)


"Aim to write programs that are bug free". It is easier said than done.This book will be of special help to the Java developers and programmers who aim to develop robust programs. As developers and testers of Java applications multiply every day, it would come very handy to give them the symptoms and clues to detect a bug and make sure the code takes care of it smoothly. Several bugs go undetected in the real world due to the lack of time allotted for testing and debugging due to financial and other constraints. The author has thrown light at the importance of unit testing and debugging and explains a scientific approach to the same. He recommends extreme programming techniques to make the debugging process very simple yet sufficient.

The core portion of the book has a good structured approach to attach unique names to each bug and explains the symtoms and cure too. The initial part of the book concentrated on why debugging and testing was important. There was a big jump when the author goes into more technical details in Java codes and examples. Thats where the reader who has only a minimum knowledge in Java gets lost. This book cannot be recommended to developers in their learning phase. It focuses only on the audience who are Java literates who have been intensively coding in the same. It can be recommended for those Java programmers who want to become better Sherlock Holmes in detecting bugs in Java !

Discuss book in the Saloon — More info at Amazon.com


Information Architecture for the World Wide Web
by Louis Rosenfeld, Peter Morville, Louis Rosenfeld


O'Reilly
1 edition
February 1998
202 pages
Reviewed by Frank Carver, October 2001
  (8 of 10)


This is a relatively slim book with a clear focus. It's not about web page design - it's about web site design. In particular it's about designing a scalable site where information is well organized, consistent and easy to find.

This specific topic is covered in great depth, and includes all aspects of categories and labelling, navigation, searching, links and layout. It also covers the process of researching and deciding on who and what a web site is for, and managing the practicalities and politics of getting a large and complex site up and running.

The authors are librarians and information architects, and it shows. The style is dry and to-the-point, with relatively few illustrations. This book won't help you build beautiful sites, or implement database-driven "web applications", but if you want users to be able to find the information they need, this book is a vital addition to your bookshelf.

Discuss book in the Saloon — More info at Amazon.com


O'Reilly
second edition
August 2002
486 pages
Reviewed by Margarita Isayeva, June 2003
  (7 of 10)


The second edition is about twice as long as the first. The first part of the book covers the same ground as the first edition. I was somewhat less enthusiastic about this than Frank. Since the first edition was published, this subject has had some (albeit scattered and cursory) coverage in other books and articles, and many things now seem self-evident. I did find that classification of information seeking behaviors -- browsing, searching, and asking questions provides a useful mental framework; and the hierarchical vs. faceted classification approach has interesting parallels with Object-oriented vs. Aspect-oriented programming counterparts. Other than that, the first part lacks the "A-Ha!" effect that I usually look for in books.

Chapters added in the new edition discuss the process of building an information architecture. Here the discussion is centered on methodological, political and business issues in large organizations and is more useful for someone who wants to become a professional Information Architect than for a general audience.

I would define the book's genre as "textbook": it introduces the main concepts in Information Architecture and teaches the vocabulary of this professional community. When I subsequently came across the "Boxes and Arrows" site, I found that I could understand its vernacular without problems.

Discuss book in the Saloon — More info at Amazon.com


XSL FO
by Dave Pawson


O'Reilly
1 edition
August 2002
264 pages
Reviewed by Mark Spritzler, October 2002
  (6 of 10)


XSL:FO is about taking XML documents and transforming them into XSL:FO documents which can then be sent to an FO procecssor to create PDFs or other print formatting documents.

It focuses on the tags and properties of XSL:FO. This book does not cover using it with your Java programs.

After trudging through a reading of O'Reilly's book on XSL:FO, I have determined that this is not a book to read straight through. I have also determined that this is not a good book to read if you are a beginner to the XSL:FO world.

This book is very detailed and covers all aspects of XSL:FO. It reminded me of the time I had read O'Reilly's UML in a Nutshell. Their examples are hard to picture, and therefore were difficult for me to understand. Maybe this is because I am a visual person. Even so, This book seems to be a great reference book to use when you are creating XSL:FO documents to transform. However, from my inexperience with XSL:FO I could not determine how valuable a reference it would be.

I would highly recommend buying this book only if you have XSL:FO experience and can grasp it's concepts quickly and need a good reference book. However, if you are a beginner like myself, I would look to some of the good tutorials that are online, or in a good magazine like Java Developer's Journal.

Discuss book in the Saloon — More info at Amazon.com


Writers' Workshops & the Work of Making Things: Patterns, Poetry...
by Richard Gabriel


Pearson Education
1 edition
June 2002
288 pages
Reviewed by Kyle Brown, July 2002
  (9 of 10)


Every fall, just after school starts, some of the finest minds in object-oriented programming depart for an extraordinary conference in an improbable location. Held at a turn of the century mansion hidden among the corn fields of central Illinois, the PLoP (Pattern Languages of Programs) conference is one of those rare, magical events where everything you know about the way the software world works is turned on its head.

Instead of "acolytes" gathering around the feet of the "master" to hear the same talk that he gives at every other conference, experienced folks like Richard Gabriel, Ralph Johnson, Kent Beck and Ward Cunningham sit and give personalized advice about how the patterns and pattern languages written by first-time authors can be improved and strengthened. It's a place where you might find out one of your dinner companions has written four books on OO design and speaks at conferences twelve times a year, while the other is a new graduate student just getting started in the field.

How does this occur? And why do people keep coming back year after year? The key is in the primary innovation of this conference -- bringing the notion of an Author's Workshop to computer science. Richard Gabriel is the person who introduced that idea to the computer science community, and he writes lucidly and joyfully about the wonder and the terror of Author's workshops in this delightfully agreeable little book.

In this volume, Richard describes how the Author's workshop came out of the creative writing and poetry community, and provides a roadmap for carrying out a writer's workshop. He describes the benefits of the process, and gives sage advice to the participants in such workshops. He draws his stories and examples from his varied experiences in workshops in both communities (software and literature) and explains why such an unlikely way of doing things has come to be so valued and cherished by the software patterns community.

So, if you've wondered why people in the software patterns community are so set on the way they run their conferences, read this book and you'll understand why. But that's not the only value; reading this book can give you insight into how to improve your own writing in any genre, and how to marshall the resources of your communities to improve the quality of your work. I'm hooked on this process, and I'm delighted that I finally have something to refer people to so that I can share some of the magic of this unconventional way of teaching, and learning.

Discuss book in the Saloon — More info at Amazon.com


J2EE Design Patterns Applied
by Matjaz Juric, Nadia Nashi, Craig Berry, Meeraj Kunnumpurath, John Carnell, Sasha Romanosky


Peer Information
1 edition
June 2002
450 pages
Reviewed by John Wetherbie, December 2002
  (8 of 10)


This book presents J2EE design patterns from Sun and TheServerSide.com for developers and architects creating J2EE-based systems. I really like the way the patterns are presented with a fair amount of code to flesh out implementations (or "instances") of each pattern.
The patterns are grouped by tier/usage which is helpful if you are looking for patterns in a particular area. The discussions about why you would want to use a specific pattern and items to keep in mind when using it are very nice. My only complaint, and it is a mild one, is that each of the chapters that deal with a tier or aspect could be expanded into a separate book. (Hint to publisher... ;-))
This is a very good introduction to J2EE design patterns. If you want help in designing your J2EE systems in regards to security, scalability, and modularity this book will help you achieve your goals.

Discuss book in the Saloon — More info at Amazon.com


Son of Web Pages that Suck
by Vincent Flanders


Sybex
unknown edition
April 2002
320 pages
Reviewed by Salman Halim, October 2003
  (8 of 10)


This book teaches the reader about what constitutes good Web site design and is the sequel to "Web Pages that Suck"; it does this primarily by way of negative examples: sites where the design is somehow flawed. Then, specific explanations of why the design is wrong are presented; this is accompanied by guidelines on how to fix some.

The book doesn't stop with just a series of Web site snapshots with large red crosses through them; there are general guidelines on how one can design a site to avoid the problems outlined. Each chapter ends with a summary of the more important points from the chapter. One of the features I enjoyed is the "Two-Minute Offense" sidebar where a specific Web page's snapshot is shown and the user is told to examine it for two minutes and try to spot all the problems -- an explanation of each problem the author spotted follows.

The companion CD contains several shareware utilities as well as all the links mentioned in the text -- because of the nature of the Web, some of the links are no longer valid and some of the Web sites mentioned in the book have changed their look. (Several did so after appearing on the author's site!)

The only thing that rubbed me the wrong way were the somewhat (intentionally) creepy photos of the author in various poses and garb on all the sidebars; they are meant to be amusing, but I just found them creepy.

Discuss book in the Saloon — More info at Amazon.com


Design Patterns Java Workbook
by Steven John Metsker


Addison-Wesley Professional
1 edition
April 2002
496 pages
Reviewed by Matthew Phillips, July 2002
  (8 of 10)


If you are a beginner to design patterns, this book is not intended for you. This book is intended as a supplement to on of the other design pattern books and in particular the GoF book. If you have read one of the other books and feel comfortable that you can recognize the patterns when you come across them and feel that you have developed a solid foundation then you do not need to read further. This book is not for you.

If you are like me and found that you need to read more to build your design patterns foundation then this book is excellent for that. I found that the best use for me was to read a pattern in the "GoF" and then read the pattern in this book.

I did find a few problems with the book. Some of the exercises seemed a little off track for a design patterns book, although they were still good exercises. There were also a few typos. The book is a pretty quick read with lots of diagrams and sample code.

Discuss book in the Saloon — More info at Amazon.com


Applied Java Patterns
by Stephen Stelting, Olav Maassen


Prentice Hall PTR
1 edition
January 2002
608 pages
Reviewed by Michael Ernest, March 2002
  (9 of 10)


If you're unsure how to apply design patterns to Java, this book provides a solid, methodical, but gentle introduction to the practice.

This guide uses the classic design patterns first decribed by the GoF book. For each pattern, the authors provide a fresh motivation (writing a Personal Information Manager application), and rationale for matching a program feature or function to an appropriate pattern. The book seems best suited for those who need to learn definition and application in Java by example.

There's no CD-ROM; bummer. At a $45 list price, I think code-intensive books should offer one. This code is available by FTP, but, since my local firewall prohibits that, I find fault with the publisher for the inconvenience.

In the interests of full disclosure, I know Stephen and Olav personally. It's a pleasure to see them do what a number of us have been avoiding. This book needed to be written, but doing it well requires the diligence of a methodologist and the patience of a researcher. They've done very good work despite the tedium of building the book. Any aspiring program designers will find their time reading it well rewarded.

Discuss book in the Saloon — More info at Amazon.com


The Essence of Object-Oriented Programming with Java [tm] and UML
by Bruce E. Wampler


Addison-Wesley Professional
unknown edition
January 2002
320 pages
Reviewed by David Vick, March 2002
  (7 of 10)


This is a very basic and introductory book into some of the principles of object oriented programming with a nod to the Java language.

The intended audience is for semi-experienced Java programmers or programmers experienced in other languages who want an introduction to object oriented programming. If you are familiar with Java you can safely skip chapter 3. In trying to cater to other languages the book can be misleading in respect to Java. If you are coming from another language, you can just skim that chapter to pick up the basics but they are not fundamental to the rest of the book.

Over all the book is a quick, down and dirty, intro to some of the principles of OO analysis and design. At only 266 pages of actual text, it does not have the space needed to go into depth or to even give many examples. The author does do a good job of explaining the basics of UML and the notations used in different UML diagrams.

As an introductory text this book is sufficient, but if you are looking to learn more in depth you will need another book with more examples and a more detailed discussion of the various topics.

If all you are looking for is the basics or a good start into the subject then this would be a good book to start with. It will give you a solid foundation on which to build your knowledge of OO analysis and design.

Discuss book in the Saloon — More info at Amazon.com


Java Design: Objects, UML, and Process
by Kirk Knoernschild


Pearson Education
1 edition
December 2001
257 pages
Reviewed by Junilu Lacar, May 2002
  (4 of 10)


At first glance, this book looks promising. It has all the right stuff listed in the table of contents: general principles of object-oriented design, patterns, refactoring, incremental development, UML, RUP, and even XP. Don't be fooled though because the actual discussion is introductory at best with an almost incidental treatment of Java and how it ties in with the UML, modeling, designing, and creating what the author likes to call a "resilient architecture."

While the book discusses a lot of things that you should know about OO design, UML and iterative development processes, it lacks the focus and depth needed for it to be truly useful. The discussion on UML and design revolves mainly around two use cases and there are very few other examples. Most of the time the author is introducing a new concept and constantly referring to other parts of the book where it will be or has been discussed in detail. However, when I got to the end of the book I was still expecting more detailed discussions and had to go back to see what I missed.

You'll probably get more bang for your buck with Martin Fowler's books on UML and refactoring and Craig Larman's book on UML, patterns and the Unified Process. These books are filled with the examples that "Java Design" sorely lacks. For OO design principles, read the articles by Bob Martin published on http://www.objectmentor.com.

Discuss book in the Saloon — More info at Amazon.com


JavaScript: The Definitive Guide
by David Flanagan


O'Reilly
fourth edition
December 2001
900 pages
Reviewed by David O'Meara, April 2002
  (8 of 10)


This book is for programmers. The coverage of the various core-programming practices is fairly light and is usually explained in comparison to Java. It won't teach you how to code with JavaScript if you don't have something to base it on. This lends itself to programmers, who don't necessarily want to drown in familiar concepts. The down side is that the book is less likely to be useful to nonprogrammers.

The previous version of the book focused mainly on the uses of JavaScript in browsers. However the new version treats JavaScript as a complete language, with extensive coverage including DOM and CSS.

The book still has one of the most concise listings of functionality and browser compatibility, which is its greatest asset. It is an invaluable resource when you need to build some stable and compatible code. This is even more important with the recent changes in Netscape6.

Providing sample code isn't the primary aim (although there is still a bunch), but combined with the other resources available on the internet it should be all that someone with existing Java skills requires to build what they need using JavaScript.

A simpler coverage might make life easier for you in the short term, but this book will help you do whatever you want, whenever you want. If other books feed you for a day, this book won't feed you for a lifetime, but it'll stand by you until the next version.

Discuss book in the Saloon — More info at Amazon.com


Content Critical
by Gerry McGovern, Rob Norton


FT Press
1 edition
December 2001
256 pages
Reviewed by Frank Carver, September 2003
  (7 of 10)


This book is primarily about web site design, although that may not be very obvious from the title.

The overall premise is that the job of producing and running a web site has a lot in common with traditional paper publishing. Central to this idea, and the inspiration for the title, is that whatever the site, people actually visit it to read words. Not to look at pictures. Not to admire layout or coo at dynamic navigation menus. To find and read content. Everything else is at best irrelevant, at worst a distracting nuisance or even a reason to leave the site completely.

I wholeheartedly agree with this, and generally follow with the recommendations that the author makes about how to encourage and profit from this understanding: keep things simple, short, and fresh; understand your readers; make it easy to find stuff; treat editing and publishing as key business functions and so on.

What I find slightly disappointing is that the book itself doesn't entirely embody these values. The style is repetitive and often long-winded. As a well-edited web site or a conference presentation this would pack a much more powerful punch. I finished reading it mostly out of duty.

Discuss book in the Saloon — More info at Amazon.com


Java and UML
by Paul R. Reed Jr.


Addison-Wesley Professional
1 edition
November 2001
504 pages
Reviewed by Ersin Eser, December 2001
  (5 of 10)


UML Topics discussed in this book stay on a conversational level related to OOAD and Unified Process (UP). A conceptual understanding of the topics occurs at very basic level, but it will not enable you to create diagrams related to this area. UP is discussed extensively throughout the book.

Regarding JAVA the author talks (cursory level) about JSP, Servlets, JavaBeans and EJB. Code is included which uses these technologies. If you don't know these topics, you will learn the basic conversational-level knowledge of the concepts. If you already know them, nothing new is added.

If you are a developer without OOAD knowledge, this book is a great warm-up book for you. It will encourage you to take the next step. If you are a non-technical reader and trying to understand all these new acronyms, terms, and concepts, this is a great book for you buy it.

Discuss book in the Saloon — More info at Amazon.com


Applying UML and Patterns
by Craig Larman


Prentice Hall PTR
second edition
July 2001
656 pages
Reviewed by Junilu Lacar, June 2002
  (9 of 10)


Craig Larman has outdone himself. This edition, with its many changes and new sections, is really almost a rewrite rather than an enhancement.

This edition uses the Unified Process (UP) as a sample iterative process, replacing the first edition's generic set of Recommended Process and Methods (RPM). Many of the changes in the text and diagrams revolve around this shift. If you don't use UP, don't worry: the material is still very relevant since the basic ideas can apply to any iterative development process.

Java programmers will also feel right at home since the code examples are in Java. If you use another object-oriented language, you should still be able to follow the discussion. Larman expands his discussion of object-oriented design principles and the General Responsibility Assignment Software Patterns (GRASP) introduced in the first edition, particularly the "Don't Talk to Strangers" pattern which has been incorporated into the more general "Protected Variations" pattern.

Other changes include updating use cases to follow the approach popularized by Alistair Cockburn and including a third iteration in the POS System case study. My favorite addition was the new "You Know You Didn't Understand..." sections. They listed common misconceptions about various UP concepts-" a useful aid to quickly review your understanding of the preceding sections.

If you read the first edition, you'll probably want to read this one, too. Highly recommended for anybody who wants to learn the basics of UML and iterative OOAD.

Discuss book in the Saloon — More info at Amazon.com


Patterns for Time-Triggered Embedded Systems
by Michael J. Pont


Addison-Wesley Professional
1 edition
July 2001
1024 pages
Reviewed by John Volkar, December 2001
  (10 of 10)


Not your typically software patterns book. Real engineering, hardware and software making stuff happen! Yeah!
Probably the best example that I've ever seen of how patterns should be described and discussed, clear, concise, and with sufficient background to make each pattern feel meaningful and complete.
While this book deals specifically with the 8051 family of microcontrollers, almost all of the patterns given are generally applicable to any microcontroller family.
Even if you're just a software engineer, and even if you don't do embedded work, at least half of this book contains information that will pique your interest, and cause you to rethink some of your assumptions.
Pretend that you have to write an embedded program that responds in real time and has a bounded response window. Now you have the choice of a preemptive or cooperative scheduler. (For all you nonhardware folks: A scheduler is a microoperating system that you either buy of build yourself for your microcontroller.) I'd say most folks would choose the preemptive scheduler. Needless to say, the patterns in this book give clear guidelines as to which to choose and when. Furthermore, they illustrate that for the most reliable (most predicable) operation, a cooperative scheduler is probably a better choice. Now think about some business systems architectures, response times, latency, liveness, robustness, the discussions on embedded schedulers have relevancy!
The world needs more books of this caliber and utility. If you're even remotely interested in embedded systems, GET THIS BOOK!

Discuss book in the Saloon — More info at Amazon.com


Design Patterns Explained: A New Perspective on Object-Oriented Design
by Alan Shalloway, James R. Trott


Addison-Wesley Professional
1 edition
July 2001
368 pages
Reviewed by Margarita Isayeva, October 2001
  (10 of 10)


I was going to say "read this book", put a period and finish my review, but they didn't allow me to.

This book is a very well written introduction to patterns. Read it before GoF and Cooper books. Read it after, if you want to understand what GoF and Cooper books are about.

I was going to say "this book is more about good design than it is about patterns", but this would be senseless - patterns are good design. This book doesn't teach you how to "use patterns", it does better - it teaches how to find a good design.

It maps a conceptual level of thinking about design - "good design principles" with an implementation level that happened to be patterns. Reading about design principles when you do not see how they work on concrete code examples isn't particularly insightful. Looking at good code if you do not understand principles that underlie it doesn't help either - only makes you puzzled why it is designed in such a weird way? The magic of this book comes from mapping and tying together these two levels of thinking. It liberates your mind from thinking on implementation level ("nouns are classes, verbs are methods") and allows you to think conceptually - "see the forest and the trees" in authors words.

"At this final stage, the patterns are not longer important... The patterns have taught you to be receptive to what is real" - C.Alexander speaking from the last pages of Design Patterns Explained.

Discuss book in the Saloon — More info at Amazon.com


Hack Proofing your Web Applications
by Jeff Forristal, Julie Traxler


Syngress
1 edition
June 2001
608 pages
Reviewed by Frank Carver, October 2002
  (8 of 10)


This book aims to be a "one stop shop" covering all aspects of web application security, however your app is written: Java. CGI, Perl, PHP, Active X. To a large extent it succeeds, and in a surprisingly readable way. Each chapter covers on aspect of hacking or security, and ends with a summary, a "fast track" checklist, and a FAQ for the topics covered. The book is sold like software - you can register for a "1-year upgrade", to keep the content fresh.
Important topics include both detailed and general hints on how to read and spot security holes in code in different languages; and how to "think like a hacker", and use hacker tools to test your own security. Above all, the book emphasizes the need for creative thinking and to avoid producing code carelessly.
I know from experience that security is often ignored if it's seen as too hard to understand, plan or test. Don't be a victim of your own ignorance, read this book.

Discuss book in the Saloon — More info at Amazon.com


Software Fundamentals: Collected Papers by David L. Parnas
by Edited by David M. Weiss and Daniel M. Hoffman


Addison-Wesley Professional
1 edition
April 2001
688 pages
Reviewed by Jessica Sant, June 2003
  (9 of 10)


Anyone who considers themself a Java developer should know who Dave Parnas is. Without the insight of Dave Parnas in the 60s and 70s there would be no such thing as the Java programming language. Ever heard of information hiding (the basis for all Object Oriented programming)? Yeah, Parnas came up with that. Exception Handling? That's him too. Interfaces? Parnas. (Get the idea?)

This book reprints 33 of Parnas' most influential papers. Each paper is started off with an introduction from one of Parnas' peers (like Barry Boehm), giving the paper a connection to the modern state of Software Engineering, and trying to give the reader an understanding of just how seminal the particular paper was to the world of Computer Science and Software Engineering.

I believe you become a much better programmer if you understand where things come from. Once you understand how things were before "Information Hiding" came about, you get a better appreciation for why its such a necessary and important practice. You'll become a better programmer because you're more aware of what would happen if you didn't have exception handling. And you'll be come a better writer when you understand why buzzwords can be so dangerous in technical papers.

Dave Parnas has been a huge influence over the world of Software Engineering. Everyone should have the chance to read his work.

Discuss book in the Saloon — More info at Amazon.com


Java Enterprise Design Patterns: Patterns in Java Volume 3
by Mark Grand


Wiley
unknown edition
February 2001
416 pages
Reviewed by David Vick, April 2002
  (9 of 10)


This is an very well-written book on Enterprise design patterns. Mark Grand presents his topics very clearly and describes each pattern he discusses in detail. The book starts with a thorough tutorial on UML that provides many different examples of the various diagrams and elements, and how they are used together. This part of the book is a good foundation for the balance of the book, which uses UML diagrams in each pattern description.

The book is logically divided into different sections based on the common uses of the patterns described. Then each pattern description is broken down into various parts. Mark does an excellent job of focusing in on the various things that affect the pattern in use. He also uses real world examples to describe usage instead of the usual contrived ones found in many books.

This is a book that you will read once then use each time you are implementing a pattern to see what you've missed. From an educational point of view, the book is very good and will teach you a lot about the patterns in it. From a development standpoint it may be even more valuable in that it can be used as a reference to get alternative ideas or to see what consideration you may have missed in your implementations. I highly recommend this book to anyone doing enterprise work now or in the future. Now I have to go out and get the first two volumes!!!

Discuss book in the Saloon — More info at Amazon.com


Software Architecture: Organizational Principles and Patterns
by David M. Dikel, David Kane, James R. Wilson


Prentice Hall PTR
1 edition
January 2001
320 pages
Reviewed by Carl Trusiak, November 2001
  (9 of 10)


You might ask if a book devoted to Organizational Principles and Patterns on Software Architecture is really necessary. I didn't think so until I read this book!

I quickly found myself nodding as I recognized patterns from the book that we practiced at work. I was also alarmed at the number of Anti-Patterns we have as well. This gives me a goal and guidance to help guide things, hopefully, along a successful path.

Besides my enlightenment, the book mainly covers the VRAPS Principle (Vision, Rhythm, Anticipation, Partnering and Simplification Patterns) with real world case studies from organizations such as Allaire. An extreme amount of research went into the production of this book. The result is obvious.

Any company producing software should make reading this book mandatory for their Managers, Architects and Developers

Discuss book in the Saloon — More info at Amazon.com


IT Architectures and Middleware: Strategies for Building Large, Integrated Systems
by Chris Britton


Addison-Wesley Professional
1 edition
December 2000
336 pages
Reviewed by Ajith Kallambella, December 2001
  (10 of 10)


An excellent coverage of what's, why's and how's of middleware technologies.

The book gives an interesting perspective into the growth of middleware solutions with special focus on enterprise systems architecture and distributed technologies. The long journey that begins with TP monitors and primitive "transaction machines" covers a great deal of ground outlining the need-driven evolution of various middleware alternatives and ends with the discussion of latest - the EJB, .NET and CORBA. There is a special emphasis on the changing landscape brought about by the rise of eCommerce and the need to manage large-scale enterprise systems.

I love the way author drives home some very complex concepts. This book can serve as an indispensable resource both for beginners and experienced professionals. While the novice can easily comprehend intricacies of IT architecture, experienced architects will find a lot of food for throughout and new insights into many issues. I personally had many "ah, what a brilliant idea" moments. You will find many useful and perhaps unconventional solutions to practical problems. It can even help an IT manager to understand the real middleware and IT architecture issues and to make intelligent decisions without having to get deep into technical waters.

Overall, this book is a must have and deserves 10 horseshoes.

Discuss book in the Saloon — More info at Amazon.com


Metapattern: Context and Time in Information Models
by Pieter Wisse


Addison-Wesley Professional
1 edition
December 2000
296 pages
Reviewed by Scott M. Allman, February 2001
  (6 of 10)


As the author is quick to point out this is an innovative and highly original work in conceptual information modeling. After a formal presentation of metapattern terminology and key concepts Wisse jumps into the middle of several issues in conceptual modeling. For example, the book hopes to explain that an object in context is different from the absolute objects assumed by traditional OO models. The metapattern presumes that an object's behaviors are completely different from one context to another. The metapattern, by emphasizing context over object, enables you to adequately describe the enormous variety found in real life. Traditional OO modelers should be ready to leave behind many dogmas. In the metapattern, time has drastic consequences for objects. In addition, OO designers should be forewarned. The metapattern is not a method for technical design or software engineering. 'Metapattern' is a formalization of context, time and validity in information models. This book is actually several books within one and you ought to pay careful attention to the order you read the chapters. The middle parts compare the metapattern to recent work by authors James J. O'Dell, Haim Kilov, August-Wilhelm Scheer, David C. Hay and Martin Fowler. These chapters supplement the theoretical explanation of the metapattern's most fundamental characteristics. A necessary warm-up before tackling the challenging terminology and concepts in the first four chapters is to read both appendices and the introduction. Wisse's schematic diagrams are simple and elegant but weren't enough. This reviewer wanted additional, concrete explanations of core ideas. Immense value would come from more concrete comparisons and examples. The author's frequent tangential remarks, while doubtless precise and true, were distracting. Frankly, I tried hard to understand the metapattern. I read the book cover to cover, then re-read chapters in a different order, all the while investigating his ideas using concrete examples, as best I could. There were glimmers of excitement as I encountered familiar concepts from metaphysics, epistemology, set theory, information modeling and object-oriented modeling. However, all too often I missed the point of his arguments. Reading does not entail understanding. Perhaps I am too much of a software engineer and not enough of a conceptual modeler. I must apologize to the author, but the fairest thing for me to say about the metapattern is that I still don't understand it.

Discuss book in the Saloon — More info at Amazon.com


Practical information architecture, a hands-on approach to structuring successful websites
by Eric L. Reiss


Addison-Wesley Professional
1 edition
November 2000
192 pages
Reviewed by Carl Trusiak, November 2000
  (5 of 10)


This book covers common sense information for website development through the entire design process. Beginners can gain useful information on site structure and the design/development process. However, it lacks the depth of information to make it truly useful as a reference manual. This is best suited as a supplementary text for an html or e-commerce course

Discuss book in the Saloon — More info at Amazon.com


HTML & XHTML
by Chuck Musciano & Bill Kennedy


O'Reilly
fourth edition
August 2000
672 pages
Reviewed by Angela Poynton, October 2001
  (9 of 10)


This was the very first book I've ever read about HTML, years ago I taught myself HTML by using tutorial available on the net. Over those years it hasn't changed much, but now with HTML becoming integrated with XML (therefore becoming XHTML) things are changing quickly.

This book will help those who already know basic HTML through the transition and is also comprehensive enough to be usful to someone who's never written HTML in their lives. Typical of O'Reilly books this not only has chapters which go into things in-depth but also comprehensive appendices which can be used as handy references along with a pull-out "Quick Reference" section. It's extremely easy to read and I recommend it to anyone who has to deal with HTML or XHTML.

Discuss book in the Saloon — More info at Amazon.com


GUI Bloopers
by Jeff Johnson


Morgan Kaufmann
1 edition
March 2000
584 pages
Reviewed by Salman Halim, August 2003
  (8 of 10)


This book discusses some of the more common problems with modern user interfaces. It takes the approach that the user interface is arguably the most important aspect of an application (or Web site) and shouldn't take a back seat to the business logic therein.

The book begins with a treatise on what a GUI should be like and serves as a good set of things to keep in mind when designing an application's front-end. The bloopers themselves are arranged by category, one category to each chapter. There are 82 bloopers in all, so the book contains quite a decent amount of information.

The individual bloopers themselves are laid out quite well: there is a description of the blooper and the common variations thereof (usually with a picture from a real or sample application demonstrating the problem); this is followed by guidelines on how to avoid the particular blooper (often with a fixed version of the original pictures).

There weren't any real problems with the book; the only thing that irked me was the author's habit of pointing out something that was a problem and following it up with, "Bzzzt. Blooper!" It was cute the first time but quickly became something that grated on me.

Recommendation: for someone who knows how a GUI component works, but doesn't know how to make it look professional, this is a great book. Everybody who does GUI work could learn something here, though.

Discuss book in the Saloon — More info at Amazon.com


Java Design Patterns: A Tutorial
by James W. Cooper


Addison-Wesley Professional
unknown edition
February 2000
352 pages
Reviewed by Thomas Paul, May 2001
  (7 of 10)


Any Java developer who has read "Design Patterns" by Gamma, et al, has probably tried to relate the patterns discussed to Java programs. This book provides a linkage between "Design Patterns" and Java. Each of the 23 patterns discussed in "Design Patterns" are covered in this book using an example of a Java Swing program. The book opens with a brief discussion of design patterns in general and a quick review of UML, which is used throughout the book. The book then has a chapter for each of the 23 patterns. The book then finishes with an overview of Swing and a case study demonstrating how design patterns might be used in an actual development project. Although the author says that this book is not meant to be a companion book to "Design Patterns," I found that is actually the best way to use this book. Reading the description of each pattern in "Design Patterns" followed by reading about the same pattern in this book helped me to understand each pattern in a deeper way than by reading either book by itself. This book is not, however, the Java version of "Design Patterns". Some of the examples seemed strained to make their point. Also, by limiting himself to Swing, the author missed the opportunity to discuss how to use patterns in server side Java development. In general, however, the book does a good job of explaining design patterns and how to use them.

Discuss book in the Saloon — More info at Amazon.com


The Pattern Almanac 2000
by Linda Rising


Addison-Wesley
1 edition
January 2000
384 pages
Reviewed by Shailesh Sonavadekar, October 2001
  (8 of 10)


Patterns. The current vocabulary of the high end designers and software architects. There are very few universities offering the M.S. courses on this subject; the future language of the software industry. Eric Gamma et al. started this revolution in 1995. It seems that there is no end to it. The author herself has significant experience in the area of Patterns. The book, as its name suggests, is indeed a very good almanac of patterns.
The author has taken truly a lot of pains to collect patterns from varous industries & put them in book form. Many of the patterns I have not heard of. That is one of the greatest strengths of the book; it gives you a bird's eye view of all the patterns used in various industries. Another thing I liked about the book, the author mentions relationships with other patterns, though not with details.
The layout of the book was not as appealing & the index takes many pages. The patterns should have been accompained by urls. Some url's are given. But, not all. But the effort is really herculean & the author has done a great job to put it in book form.
Please note that the book is not for beginners. It is for users who know & use patterns & want to know more about other patterns. I hope the author will come up with more patterns in the near future.

Discuss book in the Saloon — More info at Amazon.com


Designing Web Usability
by Jakob Nielsen


Peachpit Press
1 edition
December 1999
432 pages
Reviewed by Frank Carver, June 2001
  (7 of 10)


This book is widely regarded as a web usability classic. Not everyone loves it, though. Opinions range from "he is a genius" to "the book is obsolete". The book is bigger than it need be. Nielsen argues strongly that web sites should be concise, but that doesn't carry over into his writing. In several places a paragraph or two seemed very familiar, having already been used earlier. There are lots of colour screenshots of web pages, mostly to point out flaws. I agree with most of what he says: Make things simple, easy and effective for users; make your pages download as fast as you can; provide a site search and so on. Where he lets himself down is in speculating about what the internet might be like five, ten or even twenty years from now. This is a complete waste; I got fed up wading through it. It's also too heavy on opinion and too light on practical detail for me. Nielsen claims he plans to write a "how to" book, but that's no use now. The section on internationalization, for example, tantalizingly mentions a few things (US switches go "up" for "ON", European ones go "down"; don't use baseball metaphors etc.) then leaves it up to the reader with very little help. Well worth absorbing, but I won't often dip into it again. Unless you are a collector, borrow it rather than buying.

Discuss book in the Saloon — More info at Amazon.com


Building Web Applications with UML
by Jim Conallen


Addison-Wesley Longman
1 edition
December 1999
320 pages
Reviewed by Carl Trusiak, April 2001
  (7 of 10)


If you are new to UML and are looking for a good book to learn with, then this book isn't for you. On the other hand, if you are experienced with UML modeling, you can save yourself some time by skipping the first five chapters. The real meat of the book gets started in chapter six. From there, it is extremely packed with information to help you model a website. The biggest disappointment for me was the minimal number of examples in Java, Servlets and JSP. There are a few. However, the complete Model Example is in Active Server Pages. I'd really love to see an erratum for the book with the example done using Java Technology. If you need to learn a standard way for your organization to model dynamic web pages, this book is a must.

Discuss book in the Saloon — More info at Amazon.com


UML Distilled
by Martin Fowler, et al


Addison-Wesley Professional
second edition
August 1999
185 pages
Reviewed by Paul Wheaton, January 2000
  (10 of 10)


The best book on UML. Oh sure, you can buy the three amigos books, take a few years to read them and if you can stay awake, you might actually retain something. This book is an easy read and answers your practical questions. The author is the same guy that wrote the "Refactoring" book reviewed on this page. He makes any subject come alive.

Discuss book in the Saloon — More info at Amazon.com


Refactoring: Improving the Design of Existing Code
by Martin Fowler, et al


Addison-Wesley Professional
1 edition
July 1999
464 pages
Reviewed by Paul Wheaton, January 2000
  (10 of 10)


This is currently my favorite book. It has changed the way I do development because it gave words to the way the I was doing things and took me even a few steps further! The book discusses the importance of rewriting code NOT to add functionality, but to add clarity and improved design. There is general discussion as well as a list of specific refactorings. It gives tips on how to stress the importance of this to managers, or sneak it by them if they might not be so understanding. :) I think we are going to hear a lot more about refactoring in the next decade. I found the refactorings to be as useful (if not more so) as design patterns.

Discuss book in the Saloon — More info at Amazon.com


Webmaster in a Nutshell, 2nd Edition
by Stephen Spainhour, Robert Eckstein


O'Reilly
second edition
June 1999
536 pages
Reviewed by Frank Carver, December 2000
  (8 of 10)


This is one of a small set of books which I use all the time. It doesn't cover Java as such, but is a mine of useful and accessible information on HTTP, HTML, JavaScript, XML, CSS, CGI, Perl, PHP and Apache configuration. Although I have many other books which cover these areas, usually in much more detail, this book is often all I need to answer a particular question. To me, this book, along with Unix in a Nutshell, show how good a "Nutshell" book can be. Small enough to carry about, and packed full of genuinely useful information.

Discuss book in the Saloon — More info at Amazon.com


Philip and Alex's Guide to Web Publishing
by Philip Greenspun


Morgan Kaufmann
1 edition
April 1999
608 pages
Reviewed by Frank Carver, September 2001
  (8 of 10)


This book covers such a wide range of subjects - HTML, web design, SQL, server configuration, e-commerce, accepting credit cards, scalability, futurology, search engines, choosing a database, the nature of buying software, system admin and loads more, all in great depth - that it'a almost impossible to characterize the contents. It's also packed full of beautiful, but completely unrelated, photographs; all taken by the author!

Philip Greenspun runs a successful web consultancy with several very busy sites, and seems to have tried to distill all that he has learned into one book. A lot of what he says is very wise, and although I disagree with some of his technology choices, he has thought everything through in great detail. There are quite a few sections which I will re-read and study for my own projects, but many others I will never bother with again. The book's main drawback is its size, which makes it hard to cherry-pick just the bits you need.

If you are looking for ways to use the latest technology to make a web site look cool, this is not the book for you. If you are building or running a site or business with lots of users, and you want to keep them and avoid going crazy in the process, you need this book. And the photos really are good.

Discuss book in the Saloon — More info at Amazon.com


Web Design in a Nutshell
by Jennifer Niederst, Richard Koman(Editor)


O'Reilly
1 edition
December 1998
580 pages
Reviewed by Frank Carver, December 2000
  (3 of 10)


I bought this as a companion to the excellent "Webmaster in a Nutshell", but was somewhat disappointed. It seems at first glance to be packed with useful stuff, but the core of day-to-day material on HTML, JavaScript, SSI and CSS is virtually the same as in "Webmaster in a Nutshell", and the rest is mostly hand-waving introductions to topics such as streaming audio and video on the web or, strangely, an Adobe Photoshop tutorial. Even stranger, the one topic it doesn't seem to cover is web design. There's nothing about how to create interesting, useful or impressive sites, and precious little about page layout or navigation.
My recommendation would have to be to forget this book, but buy "Webmaster in a Nutshell" for the nuts and bolts, and look for a decent web design book which is actually about web design rather than just web page construction.

Discuss book in the Saloon — More info at Amazon.com


Patterns in Java, Volume 1, A Catalog of Reusable Design Patterns Illustrated with UML
by Mark Grand


Wiley
unknown edition
September 1998
480 pages
Reviewed by Carl Trusiak, November 2001
  (7 of 10)


Mark does an excellent job of covering not only a few of the more common patterns but also, a good quick overview of UML and the software development cycle.

Each pattern is illustrated using UML and has example Java code to demonstrate it's use. While the accompanying CDROM has a little dated software, TogetherJ Whiteboard, Rational Rose 98 and System Architect Trail editions; however, these are great to learn UML. You are also given the opportunity to try each and choose the one you might prefer. The 41 patterns discussed are divided very logically in 6 groupings.

I can't wait to get the opportunity to read Mark's volume 2 and 3!

Discuss book in the Saloon — More info at Amazon.com


Anti-Patterns / Refactoring Software, Architectures, and Projects in Crisis
by Brown, Malveau, McCormick, and Mowbray


Wiley
1 edition
March 1998
336 pages
Reviewed by Mark A. Herschberg, April 2002
  (7 of 10)


If you like pattern books, you'll like Anti-Patterns. What is an anti-pattern? It's a design pattern for bad code. Let's face it, we all see plenty of bad code on the job, this book will help you better identify it.

This book, like a pattern book, is a catalog. Each anti-pattern definition is structured like a pattern: Name, Root Causes, Symptoms, Consequences, Anecdotal Evidence, and Refactored Solution. It identifies what the problem is, along with its causes. It goes on to discuss the consequences of the problem and then discusses the refactored solution. As with a pattern definition, it goes into great detail, including such information as exceptional cases. The book contains 3 categories of anti-patterns: software development anti-patterns, software architecture anti-patterns, and project management anti-patterns.

The book itself is easy to read. It's entertaining, too, often written with a tongue in check style. The anecdotal evidence provided for the anti-patterns is something right out of Dilbert, funny and accurate.

The best review I can give is to name some of the anti-patterns from the book: Lava Flow, Golden Hammer, Spaghetti Code, Stovepipe System, Vendor Lock-in, Fire Drill. Like regular design patterns, you probably recognize some of them, but will be able to better identify and apply the knowledge after seeing it formally treated.

Exposure to anti-patterns is just as important as exposure to design patterns. This book is a good introduction to the subject.

Discuss book in the Saloon — More info at Amazon.com


Pattern Oriented Software Architecture
by Frank Buschmann, Regine Meunier, Hans Rohnert et al


Wiley
1 edition
August 1996
476 pages
Reviewed by Madhav Lakkapragada, April 2002
  (6 of 10)


The title "Pattern Oriented Software architecture" suggested to me that the book deals a lot with design patterns for software. Maybe because this book was compared to the GoF book in one of the online reviews at Amazon.com. Somewhere in this thought process I got lost reading this book. Defenitely, the book describes patterns. However, the book gives very few examples explaining the usage of the pattern. It describes the architecture details but with very few code examples. So, I do confess that this was not the kind of book I was expecting based on the title. On the other hand the book emphasises Smalltalk examples, although a handful of examples are in C++. A few others examples regarding client-server design patterns are in Java, since Soket programming is easy in Java, I assume.

The book is divided into three sections - Architectural Patterns, Design Patterns and other discussions on pattern systems and the future. It concentrates to a large extent on the Architectural patterns. I felt the book is very dry and theoritical as I read through the chapters. I was looking for a more dynamic approach where I could see code changing due to the application of a patterns.

Finally, I must admit its highly possible that this book describes a topic excellently but maybe I just couldn't make that connection. I, personally, could never connect with dry and theoritical subjects. I am rating the book above average giving due credit to the detailed explanations.

Discuss book in the Saloon — More info at Amazon.com


The Web Page Design Cookbook
by William Horton, Lee Taylor, Arthur Ignacio, Nancy L Hoft


Wiley
unknown edition
November 1995
672 pages
Reviewed by Frank Carver, November 2000
  (5 of 10)


This book is getting old now, and only covers basic HTML, so it's little use as a reference. What it does have, and what keeps me from discarding it in favour of newer and more comprehensive guides is it's sensible advice on web site design. It's one of the few web design books which actually covers web site design issues! It urges readers to think in terms of simple sites with useful content, and consider how the information might be used by people from all over the world as well as the usual issues of download speed and browser compatibility. Probably not worth buying these days, but borrow it from a friend or check it out of the library if you do see it.

Discuss book in the Saloon — More info at Amazon.com


Design Patterns
by Erich Gamma, et al


Addison-Wesley Professional
1 edition
November 1994
416 pages
Reviewed by Paul Wheaton, January 2000
  (8 of 10)


The most popular computer science book of all time. This is the "Gang of Four Book". 23 Design patterns that can be used in any object oriented language. You've probably used a lot of them and never knew it! Now, rather than taking 15 minutes to explain to another engineer what you are trying to do, you can just say "I'll use the state pattern here."

Discuss book in the Saloon — More info at Amazon.com
 
The Bunkhouse administrator is Lasse Koskela.