Slashdot Mirror

PotPieMan writes "I recently finished reading JSP and Tag Libraries for Web Development, a book for JSP developers wanting to improve their skillset. Read on for my review." It's not a new book, but still relevant. JSP and Tag Libraries for Web Development author Wellington L.S. da Silva pages 420, including appendices publisher New Riders rating 6 reviewer PotPieMan ISBN 0735710953 summary A guide to designing and implementing JSP applications, with a focus on tag libraries.

The Scoop Web developers and designers have long wrestled with strategies for combining their efforts. Web developers don't mind looking at code but dislike dealing with the look of a page, while Web designers are the opposite. Dynamic Web page technologies, such as Microsoft's ASP, Perl's many template systems and Web frameworks (Text::Template, HTML::Template, HTML::Mason, CGI::Application, etc.), and PHP, were designed to give both developers and designers a chance to do their work without stepping on each other's toes.

Sun's answer was to release the Servlet API and later extend that to make JavaServer Pages. Initially, there was no clear role separation for servlets and JSPs, since a servlet could generate and display HTML just as easily as a JSP could perform business logic. The Model 2 architecture, based on Smalltalk's Model-View-Controller (MVC) design pattern, showed that servlets and JSPs complemented each other. Tag libraries extended the functionality of JSPs in a way that made it easier for developers and designers to collaborate.

JSP and Tag Libraries for Web Development is mostly targeted at Web developers who want advice on designing JSP applications and incorporating tag libraries. The book covers custom tag libraries, the Jakarta Struts framework, and various commercial and noncommercial tag libraries, such as Jakarta Taglibs.

What's to Like? The author starts with an introduction to servlets and JSPs, including a decent explanation of MVC. If you are comfortable with servlets and JSPs, this discussion is really more of a review than anything else.

The next two chapters introduce tag libraries and the author's example application (a simple article and author tracking system). The author illustrates the lifecycle of a tag, which helps if you haven't really used or written custom tags before. Da Silva also gives a very detailed discussion of tag library descriptors (TLDs). Some details might have been better left as an appendix, but it is nice to see such a comprehensive explanation of what you can put in a TLD.

Da Silva then spends about 100 pages on writing simple tags, iteration tags, body tags, and making all of these types of tags cooperate. The discussion is again very detailed, but seems unfocused in many parts. Very little of the code in these chapters ties in with his example application.

Next, the author spends three chapters on the Jakarta Struts framework. He explains how Struts naturally fits into the MVC design pattern and gives various examples of how to structure your Struts application. He also includes an entire chapter on finishing his example application, going over Struts ActionForms, Struts Actions (including a method to prevent double submission that I had not seen before), and Struts' method of internationalization on JSPs.

Finally, the author runs through the Jakarta Taglibs project and some commercial tag libraries. Brief examples are provided, but this chapter really needed more attention than da Silva gave it.

What's to Consider Overall, JSP and Tag Libraries for Web Development feels unfocused. The author's central points are explained well in many places, but lost in many others. With some reorganization, I think the book could make a much stronger case for appropriate uses of tag libraries, both application-specific and general (e.g. Struts and Taglibs).

Sections where general tag libraries are discussed read very much like the documentation available on project Web sites, such as the struts-html tag library documentation. These really should have been left as an appendix, with better explanations and usage examples provided in their place.

I was also very disappointed in the author's use of Struts Action classes. He combined various actions (add, edit, delete, etc.) to perform on a specific object and tested for a URL parameter to decide what to do. In my opinion, each action should be encapsulated in one Action class (AddObjectAction, EditObjectAction, and DeleteObjectAction). The author's design leads to URL hackery which Struts tries to avoid.

Recently, Struts released a stable version of the 1.1 series, which this book does not cover (it was published in early 2002). Readers should be familiar with the Struts documentation for this release before picking up this book.

The book's Web site is under construction, and I've been able to find little information on the publisher's site.

The Summary A okay book with room for improvement. While the author shows his technical knowledge, the book loses its direction in places. Most developers can probably get by with the documentation available on the Web. Table of Contents

1. Understanding the Tag Library Extension API
2. 1. Introduction to Servlets and JavaServer Pages
   2. Introduction to Tag Libraries
   3. Writing Custom Tags
   4. Cooperating Tags and Validation
   5. Design Considerations
3. The Struts Framework
4. 1. The Jakarta Struts Project
   2. Struts Tag Libraries
   3. Anatomy of a Struts Application
5. The Jakarta Taglibs and Other Resources
   1. The Jakarta Taglibs Project
   2. Commercial Tag Libraries
   3. Other Resources
6. Appendices
7. 1. Tomcat
   2. Allaire JRun
   3. Orion
   4. MySQL
   5. Mapping Servlet-JSP Objects
   6. The Apache Software License, Version 1.1

You can purchase the JSP and Tag Libraries for Web Development from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Steve MacLaughlin wrote this review of Web ReDesign: Workflow that Works , a book which transcends its title to address much more than workflow, and more generally than just on the Web. Steve promises that your copy will soon be tattered and marked -- and that's a good thing. Web ReDesign: Workflow that Works author Kelly Goto & Emily Cotler pages 253 publisher New Riders Publishing rating 9 reviewer Steve MacLaughlin ISBN 0735710627 summary Practical wisdom for Web creators on consulting, design, development and more rolled into a single readable volume.

There are books that attempt to impart the divine wisdom of consulting. There are books that detail best practices in graphic and usability design. There are books that detail the intricacies of software development. There are books that detail project management and surviving the technology lifecycle. But there are very few books that explain how all of these pieces work together successfully. Kelly Goto and Emily Cotler have pulled it off with masterful perfection in their new book Web ReDesign: Workflow that Works.

People, projects, technology, and clients do not work in a vacuum from one another. Process is the magnet that holds them all together. Goto and Cotler offer professionals a comprehensive "Core Process" to guide them through their Web projects. While other books may explain some of the tricks of the trade no book has really placed all of these best practices under the umbrella of a process or methodology. Perhaps that's because a lot of these processes have been closely guarded secrets in the highly competitive interactive services industry. It's almost as if Goto and Cotler are on a humanitarian mission to save clients and projects from future punishment under the hands of companies using poor or in some cases no processes at all.

Web ReDesign's Core Process is a five-step approach to producing successful Web projects. The five steps are Defining the Project, Developing Site Structure, Visual Design & Testing, Production & QA, and Launch & Beyond. And each phase is broken down further into steps and checkpoints in splendid detail. As someone who started out doing this kind of work I found myself making mental checkmarks throughout the book. "Did that. Did something like that. Man, it took me years to learn that I should do that. Where was this book six years ago when I needed it?"

Perhaps a book like this wasn't really possible until now. The profession had to go through its ugly duckling stages where individuals and companies tried to figure out what worked and what didn't. Grafting parts from consulting, marketing, project management, and software development into some freakish process monster that often resulted in turning clients into an angry torch-carrying mob. Thankfully Web ReDesign has finally arrived and it is certainly no Bride of Frankenstein. The processes are spelled out in clear language and the authors repeat certain key points in case you missed something along the way.

It's easy to get sidetracked reading Web ReDesign with all the sidebars, charts, sample forms, and interviews. But this is a good thing! The tips and sidebars along the way spell out in greater detail how to put the process into action, and what to do when trouble arises. The forms and charts are some of the most thorough ever published, and thankfully you can download most of them on the companion website located at www.web-redesign.com. Throughout the book Goto and Cotler call on experts like Lynda Weinman, David Siegel, Jeffrey Zeldman, and Jakob Nielsen to offer their perspective on a given topic. The overall design and layout work done by the folks at New Riders is phenomenal and the visual presentation of the book is really first rate.

The one big question I have about the books is its title: Web ReDesign. That's because this is a book that can be used for first time Internet initiatives just as well as for redesign projects. Perhaps the authors had some dual purpose in mind for the title: If you're doing this for the first time, you need to rethink the conventional wisdom that Web projects are a black art with no best practices. Or if you didn't use a process the first time, then you've probably learned how valuable it is to have a proven methodology to avoid repeating mistakes.

Goto and Cotler have produced a book that no Web professional, whether they're a consultant, project manager, designer, programmer, or specialist, should be without. Web ReDesign is one of those books that should be kept close at hand during projects of all shapes and sizes. It won't take long before your copy is either severely dog-eared or has post-it flags sticking up throughout it. Get your hands on a copy before the competition does.

You can purchase this book at Fatbrain. Have your own book review to contribute? Check out the book review guidelines, then write away!

Years after the virtues of XML were first extolled (and plenty of uses both front-and-center and behind-the-scenes later), XML still isn't the do-all, be-all wonder we were led to believe. Book reviewing genius chromatic here dissects a book that sounds aimed at intermediate or advanced programmers (of other languages) who want extend their grasp with a greater understanding of the flexibility inherent to XML. How well it succeeds? Well, see what he's got to say about that.

Inside XML author Steven Holzner pages 1102 publisher New Riders rating 7 reviewer chromatic ISBN 0-7357-1020-1 summary A detailed but uneven treatment of XML and related topics.

The Scoop People love it, but XML won't save the world. If properly applied, it will improve the transfer of information between different individuals, platforms, and programs. A language that describes languages, XML in the real world has spawned hundreds of applications. In Inside XML, Steven Holzner attempts to make sense of the basic principles and more popular implementations as things stand right now. What's to Like? Holzner's caught platform independence fever, and he imparts a healthy sense of respect for W3C standards to his readers. While the current state of XML handling, especially in web browsers, is mediocre at best, he varies platforms when possible. Though most examples use IE on Windows, the author occasionally examines offerings from Mozilla and IBM.

The book's strength is describing a technology. The first five chapters explore XML's essential concepts, including DTDs and schemas, in as good an explanation as you'll find anywhere. Later chapters cover XSL (used to format and to transform documents), XHTML (the successor to HTML), CSS (governing the presentation of XML and XHTML documents) and RDF and CDF (to describe available resources) in sufficient detail. The explanations here are good, with accurate information and plenty of examples.

Java programmers will appreciate the extended descriptions of the DOM and SAX parsing styles. Though the examples themselves are in Java, most concepts translate fairly well to other languages. JavaScript also gets some attention, mostly in the confines of IE5.

What's to Consider? Though the cover blurb claims otherwise, most programming examples use Java. Perl earns a brief 13-page treatment, while ASP and Java Servlets share just eight pages in the same chapter. Exotic languages like C and C++ are conspicuously absent. A detailed description of the DOM and SAX approaches would benefit everyone, not just Java hackers.

This massive tome could have stood another round of editing. Many examples run up to a page and a half in length when only two to four lines have changed from the previous listing. Other material is arguably filler, such as four and a half pages of JavaScript events supported in IE, or fifteen pages detailing XML DOM objects and associated methods before giving a single example of DOM usage. The publisher could have cut between 100 and 200 pages, instead adding footnotes to authoritative sites.

Worse yet, the book's organization is questionable. After describing the basics of XML, it veers off into a 50-page JavaScript tutorial. Java soon suffers the same fate. These chapters break the flow of subjects, use no XML in their examples, and should be appendices. (They're decent, as far as tutorials go. They just don't belong in the middle of the book.) Readers will have difficulty finding useful reference material mixed in with tutorials.

English majors will also find Holzner's transitions awkward. Logical sections often conclude with a phrase such as "Now I will talk about the topic named in the heading immediately following this sentence." XML is not a serial radio cliffhanger, and most readers can find their way down the page by themselves. It occurs often enough to be distracting.

The Summary Besides the reservations above, most of the information is solid and usable. Inside XML is at its best when describing technologies instead of how to work with them. Uneven presentation hinders (not hobbles) the book, making it a better introduction than a definitive guide. Though falling short of its claims, cautious readers will learn plenty. Table of Contents

1. Essential XML
2. Creating Well-Formed XML Documents
3. Valid XML Documents: Creating Document Type Definitions
4. DTDs: Entities and Attributes
5. Creating XML Schemas
6. Understanding JavaScript
7. Handling XML Documents with JavaScript
8. XML and Data Binding
9. Cascading Style Sheets
10. Understanding Java
11. Java and the XML DOM
12. Java and SAX
13. XSL Transformations
14. XSL Formatting Objects
15. XLinks and XPointers
16. Essential XHTML
17. XHTML at Work
18. Resource Description Framework and Channel Definition Format
19. Vector Markup Language
20. WML, ASP, JSP, Servlets, and Perl

1. The XML 1.0 Specification

You can purchase this book at FatBrain.

The Gimp, frankly, rocks. But like most pieces of complex software, it's a bit of a...problem to learn how to use. Enter chromatic's review of Carey Bunk's Grokking The Gimp. If you want to know more about image manipulation, check it out. Grokking the GIMP author Carey Bunks pages 342 publisher New Riders rating 8.2 reviewer chromatic ISBN 0-7357-0924-6 summary Principles of image manipulation explained in the context of the GIMP.

The Scoop One of the standout userland programs to come from Free Software development, the GIMP offers a powerful range of features for digital imagery. Unfortunately, not everyone's had the privilege of (or inclination for) sitting through 'Principles of Color' or similar classes. Not to fear, the author has - - and he's willing to share his knowledge.

Compounding the complexity challenge, the GIMP has its own way of doing things. Half of the work of editing an image seems to be making a good selection. Again, the author has theory to divulge and tips to present to improve your technique. Though only a few tools and methods are discussed, they are fundamental to all advanced operations. (Note that the book covers the as-yet unreleased 1.2 GIMP -- the 1.1.x betas have been quite usable for months.)

What's to Like? This attractive book is well-printed, with plenty of full-color images and good figures. It's also well-designed and the layout is excellent. The decision to add a few common problems and frequently asked questions at the end of most chapters is commendable. It's not designed as a reference book, but the index and table of contents are detailed enough to locate specific actions later.

Banks assumes little prior knowledge of the GIMP. Chapter one is a brief tutorial of the program's features and functions. More experienced users can skip this, though I found a couple of timesaving tidbits. The same may be said of chapter two, on layers, though the material quickly moves beyond what an average user might discover in an afternoon. The selections and masks chapters form the real foundation for most GIMP work -- how do you choose parts of your image to edit? A little theory, a few tools, and some examples later, you'll have multiple answers for that question.

The next two chapters pile on the theory. First, Bunks discusses the theory of color -- running the gamut (so to speak) from additive to subtractive, RGB, HSV, CMYK, and grayscale. There's plenty of math (more than one would need), and the explanations here are quite detailed. It's fundamental knowledge, and most readers can probably pick up just enough to get by. Don't skip ahead and miss the very useful touchup discussions in chapter 6. (The author considers them worth the price of the book -- given the results on some of my images, I'm inclined to agree.)

The final three chapters each cover different tasks one might wish to accomplish. Bunks explores various techniques while creating projects. Screenshots and commentary accompany step-by-step instructions. It's in these sections that the full power of the GIMP comes into play. Rounding things out are a handy keyboard shortcut guide and a detailed index.

What's to Consider? Things do get pretty heady in the theory section. Non-programmers (and people who haven't already worked with professional imaging) will have some slow going trying to absorb the math and colorspace information. It's not essential to use the GIMP, but knowing the differences between the modes and the limitations of each is necessary for most serious work.

Readers looking for a guide to the dozens of distributed plugins will be disappointed -- this book is more interested in the general techniques used in nearly every non-simple project. Finally, the book seems a little short. It's 342 pages, but the information is good enough that perhaps more subjects can be covered in a future edition. (That's a good thing.)

The Summary Nearly anyone will benefit from the deep magic behind the menu operations. Move past cheesy banners and poorly-executed lasso operations. Double the size and power of your toolbox, and get to know the GIMP. (If you're not convinced, browse the book online!)

Or buy it at ThinkGeek.

Table of Contents

1. GIMP Basics
2. Review of Layers
3. Selections
4. Masks
5. Colorspaces and Blending Modes
6. Touchup and Enhancement
7. Compositing
8. Rendering Techniques
9. Web-Centric GIMP

1. GIMP Resources
2. Keyboard Shortcuts

Madman Chromatic (coder, writer, thinker) sheds even more light on the books lurking on store shelves designed to lure, and then snare, new or uncertain users into trying out -- and actually enjoying! -- this wacky "Linux thing." This time around, the texts he's chosen cover the topics of installation and day-to-day operation of a Linux system in greater depth than the Dummies series dares to, but they're still aimed squarely at competent, literate users rather than only at technical gurus. Read on for his insights into Using Linux, Linux Configuration & Installation, and the Linux Essential Reference.

Various Introductory and Reference Books author (Varies by title) pages n/a publisher (Varies by title) rating n/a reviewer chromatic ISBN (Varies by title) summary Three books intended to provide clear guidance and reference to the Linux sysadmin

This week's edition takes a look at three very different books. We have tutorials, theory and techniques, and thick juicy slabs of opts. Step through instructions and stay on the sidewalk, get your hands dirty on your own if you're the trailblazing type, or read up on what you always thought someone should code, if you're stuck at your desk.

Title (Author) Using Linux (Jack Tackett, Jr / Steven Burnett) Publisher, ISBN QUE, 0789717468 Included Stuff none Intended Audience RedHat users. Scope Installation and basic introduction to Linux. Technical Correctness Occasional weird advice. (In one spot, the authors describe a very insecure PATH setting without explaining that it's dangerous.) Writing style Varies with chapter author. Other Two-thirds of the way through the book, there are a number of mildly annoying typesetting errors. Unfortunately, they tend to appear near literal command-lines. Hopefully this will be corrected in a second edition.

Using Linux is a cross between a reference-book and a tutorial. Each chapter takes a different subject (Networking, Working with Hard Drives) and breaks it up into common tasks -- each listed in the copious table of contents and the large index. For example, if you're interested in setting up a file system, you can flip right to page 495 and choose between the RedHat tool or editing /etc/fstab yourself. Though RedHat tools receive a lot of attention, they're not presented as the only way to get things done. In a pinch, you'll find command line equivalents for common tasks given near the graphical description.

Accompanying the chapter text are occasional sidebars. These label figures, give a bit of historical perspective, and dish out useful tidbits of information that don't fit into the normal flow. This is less distracting than the usual approach of goofy icons and inset boxes often found in other books.

What's nice about this book is that it covers more subjects than most of the others. It's thick, but not unreasonably so. It's easy to read, but packed with details. Instead of covering only the handful of things every (home) user will need, the authors add information about removable drives, fax configuration, and file system cleanup, to name a few topics. Also nice is a brief chapter on building installations from source code (both make and Imake style systems) -- there's another world out there beyond RPM.

The task-oriented approach doesn't spend much time on theory, preferring a gentle overview and usage specifics. Obviously, there's more to learn than what's presented, but people more interested in results will prefer this decision. The system administration section really stands out, for an introductory book, and the appendix listing common Linux commands and glossary of terms will come in handy.

All things considered, this is a solid book. The breadth of information is good, and the flow of topics means it's readable from start to finish. Occasional flaws detract slightly, but they're not fatal.

[You can purchase this book at FatBrain.]

Title (Author) Linux Configuration & Installation (Patrick Volkerding, Kevin Reichard, Eric Foster-Johnson) Publisher, ISBN M&T Press, 0764570056 Included Stuff Slackware 3.5 CD-ROM, with extra disk full of additional programs. Intended Audience The do-it-yourself type. No prior Unix knowledge is necessary, though some experience with the command line will come in handy. Scope Installation and introduction to Slackware. Very good overview of the general Linux way to do things. Technical Correctness Quite good. Writing style Easy to read, though still technical. Other The version reviewed is the 4th edition -- somewhat dated (1998), but not out of touch. If there's a newer edition, get it! If not, you won't go astray with this one.

With help from Patrick Volkerding (Slackware creator) himself, this book teaches the do-it-yourself distribution. Expect a tremendous amount of detail -- in the first chapter alone, there are dozens of links to a Web site for more information about Linux and particular hardware. Fully half the book falls under installation and initial configuration issues, though this includes tinkering with your window manager, setting up networking, and recompiling your kernel (topics usually saved for later in other books). The fourth edition added a section on Slackware and portable computing, with pages of links to information on particular laptop models and information on synchronizing your Palm Pilot.

Chapter seven introduces the command line (though people following along will have used it -- with gentle prodding). It's a whirlwind, 50-page tour that explains a bevy of tools and tricks both concisely and thoroughly enough for day to day work. Following that are applications -- text editors, text formatters, graphics viewers, and the like. A short section on system administration covers scheduling, managing accounts, checking performance, but relatively little about security. Finally, chapter ten delves in to Linux programming -- toolkits, languages, tools, and scripts. Maybe the hors d'ouvres will whet your appetite to learn more, or at least help you with the magic "./configure; make; make install;" incantations.

The appendices list additional sources of information and the contents of the CD-ROM. Don't overlook the supplemental information, either -- including 30 pages of extra package description. (If you're going to install Slackware yourself, you ought to know what you need and what additional options there are.)

The only reason to overlook this book is its age, which is a shame. Things haven't changed so much that the knowlege presented is obsolete -- considering that the hands-on Slackware approach often leads to true and deep understanding. Unless you're too intimidated to experiment, you can learn a great deal, even from a two-year-old text.

This book is eminently readable. Readers with some technical background will appreciate the slightly geeky, no nonsense approach, while users new to Unix in general will benefit from the quality explanations. When the publishers see fit to release a 5th edition of this book, it deserves very serious consideration.

[You can purchase this book at FatBrain.]

Title (Author) Linux Essential Reference (Ed Petron) Publisher, ISBN New Riders, Included Stuff none Intended Audience Users and administrators already comfortable with the command line. Scope Common and uncommon commands and switches. If you can imagine a task, it's likely listed here in glorious detail. Technical Correctness Good. Writing style Reference style -- very concise, little prose. Not something you'd read straight through. Trust me. Other The organization by topic here is nice. I've used it a few times already, just to look up something I knew had a command option somewhere.

For the user already familiar with shell basics, running programs, and using 'shutdown' instead of flipping the switch, a reference of commands and options might come in handy. That's the idea behind Linux Essential Reference. If you already know what you want to do but not how to do it, flip to the appropriate section and discover all of the little timesavers and niceties you've always wanted but never knew existed.

What sets this book apart from other works, including the man and info pages, is the excellent organization. Not only are commands grouped by category, the sections are (roughly) arranged according to complexity. (Although if you're not familiar with cd, mv, cp, and at least pico before looking something up, get thee to a tutorial!) For example, the Kernel chapter subsections are, in order, 'Installing New Kernels', 'Using Modules', 'Device Files', 'The /proc Filesystem', and 'Kernel Message Logs.'

Rather than reformatting man pages, the author has gone to quite a bit of work, rewriting often terse descriptions into longer examples. This is helpful with the lesser-known options (ls -T 4). The amount of detail, more than in any other work, makes this a good reference. (If you do read it all the way through, you'll have something to put on your technical reviewing resume.)

As seems to be usual, this book is divided into a user section and an administrator section. Administration gets a stronger treatment here, with information on LAN-specific tools. It's not limited to the home user's point of view, which makes it more useful to system administrator-types. The security chapter, including tcpwrappers and ipchains configuration, stands out as informative, though brief.

This book answers the question, "Okay, now what?" If you're feeling experimentative after polishing off one of the others, but you want a little more direction than the command prompt usually provides, having this book on your desk will prove valuable.

[You can purchase this book from ThinkGeek.]

Jakob Nielsen is no Web-designer-come-lately. He's a respected, thoughful researcher and educator. When he speaks, (smart) people listen. The first review below is one of more than five hundred by reviewer Danny Yee. Likely to interest Slashdotters are reviews in the categories popular science, science fiction, and computing. Our second reviewer is Cliff Lampe, who brings his own expertise in human-computer relationships to the table. Readers may also want to read the Slashdot interview with Nielsen.

Designing Web Useability (The Practice Of Simplicity) author Jakob Nielsen pages 417 publisher New Riders 1999 rating 8/10 reviewer Danny Yee, Cliff Lampe ISBN ISBN 1-56205-810-X summary Down-to-earth, practical advice on making Web sites work at all levels.

Review One: Danny Yee

Designing Web Usability is the most important book on Web publishing yet to appear. While it contains little that is novel, at least to those who have read Nielsen's www.useit.com Web site and other such resources, the lessons it teaches have not reached widely enough: there are all too many Web sites that are a continual source of frustration and stress to users. (Nielsen begins by explaining why he chose to write a printed book on Web design: for comprehensive, sustained arguments online reading is not yet as effective as print. Another consideration is that, going by the utter un-usability of so many corporate Web sites, there must be many web site managers who don't actually use the Web: some of these might read a printed volume.)

At the core of Designing Web Usability, and two thirds of it by page-count, are chapters on page, content, and site design. The first covers cross-platform design, the importance of minimizing response times, how to use links effectively, and the advantages and disadvantages of style-sheets and frames. The second covers writing for the Web, micro-content (titles, headlines and so forth), and multimedia content (images, animation, audio, and video). The last covers navigation, home pages ("splash screens must die"), search support, and "URL design." Other chapters cover special usability issues with intranets, accessibility for users with disabilities, and internationalization and localization; in a final chapter Nielsen takes a stab at predicting the future of the Web.

Because Designing Web Usability addresses underlying ideas rather than specific technologies, it will date far less rapidly than most books on Web publishing. It doesn't contain as much as its 400 pages would suggest, since a lot of space is used for screen shots of example Web pages. (These are not, however, gratuitous, as is often the case with books on HTML.) Web publishing is very different from paper publishing, but Designing Web Usability is a high quality, usable book -- only a few minor things got past the proof-readers. Check Danny's Other 500 Reviews

Review Two: Cliff Lampe

The Scenario

In Designing Web Usability, Jakob Nielsen codifies his ideas and wisdom on user-centered design. This is the first book in a two-parter, to be followed by Ensuring Web Usability, which will be more analysis centered.When I first was reading through this book, the irony of reviewing a usability book for Slashdot absolutely thrilled me. A common complaint about Linux, whether deserved or not, is that it is completely unusable. Except for a few shots at both the Windows and Mac OS, Nielsen obviously stays away from this topic. On the other hand, his advice on Web design is well researched, sensible, and right on target. Since human/computer interaction is what may be referred to as my "bag," I found this book impressively concise and comprehensive.

For those who may have missed the usability boat, Nielsen advocates user-centered design. This is the radical idea that a computer is a tool for managing information, not an end in itself. As many of us know, this concept is remarkably easy to lose in the rush to make everything work in the first place. When it comes to usability, everyone has their ideas about what they like, and tend to include them in their own designs. The problem is, we creators of Web sites may be too far removed from our users by experience or some other perspective to be designing in their best interest.

Eminently practical, Nielsen gives step-by-step advice on how to design with your user in mind. His examples are backed by screenshot examples and extensive user studies. The first section deals with page-level design, with advice on colors, layout and use of special features. Further sections of the book deal with site and intranet design, usability issues surrounding various disabilities and the future of Web design. One especially welcome chapter deals with actual creation of content in a Web environment. Writing for the Web is vastly different from writing for other media, like newspapers or magazines, but this is rarely recognized.

Once Nielsen has dispensed with the advice that is applicable to the Web environment we all deal with today, he spends the last section discussing the future. As the author says, we tend to overestimate the short-term effects of technological change and underestimate the long term effects. Keeping this in mind, Nielsen makes some stabs at predictions of his own (like the gradual erosion of the Post Office) that seem accurate and eerie at the same time. He makes the good point that most of the user interfaces we deal with today are descendents of the 1984 Mac. That's like using your little aquarium net to snare salmon. With the eventual dissolution of Web browsers will come a need for user interfaces that more capably deal with a glut of information.

I have some advice for reading this book. Treat it like a computer manual, and don't necessarily read it from cover to cover. Read the section on content design for sure, but depending on your familiarity with human/computer interaction principles, you may want to poke around a little more. Fortunately, and in typical Nielsen fashion, the book is laid out perfectly to make this kind of browsing convenient. That being said, if you do read straight though it, you won't be disappointed.

What's Bad?

There are a couple of concerns I had with the book. One is that the layout is wacky, though I understand this is more the fault of the publisher than Nielsen. There is a straight narrative, like in any other manual, but it is broken frequently by screenshots and pull-out comments that attract attention away from the main narrative. The integration is good enough that you can pick up where you left off easily enough, but a tighter bundling of content with the visuals would have been welcome.

Secondly, the last chapter should have had some content stolen for the preface. Many of the limitations mentioned by Nielsen immediately beg the question of higher bandwidth on the horizon or more powerful computers. The book is so practical I almost found myself playing devil's advocate in response. At the same time, the advice is so well backed up by research, that to rail against it feels a little bit like yelling at your mom for telling you vegetables are good for you.

What's Good?

This book is so efficiently packed with tons of great advice that I read some sections again and again to make sure I didn't miss anything. Nielsen does not waste time over-elaborating his points, which is a welcome change from most books of this sort. The data from actual user studies are important to prove to a skeptical web developer that these considerations are real, and the actual examples of the Web pages and sites give incredible insight to the point being made. One of the pages captured even has a Jon Katz article on it.

So What's In It For Me?

If you are responsible for developing Web sites, or just a duffer who makes his greeting card collection available on the Web, read this book. The advice is sound, researched and proven over and over. If you are a usability engineer, this book may be on the general side for you, but otherwise it is the best introduction to these concepts assembled in one place that I have even seen.

As I was reading through this book, I kept thinking of various pages and sites that I had designed. What would be said if one of those pages had been captured and displayed? Would it be an example of what to do, or what only an idiot would do? These are good questions for any of us.

Purchase this book at ThinkGeek.

chromatic, lord of many reviews, has come up with a review of MySQL, from the folks at New Riders. Author Paul DuBois has gone beyond the technically comprehensive MySQL documentation to produce an informative and entertaining compendium of MySQL knowledge. Requiring little prior experience ("What is a database and why should I care?"), he explains general SQL and RDBMSs, as well as the peculiarities of MySQL. MySQL author Paul DuBois pages 756 publisher New Riders rating 8.5 reviewer chromatic ISBN 07357-0921-1 summary There's something for everyone -- user, developer, administrator -- in Paul DuBois' excellent MySQL book.

The Scoop Paul DuBois has gone beyond the technically comprehensive MySQL documentation to produce an informative and entertaining compendium of MySQL knowledge. Requiring little prior experience ("What is a database and why should I care?"), he explains general SQL and RDBMSs as well as the peculiarities of MySQL. What's to Like? The prose is clear and readable. At the start, DuBois walks the reader through designing two very different database projects. After the first chapter, a normal user will be proficient at manipulating the client and issuing basic commands -- even designing her own tables. From there, the rest of the MySQL world opens up as more detail emerges. The sections on optimizing queries and table indexes will prove particularly valuable as the database grows from a hobby into a valuable project of its own.

Almost anyone working with MySQL will find appropriate information, no matter his approach. While the standard client receives ample attention, Perl and PHP Web interfaces are developed and explained in later chapters. After explaining the general ideas of the particular interface, DuBois walks through the design and evolution of programs to fill specific tasks. These programs start with basic functionality and gradually add more features until the original goal is met.

Though the book explicitly covers stable version 3.22 and development version 3.23, features introduced in newer versions are marked and features on the roadmap are mentioned. Deprecated functions and replacements are labeled, too. As well, the section on "missing features" is useful, giving suggested workarounds, when present. (Examples include subselects and transactions.) ANSI SQL receives plenty of attention -- even where the MySQL implementation strays. It's an honest approach.

DB administrators aren't left out -- a full section is dedicated to their own issues. Security and permissions receive due treatment, as does performance tuning. The section on maintenance and database relocation was particularly interesting. There's even a treatise on the structure of the database files (notable for the differences between the ISAM and MyISAM formats).

Finally, the included appendices are well-selected. Weighing in at slightly less than a third of the pages, this tome will not have time to gather dust on my bookshelf. Most pertain to programmers, but having a physical guide to the built-in MySQL functions has a certain appeal.

What's to Consider? While filed with useful information and clear examples, the Perl chapter had a distinctive C flavor to it. As the corresponding C chapter assumes familiarity with that language and the PHP discussion starts with an introduction to PHP, the author assumedly addresses potential MySQL programmers in three categories: C programmers, Perl dabblers, and PHP initiates. While this likely reflects the makeup of his intended audience, it may also prove distracting to more experienced users. (Suggestion for these folks: read the example code and skip to the API appendix.)

A minor nitpick is the binding and cover of the book. My review copy managed to attract lots of dirt on the nice cover, and it developed a serious crack in the spine, in the middle of the Perl DBI chapter. Some of the affected pages are coming loose, after moderate usage. Hopefully this is just a defect in my copy.

Be aware that much of the example prose has a touch of free-Unix to it. Nearly all options will work on the Windows platform, but users unaccustomed to extended command line forays may feel uncomfortable. (Since this also applies to the database, it's barely worth mentioning.)

The Summary MySQL is an excellent book, with a good balance of database introduction, believably practical examples, and technical information. Want to program, set up, or administer a MySQL system? You won't go wrong here.

Purchase the book at ThinkGeek.

Table of Contents

1. General MySQL Use
2. 1. Introduction to MySQL and SQL
   2. Working with Data in MySQL
   3. MySQL SQL Syntax and Use
   4. Query Optimization
3. Using MySQL Programming Interfaces
4. 1. Introduction to MySQL Programming
   2. The MySQL C API
   3. The Perl DBI API
   4. The PHP API
5. MySQL Administration
6. 1. Introduction to MySQL Administration
   2. The MySQL Data Directory
   3. General MySQL Administration
   4. Security
   5. Database Maintenance and Repair
7. Appendixes
8. 1. Obtaining and Installing Software
   2. Column Type Reference
   3. Operator and Function Reference
   4. SQL Syntax Reference
   5. MySQL Program Reference
   6. C API Reference
   7. Perl DBI API Reference
   8. PHP API Reference
   9. Useful Third-Party Tools
   10. Internet Service Providers

Carey Bunks wrote to tell us that last week, "a new GIMP site, Gimp-Savvy.com, has come online and is making available the complete text of the recently released book Grokking the GIMP . This new GIMP resource, written by me and published by New Riders, has been released under an Open Publication License. The goals of Gimp-Savvy.com are to provide high-level educational and practical resources for the GIMP, and to promote its skillful and knowledgeable use."

It's good to see high-quality books on open source software, and this one is well-organized, thorough and profusely illustrated. It happens to make a great online GIMP tutorial as well.

Note: as you might expect, many of the Web pages that make up the book are image-heavy (as you might expect), so if you're on a slow connection, browse the detailed, outline-format table of contents carefully.

And if you do have the bandwidth, you can slurp down the entire book to browse later. When's the last time you read a book that came as an HTML tarball?

Eric Harlow, author of Developing Linux Applications with GTK+ and GDK has written a book well worth reading. A good first round of things, click below to find out how to write more of applications/widgets/whatever. Thanks to A.M. Kuchling for the review. Developing Linux Applications with GTK+ and GDK author Eric Harlow pages publisher New Riders rating 6 reviewer A.M. Kuchling ISBN summary A reasonably good first book on GTK+, though it's not likely to become the definitive one unless the second edition makes some minor improvements. REVIEW: Developing Linux Applications with GTK+ and GDK Eric Harlow New Riders

Nutshell
Review: A reasonably good first book on GTK+, though it's not likely to become the definitive one unless the second edition makes some minor improvements.
Rating: 6/10 A.M. Kuchling The Scenario-->

The GTK+ GUI toolkit was developed for the GIMP, and was subsequently adopted by both the current Mozilla codebase and the GNOME project. I believe this is the first formally published documentation for the GTK+ toolkit. (It is not a generic guide to application development under Linux, even though the spine of the book reads only "Developing Linux Applications".)

The book provides good coverage of the fundamentals that you need to know: the basic data structures provided by GLIB; the overviews of buttons, menus, dialog boxes, and all the other major widgets; and four sample applications -- a calculator, text editor, Minesweeper game, molecule viewer, and a simple Defender game. Harlow's development of each topic is understandable and helpful, making the book a vast improvement over struggling through the toolkit's source code, and well worth purchasing if you want to program with GTK+.

My one major problem with the book is, surprisingly, wishing there were more screenshots in it. The opposite is true of most computer books, because a screenshot and a paragraph of text can be made to fill a whole page, and helps immensely in padding out a book to make it look bulky and comprehensive. This book goes to the opposite extreme; there's no screenshot of the calculator application at all, and only one or two screenshots for each of the other sample programs.

Another flaw is that the book seems to contain every single line of code for the sample applications. As a general rule, in any given C program, 90% of the code is uninteresting; only 10% contains the heart of the program, and the rest is all scaffolding. I would have preferred to see a dissection of the central portions of each program in pseudocode and small chunks of C code, relying on the Web to get the complete distribution, instead of having to flip past page after monospaced page of program listings. So What's In It For Me?-->

This book rates 6 out of 10 points, because it covers GTK+ quite well, and provides you with the basic information you'll need to hack with it. It would get 7 out of 10 points if there were fewer pages of code and more illustrative screenshots.

Purchase this book over at Computer Literacy.

Table of Contents

1. Introduction to GTK+
2. GLIB
3. Developing GUI Applications
4. Basic Widgets
5. Menus, Toolbars, and Tooltips
6. More Widgets: Frames, Text, Dialog Boxes, File Selection Dialog Box, Progress Bar
7. Writing a Calculator Application
8. Developing a Simple Word Processor
9. Minesweeper
10. Graphics Drawing Kit
11. Styles, Colors, Fonts, Cursors, and Referencing
12. Molecule Viewer Using GDK
13. Sprites and Animation
14. Trees, Clists, and Tabs
15. Creating Your Own Widgets