Slashdot Mirror

Zoolander writes "Christopher Tolkien has completed the last book of J.R.R. Tolkien from notes left from his father." The ultimate question is how much of a quality difference will there be; for instance the difference between Dune and Dune: House Atriedes is a pretty big gap. But in my experience, Christopher Tolkien has always taken a good, cautious approach when it comes to his father's work so here's to hoping.

Zoolander writes "Christopher Tolkien has completed the last book of J.R.R. Tolkien from notes left from his father." The ultimate question is how much of a quality difference will there be; for instance the difference between Dune and Dune: House Atriedes is a pretty big gap. But in my experience, Christopher Tolkien has always taken a good, cautious approach when it comes to his father's work so here's to hoping.

Ravi writes "Perl (Practical Extraction and Report Language) — the language which was created by Larry Wall is arguably one of the greatest programming languages. But it has a reputation for taking an excessive cryptic nature which gives it an image especially among Perl novices as a language which is complex and hard to master. Minimal Perl: for Unix and Linux people, authored by Tim Maher and published by Manning Publications addresses the obstacles presented by Perl's complexity. This book which is divided into two parts comprising of a total of 12 chapters takes a unique methodology to explain the Perl syntax and its use. The author emphasizes on Perl's grep, awk and sed like features and relys on concepts such as inputs, filters and arguments to allow Unix users to directly apply their existing knowledge to the task of learning Perl." Read on for the rest of Ravi's review. Minimal Perl for Unix and Linux People author Tim Maher pages 464 publisher Manning Publications rating 8 reviewer Ravi ISBN 1932394508 summary Provides a slice of Perl which when mastered can accomplish most of the jobs which require Perl What I found while reading this book is that the "Minimal Perl" is a specially crafted subset of Perl language designed to be easily grasped by people who have a Unix background and who wish to use Perl to write their scripts. Its aim is to filter out the complex way of writing programs using Perl and whenever possible to accomplish tasks using just one or two lines of Perl. In the first part of the book, the author explains how Perl can be used to do the same tasks as accomplished by common Unix tools such as grep, awk, sed and find. He goes one step further by explaining how one can accomplish much more and in a much simpler way by using Perl techniques.

Throughout the book, the author makes sure that the learning curve in acquiring Perl skills remain gentle. Perl is a language whose syntax has a multitude of options, this book is peppered with numerous tables which provide excellent information at a glance. For example, in the third chapter titled "Perl as a (Better) grep command", the author lists and compares the fundamental capabilities of Perl and the different grep commands such as grep, egrep and fgrep which clearly shows the advantages that Perl has over grep. In another table, you get a birds eye view of the essential syntax of Perl's regular expressions and their meaning. This chapter alone has around 12 tables. This is a really nice feature because it doubles as a Perl reference where you can flip to the respective page and get the information you need.

The main strength and drawback of a language such as Perl is its dependence on regular expressions for accomplishing complex tasks. Once you master the regular expressions, the sky is the limit for ordering and segregating data using this language. In Perl, there is more than one way of doing the same thing. What is unique about this book is that the author specializes in explaining the easiest way of doing a particular task.

In many places, the author demonstrates complex tasks using just a few lines of Perl code. Many of the examples covered in this book are practical examples which give an idea of how the commands relate to the final outcome. For instance, while elaborating on the one line grep like commands in Perl, the author illustrates a web oriented application of pattern matching where he shows how to extract and list, the outline of slashdot.org site's front page. The surprising thing is this is accomplished using just a single line of Perl code. This book has lots of such one line examples which teache how to use Perl intelligently using minimal effort.

If part I of this book focuses on ways in which simple Perl programs can provide superior alternatives to standard Unix commands, the second part throws light on the other aspects of Perl concentrating on the syntax of the language and various built-in functions and modules available which do away with a lot of re-invention of the wheel, so to speak, and helps churn out code which is portable.

Chapter 7 titled "Built-in functions" introduces an eclectic mix of functions available in Perl. You have functions which are used to extract a list of fields from a string, functions to access the current date and time, generating random numbers, sorting lists, transforming lists, managing files with functions and so on. These functions are broadly classified into those which generate and process scalars and those that process lists.

In chapter 8 of this book, the author involves the reader on the numerous scripting techniques that can be used to write better Perl programs.

It was quite surprising that the author has chosen to discuss the variables, more specifically the list variables comprising of arrays and hashes, as well as the looping constructs only in the 9th and 10th chapters, when they should be somewhere up front. In hind sight, I feel it is a good decision. Once you execute the one liner Perl programs in the initial chapters, you will be fairly confident in using Perl by the time you reach the 9th chapter.

The last two chapters deal with creating sub-routines and modules. Over the years various Perl programmers have created modules which are used for diverse purposes. With an aim to share these modules, they are collected and stored at one central place known as CPAN, which is an acronym for Comprehensive Perl Archive Network. The final chapter, apart from teaching how to create modules in Perl and manage them, also introduces the CPAN and ways in which one can find the right module by searching on CPAN.

The special variables cheat-sheet and the guidelines for parenthesizing code provided in the two appendices are really useful as a quick reference while writing Perl programs.

This is not a comprehensive book on Perl, rather the author provides a slice of Perl which when mastered can accomplish most of the jobs which require Perl. You won't find object oriented concepts of Perl being mentioned in this book. In many ways the author has moved beyond explaining a subset of Perl by providing a section titled "Directions for further study" at the end of each chapter, where the author lists further material which can be used to learn more about the topic that is covered.

I really enjoyed going through this book, especially because of its focus on the practical side of using Perl and taking a minimal approach.

Ravi Kumar maintains a blog titled "All about Linux" where he shares his thoughts and experiences in using Linux, Open Source and Free software.

You can purchase Minimal Perl for Unix and Linux People from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

John Suda writes "It's been over five years in the making and its nearly perfect. No, Im not referring to Microsoft's vast new operating system named Windows Vista, but to the reference book Windows Vista: the Missing Manual, by author David Pogue. The book is the latest, and perhaps best, in the Missing Manual series published by Pogue Press / O'Reilly Media, Inc. The Missing Manual series is the benchmark of quality for computer manuals. Unless youre a system administrator, programmer, or uber-geek, this is probably the only reference source you'll need to learn Microsofts Vista." Read below for the rest of John's review. Windows Vista: the Missing Manual author David Pogue pages 848 publisher O'Reilly Media rating 9 reviewer John Suda ISBN 0596528272 summary The only reference source you'll need to learn Microsofts Vista

Vista is the long-awaited successor to Windows XP and it is a major overhaul and upgrade of that operating system. It was designed primarily to address long-standing security issues with XP and its predecessors, but it also has a vastly new look and feel graphically and in operating features. It comes with a large number of new programs and features and its innards have been significantly beefed up, as it is a 64 bit operating system, focused on the intermediate future of computing hardware and software.

There are so many changes in Vista that it would take perhaps a dozen pages just to provide a bare-bones description of everything. You dont get any written material from Microsoft when you buy Vista. There are digital support and help resources built in and available elsewhere for Vista, but they are not convenient to use and they are relatively limited in scope and depth. Vista, the Missing Manual, provides the information Microsoft doesnt. It covers all five North American versions of Vista. Page 6 has a handy comparison chart of each version. The beginning of every content section refers to which version of Vista the discussion applies.

This Missing Manual uses every bit of 827 pages (including index) to provide similar descriptive and informational material as the built-in Vista sources, but provides much, much more:

Beyond mere description of features and functions, the book explains and evaluates all of the major (and many of the minor) changes from Windows XP to the new Vista. The introductory chapter itemizes all of the most important changes providing perspective on what Microsoft has done with the new operating system. It also highlights some of the more significant interface changes the new search tool, the revised Start Menu, and the new ribbon bar.

The author notes, at every point relevant, the options a user has in either using a new Vista feature, or in reconfiguring the operating experience to return to pre-existing features and the aesthetic elements of Windows XP and earlier versions of the operating system.

Pogue provides an expert users perspective on the value of the changes and new features in Vista. Some things are improvements and upgrades; others are rated as inferior to what was before. If you dont like the new or changed feature, Pogue guides you how to revert to previous iterations of the featuress, or otherwise provides workarounds.

Pogue is great at providing an expert users perspective on working with the operating system efficiently and pragmatically. He doesnt just describe a feature or function but includes tips and guides on how to be more efficient and practical with it and provides reference to other resources available for additional information or guidance. The Manual is written so that one almost feels that they are getting a one-on-one, hands-on lesson, in using Windows Vista. He represents the Alpha-geek relative you might have to help you out when you cant figure out how to do or fix something.

Beyond all of the information, guidance and perspectives, Pogue has a great writing style. The writing is sprinkled with wit, sarcasm, and good-natured humor, extremely rare for a computer related book. Microsoft gets more than a few slams for its many foibles, all well earned. WordPad, for example, no longer opens Word files!

The author writes for multiple levels of need and understanding. He details the basics of Windows Vista for beginners, provides richer material in breadth and depth for intermediate users, and a good amount of material useful for power users, both informationally and in advanced tips. There are many sidebars sprinkled throughout called Power Users Clinic which offer more technical tips, shortcuts, and information to PC veterans.

There is a lot new to Vista. The most important, if not the most noticeable, are the security enhancements. Microsoft now has a user account control which limits installation of new applications to a user who has administrative permissions. By default, the operating system generates accounts for simple users, without the ability to allow installation of new programs. There is a full page of FAQs just regarding the user account control.

A major security upgrade is service hardening which prevents access to the all-important system files by outsiders or unauthorized users. Other new security elements are the Windows Defender program designed to prevent spyware installs, a phishing filter in Internet Explorer, parental controls, protected mode, drive encryption, address space randomization, and much more. That list doesnt even include a new backup program to help protect users from nonfeasance in basic computer operations (although the author recommends third-party software.)

What is most noticeable is the appearance of the desktop, windows, icons, system font (Sergoe UI), and interface features. These are all redesigned to take advantage the vastly enhanced graphic capabilities of Vista referred to as Aero. The Start Menu has been redesigned to be easier to use. The conventional menu bar for the desktop and most application windows has been replaced with a content-based ribbon bar.

There is a lengthy list of new applications, most significantly Windows response to Apple Macintoshs iLife suite of media applications. In Vista, these are the Photo Gallery, Calendar, DVD Maker, Media Player 11, and DVD Maker. It adds to that group, Meeting Space, which is a collaboration program for local network users.

The Windows Sidebar is modeled after Apples Dashboard, which allows customized applets to be displayed and used. A useful cautionary note mentions that the Sidebar gadgets dont save data or configurations when closed. You must start all over again.

Mr. Pogue is an accomplished writer and computer expert having authored over 40 books, including 17 of the Missing Manual series. Hes well regarded as the weekly technology columnist for the New York Times and a correspondent for CBSs News Sunday Morning. Hes been assisted here by four other experts who contributed chapters or parts of chapters to this manual. The writing is clear, concise, and jargon free. The book provides a fair evaluation of Microsofts latest operating system and gives it good grades overall. Pogue routinely points out the areas that Microsoft has unashamedly copied from Apple Macintosh, and notes it as a good thing.

The book is organized into eight parts including a set of appendices. These include the Desktop (or user workspace), the Vista software, Online and Internet connection matters, the new Pictures, Movie, and Media applications, hardware and peripherals, PC health and maintenance, and networking with Vista. The page layout is clean. The book is filled with hundreds of screenshots and numerous step-by-step instructions on nearly all of Vistas elements. The discussion is comprehensive and deep.

Part One explains the Desktop and whats new, including the Welcome Center, Start Menu, and the greatly enhanced search tool which graces every window and the desktop itself. It now offers natural language searching for the first time. For those using older hardware which may not be up to par for Aeros graphic demands, Pogue provides a handful of suggested speed tweaks. A full 10 pages is devoted to Microsofts improved speech recognition system, including a large handful of insights from an experienced user of such software. The author is a fan of Dragon s Naturally Speaking program, but gives good reviews to Vistas capabilities.

Part Two contains most of the material on the new programs and the improved programs Internet Explorer and its new RSS capability, tabs, and search bar, Mail (the Outlook replacement), and the Control Panel, which now contains at least 50 icons for mini-applications, wizards, links, and folders. Chapter 8 provides an applet by applet description. Dealing with the Internet with Internet Explorer and Mail comprises most of Part Three. There is a comprehensive section on connecting to the Internet with the growing number of methods-cable, DSL, dial-up, WiFi, cell, etc.

The media applications are covered in detail in Part Four including comparisons of Microsofts media applications to iTunes and Zune. The discussion of Media Center includes tips on managing recorded TV and setting up media hardware. Part Five deals with the fax, print, and scan functions and hardware related matters. Especially interesting are the printer tricks and the section on laptops, tablets, palm tops and hand-recognition software.

For maintenance, troubleshooting, and problem solving, there is a trio of chapters in Part Six covering disk maintenance and repair, the new dynamic discs feature, compression and encryption, and backups. Geeks may be interested in knowing how to uncover the hidden controls for the new improved firewall. Pogue even provides material on energy conservation and how to configure Vista to work most efficiently for the user.

Part Seven covers the basics of accounts and networks. There is a lot new in Vista, especially in regard to its separate users architecture. The difference between workgroup and domain networks is explained clearly. Sharing and collaboration functions are explained and there is a comprehensive and deep section on remote control using a multitude of methods.

The appendices are great. Appendix A. discusses the installation of Vista in a comprehensive, systematic manner, from pre-purchase and installation considerations, to making decisions about upgrades or clean installs, to dual booting. He describes the new Welcome Center which aggregates many of the initial configurations for a user, or for multiple users.

Appendix B. is cheekily titled Fun with the Registry and is an introduction, with examples, to the notorious registry which is carried over from XP and predecessors. Most authors writing for this level of reader tend to avoid discussion of the registry, but Pogue provides just enough material to intrigue the intermediate user.

Appendix C. is a short itemization of whats missing in Vista from previous Windows operating systems. It makes it easy to figure out why something youve used before cant be located and used. Appendix D. is a master list of keyboard shortcuts for both the operating system and its major applications, like Internet Explorer 7, and the new Windows Mail.

There is no wasted space or text in this book. Its worth every cent of its $34.95 price. As a small bonus, copies of shareware programs mentioned in the book are conveniently available for download at www.missingmanual.com.

You can purchase Microsoft's Vista: the Missing Manual from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "Computer programming books come in all varieties, but there are at least four general categories: introductory texts, which typically have the lowest content per page; language references, which have become increasingly supplanted by online sources; "advanced" treatments, which are often a mishmash of errata-riddled articles; and "how-to" books, usually at the intermediate level, and sometimes presented as "cookbooks." It is that last category that has been growing in popularity, and for good reason. When an experienced software developer needs assistance, it is rarely for language syntax, but instead a desire to see how someone else solved a specific problem. For solutions using the PHP language, one source of information is PHP 5 in Practice." Read the rest of Michael's review. PHP 5 in Practice author Elliott White III and Jonathan D. Eisenhamer pages 456 publisher Sams Publishing rating 8 reviewer Michael J. Ross ISBN 0672328887 summary One of the most meaty, immediately useful, and fluff-free PHP books available

The book was authored by Elliott White III and Jonathan D. Eisenhamer, and put out in July 2006 by Sams Publishing (an imprint of Pearson Education). Given today's standards of hefty technical books, this particular one is relatively light, weighing in at 456 pages, which are organized into an introduction, numerous chapters, and three appendices.

Its introduction is more interesting than that of most similar books, whose introductions usually consist of formatting conventions and explanations as to why the book was written — all such content providing little to no value to the impatient programmer facing a deadline, and invariably ignored (the content, that is, not the deadline).

White and Eisenhamer took a refreshingly different tack, and chose instead to explain their use of coding standards, comments and whitespace, braces and parentheses, PHP short tags, PHP mode, and other language considerations that are more useful than the typical rundown of somewhat childish icons used in other texts, such as light bulbs and red warning signs.

Switching to the other end of the book, we find three appendices. The first one briefly discusses issues one might face in migrating from PHP version 4 to 5. The second introduces the Standard PHP Library (SPL), and the objects related to its primary design pattern, the Iterator. The third appendix discusses what composes the bulk of output from my PHP programs: error messages. Seriously, this appendix is worth reading, if only for the suggestions as to what to look for when you encounter some of the most common PHP error messages.

The bulk of the book's material is divided into 20 chapters, which are themselves divided into two parts: PHP internals, and applications. The internals are: strings, numbers, time and date, variables, arrays, functions, classes and objects, and files and directories. Starting off with a discussion of strings, might seem odd to the neophyte programmer, but to the veteran who has had to learn several languages during their career, the choice makes a lot of sense. There must be countless developers out there who, being fluent in the C language and object-oriented concepts, jumped into writing their first C++ program, and had to hit the books for the first time when they wanted to do some non-array-based string handling.

The book's second part covers some of the most common applications in PHP programming: Web page creation (using XHTML and CSS), Web form handling, data validation and standardization, sessions and user tracking, Web services and other protocols, relational databases and other data storage methods, e-mail, XML, images, error reporting and debugging, and user authentication and encryption. That last chapter, in the next edition, should be relocated so that it precedes or follows the chapter on sessions and user tracking.

Many of the chapters begin with a "Quick Hits" section, which briefly summarizes how to perform many of the most common and essential tasks related to that chapter's topic. For instance, in the chapter covering the use of variables, this first section explains how to: check if a variable has no value or if it is empty (not synonymous in PHP), undefine a variable, cast it to a certain data type, and do the same thing for a value. There is one minor erratum that should be noted: On page 71, in the first "Quick Hit," it reads "a variable has bee. given a value." ("been"'s "n" ended too soon.)

Each section within the chapter briefly explains the problem domain, and then presents sample code to solve the given problem. The code itself is fairly well commented, and the variable names are adequately descriptive (unlike in some programming books, whose coding standards border on the criminal).

All in all, the book offers a lot of worthwhile solutions to a wide range of problems, and does so in a straightforward manner. It is for this reason that it is not evident as to why this particular PHP title has received so little notice. For instance, on Amazon.com, it has received only one reader review, as of this writing, and does not even make it into the top quarter million books ranked in sales by Amazon.com. It is a pity, because the book deserves much more attention.

Even though this book is to be recommended, and is packed with code and text that are well worth studying, it has one unmistakable weakness for which this writer can think of no adequate justification. The book contains almost no illustrations, even when they are clearly called for — in fact, especially in those cases. For instance, the section that shows how to generate a calendar, does not show a calendar! The code is present, but the sample output — which is what the poor reader would appreciate, to see the results of the code — is missing.

Granted, an absence of figures and screenshots might be understandable for the first part of the book, which covers the PHP language itself. But the second part, covering applications, has far too many unillustrated PHP scripts. These include sections focusing on drop-down menus, progress bars, and graphical charts Web forms. In the last chapter, there is a section with code that generates captchas, but the reader is not shown what they look like. The entire 18th chapter is devoted to images, but contains not a single one! I cannot imagine why the authors and/or publisher chose to leave out these essential graphics. Was it to save money? Whatever the reason, it was a significant mistake, and one that should be corrected in the next edition.

Readers who agree with this assessment, or who have other thoughts concerning this otherwise excellent book, can leave feedback via the book's Web page on the Web site for Sams Publishing. This page offers details on the book, a description and table of contents, links for requesting instructor or review copies, and a tool for searching the book's contents within the Safari online technical library. The book's introduction states that the Web site hosts all of the code listings, as well as a list of errata. Yet, I was unable to find either one. (Sadly, the Pearson Education sites are still some of the least usable in the technical book publishing world.) Much better results were obtained on Eli White's site.

Despite an inexcusable and almost complete lack of needed illustrations, PHP 5 in Practice is possibly one of the most meaty, immediately useful, and fluff-free PHP books available. No serious PHP programmer should be without it.

Michael J. Ross is a Web consultant, freelance writer, and the editor of PristinePlanet.com's free newsletter. He can be reached at www.ross.ws, hosted by SiteGround.

You can purchase PHP 5 in Practice from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Trent Lucier writes "On most networks diagrams I've seen, the internet looks like a cloud. Sometimes it's a fluffy white cloud. Other times it's a dark ominous cloud. Regardless of the artistic style, the depiction usually conveys the mystery and danger of putting your company's network on a global information grid next to a billion users, kind of like those old maps with dragons drawn at strategic places in the ocean. Not surprisingly, corporations spend much time and energy protecting themselves from The Outside World. In Enemy at the Water Cooler, Brian Contos argues that just as many resources should be spent on defending against insider threats. Will this book help you detect the enemies at your water cooler?" Read below for the rest of Trent's review. Enemy at the Water Cooler: True Stories of Insider Threats and Enterprise Security Management author Brian T. Contos pages 302 publisher Syngress Publishing rating 8 reviewer Trent Lucier ISBN 1597491292 summary A thorough introduction to insider threats and the countermeasures that can be used against them

Contos, a Chief Security Officer himself, has written a primer on insider threats and the counter-measures that can be deployed against them. The book is written for a wide audience, so don't expect low-level details about encryption algorithms and security protocols. However, if you have to deal with a large company's IT infrastructure, you may benefit from Contos' descriptions of enterprise security concepts and anecdotes.

According to the book's terminology, an insider is someone who has more privileges than the common person and uses those privileges to abuse the system. It's important to understand the full scope of the term "privileges". In addition to computer privileges, Contos is also talking about physical access to hardware, paperwork, and even other employees that can be exploited in social engineering attacks. Even if a piece of information is useless to the insider, it may be something that a competitor would be willing to buy for the right price.

The early chapters provide background on all the standard attacks that are in the news these days: phishing, denial of service, keylogging, etc... What makes these sections interesting are the statistics that are sprinkled throughout the text. In a survey conducted by CERT examining known attacks, 49% were committed by insiders that were married. This goes against the profile of the insider being someone who has less personal risk (such as a family) at stake. In fact, the prevailing image of the last 30 years depicting a computer criminal as a socially awkward young male has started to become less accurate as organized crime has turned into the biggest threat.

Enemy At The Water Cooler does a great job of putting statistics in context. The book is always careful to mention that the crime statistics represent only the known incidents. Contos often explains why certain numbers matter. Near a chart showing that 59% of discovered crimes were committed by former employees, the author explains that recently fired employees can be highly motivated to commit revenge and still have access to accounts and passwords, which is a dangerous combination.

How does the book propose that businesses deal with threats? At the end of Part I, Contos introduces a technology called Enterprise Security Management (ESM). This is a blanket term used to describe a collection of enterprise-level tools that can perform information analysis, display event feeds, manage policies, and do everything else in the world besides make toast. The remainder of the book constantly mentions this technology, so if you are not interested in learning about ESM, this book may not be for you.

At this point, it should be noted that Brian Contos is the Chief Security Officer of a company that sells ESM products. The book is neutral on which product you should use, although some screenshots show Contos' program for illustrative purposes. I did not feel that the book was biased or trying to sell me something. Regardless of who the author works for, he makes a compelling argument that ESM systems are necessary for big companies that need to manage their IT security.

Case studies comprise Part II of the book. This is the entertaining stuff, and probably the type of thing most people want to read when they pick up a book called Enemy At The Water Cooler. There are 8 main case studies, each running about 5 pages in length. Contos puts the "study" in "case study" as he illustrates how tools (ESM) and training could prevent many of the scenarios he describes. Those expecting light reading in the form of amusing anecdotes about IT security will be disappointed. However, if you're looking for a detailed analysis of insider crime, these chapters provide it.

Many times, greed and hubris are the ultimate undoing of the insider. In one example, a company discovered that their servers were hosting pirated software. Little did the company know that the employee that was asked to clean up the server was actually the one who put the software there to begin with. The insider would have gotten away with it if only he hadn't bragged to a co-worker about how dim-witted his company was.

In other situations, employees can be blackmailed into committing crimes. In the case of a Spanish company, an employee was forced into planting a wireless access point in one of the development labs. The employee had lied about his educational background on his resume, and criminals threatened to expose him if he didn't cooperate by planting the device.

The final portion of the book discusses further capabilities of ESM. The main point is that ESMs should be able to monitor everything. Contos explains a scenario where an employee pulls financial information from a proprietary system and then uploads it to a P2P network. Most companies do not have the technology to detect such an action. Not that Contos claims technology is the only answer. It is just a tool, and it is useless when not supported by trained employees and policies. At the end of the book, the reader gets information about "soft skill" topics like incident management, hiring processes, and some legal case history regarding insiders.

The book's viewpoint is very top-down with regards to the corporate hierarchy. Executives will no doubt love all the capabilities that Contos claims can be at their fingertips, but individual employees might feel it is slightly Orwellian. Can all this information that the ESM vacuums up be used for evil? The book's implicit answer seems to be "yes", since it is repeatedly made clear that no one can be trusted. But there is never any explicit information given on how the ESM itself can be protected from abuse.

Enemy at the Water Cooler provides a thorough introduction to insider threats and the countermeasures that can be used against them. If you are just interested in stories about insider security crimes, then you may want to pass. (The section on case studies is only about a third of the book's content). However, if you are interested in learning about technology that can help defend against these threats, then this book provides a comprehensive overview.

Trent Lucier is a software engineer. His latest experiment is localhost80.com"

You can purchase Enemy at the Water Cooler: True Stories of Insider Threats and Enterprise Security Management from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Aeonite writes "Billed as the 'first complete guide to writing for games', Game Writing: Narrative Skills for Videogames provides an excellent overview of the ins-and-outs of writing for the videogame industry. As might be expected from a publication of the IGDA's Game Writers' Special Interest Group, the book is dense with information, addressing everything from high-level narrative theory to the specifics of dialogue engine design and game localization." Read the rest of Aeonite's review. Game Writing: Narrative Skills for Videogames author Chris Mark Bateman pages 336 publisher Thomson Delmar Learning rating 9 reviewer Aeonite ISBN 1584504900 summary an excellent overview of the ins-and-outs of writing for the videogame industry

When I see that a movie has multiple writers involved, I get a little nervous. It's usually a bad sign, generally indicating that the narrative will be somewhat piecemeal and uneven. As this book has 13 writers and a half-dozen additional subeditors, I was likewise nervous, but I was happy to discover that although each chapter has a different emphasis, the general tone remains steady throughout the book. There's a little more fluff up front, and a little more crunch in the back, but taken as a whole the book maintains a coherent focus. These 13 voices speak in harmony, and adequately cover both the creative and technical aspects of writing for games without any noticeable bumps.

The preface by Chris Bateman explains that a book on videogame writing is difficult to write, as many areas of the industry are still ill-defined. Whereas Hollywood has a fairly standard screenplay format that's fairly easy to work with, the videogame industry offers no single script format, due to the different requirements of different genres and different companies. Personal experience has taught me, for instance, that Microsoft Excel is one of the more useful tools when writing for games; one would not generally associate spreadsheets with narrative flow.

The chief complaint here is that there are no clear examples of great game narratives, with the industry's shining stars falling somewhat below the highest standards of work in other media. My interpretation of this is that Half-Life 2 is less Godfather 2, and more Escape From L.A. — good enough, but not great. According to Bateman, chief culprits for the lack of artistic polish may include the fact that the game industry is so young (compared to radio, television, and movies) and the lack of artistic freedom within the industry.

Worth calling out here is an example of where the industry seems to be falling short. At one point, the book discusses the concept of 'forced failure' in games, and why it's a narrative tactic to be avoided. A good example of this (my own, not the book's) is near the end of the original Half-Life game, which sees Gordon Freeman captured, stripped of all his gear, and dumped in a trash compactor, with the player unable to do anything but watch. Yet Half-Life won numerous Game of the Year awards, and is still considered by many to be one of the best games of all time. The point is not that Half-Life is a bad game for using 'forced failure', but rather that it could have been a a better game if it hadn't resorted to that tactic. In other words, even good games can do better, and this book is a first step towards achieving that goal, by way of establishing a 'coherent narrative language' for games.

The book itself is divided into 14 chapters. The first three can be roughly clustered into a category called Game Narrative, as they all focus on higher-level narrative theory. Chapter 1 provides an overall introduction, defining story, character, and other such terms before delving into what makes game writing unique (as compared to other media) and how a writer uses the tools provided (dialogue, cutscenes, etc.). Chapter 2 covers the Basics of Narrative, including Aristotle's Poetics, Joseph Campbell's Hero's Journey, Freytag's Pyramid, Syd Field's Screenplay model, and the other sorts of things we English majors learn in school in lieu of math and science. Extensive discussion of Star Wars: Episode IV and how it maps to these models is provided, along with some coverage of Jungian and Campbellian Archetypes. Chapter 3 is an overview of what's involved with writing for games, covering the difference between narrative and story, types of narrative, pacing, structure, and the concept of player agency.

The next four chapters of the book contain less high-level theory and more specific application. The first two cover the path the character takes through the game, with Chapter 4 being an exploration of Nonlinear Game Narrative (branching structure, parallel paths, and how to merge story and game) and Chapter 5 discussing how to keep the player on track (breadcrumbing, funneling, the "edge of the world", etc.). Chapter 6 covers Game Characters (including types of protagonists, antagonists, and NPCs, and the traits and characteristics thereof), and Chapter 7 deals with the specifics of cutscenes and scripted events, and the dangers of removing player control.

Chapters 8 through 10 see the camera zooming out a bit more to cover the broader concepts of Writing Comedy for Videogames, Writing for Licenses, and The Needs of the Audience, respectively. Of the three, the last is the crunchiest, covering specific demographic data and the issues of gender, ethnicity and disability as they relate to a game audience.

The final four chapters cover issues specific to videogame writing, and as a whole generally focus on dialogue. The short Chapter 11 deals with Localization issues (translation, lip synching, cultural differences), with Chapter 12 covering Voice Actors more generally, including: a discussion of context, inflection, and emotion; the need to be at the recording session; and other technical considerations. Chapter 13 deals with Interchangeable Dialogue Content, and covers stitching, dialogue driven by game events, and the problems associated with simultaneity, interruptions and inflections. Chapter 14 closes the book on a crunchy note, covering Dialogue Engines in some detail, with many examples of the codelike format involved (dynamic elements, if-then statements, cases and states).

Although it probably goes without saying, this is obviously a book by writers, for writers. The book is very heavy with text, featuring only a very few charts and icons to break up the copy, so as far as layout and flow there's little to complain about aside from some minor inconsistencies, such as the little 'Note' icons which appear in Chapter 3 and nowhere else. Though dense with information, it's fairly easy to find your way around, as the book features an 8-page glossary, 6-page index and a perhaps too-detailed 9-page table of contents. Also worth noting is the copyediting; aside from some very sporadic typographical issues, the book gets an A+ for editing (with Chapter 2 perhaps only an A). Overall, it's hardly worth mentioning, which is always a good thing when it comes to typos.

My biggest complaint with the book is what's not covered. For instance, examples from real games, is billed as a main feature on the back cover, but there could have been more of them, especially with regards to more current games. This is not to say that they're not in there, but certain chapters (particularly those in the book's first third) would have benefited from less Star Wars and more Knights of the Old Republic. It's helpful to be aware of the high-level theory, but this is after all a book about game writing, so more examples from relevant games would be welcome.

I also found myself wishing that the book had devoted a chapter to breaking into the field of videogame writing. Books on other aspects of game design and development typically include such information: I have several on my desk right now that discuss how to create a portfolio and land a job as a Level Designer or Game Designer. Do videogame writers simply spring from the head of Zeus, ready for battle? With this information in place, the book would be a more useful tool to everyone from the pro writer to the complete novice; as it stands, the book is much more helpful to those already in the field. However, wishing that the book covered job entry is, I admit, somewhat akin to wishing that a book on carpentry also included a chapter on lumberjacking. Relevant, but not to be faulted for its absence.

As a whole, the book does what it sets out to accomplish, and provides a good overview of the issues involved in writing for videogames. It's a must-have for anyone in the videogame industry, or anyone who wishes to be.

You can purchase Game Writing: Narrative Skills for Videogames from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "Every Web developer knows that Cascading Style Sheets (CSS) makes it possible to separate the contents of Web pages from the styling of the elements on those pages. This in turn confers tremendous advantages, such as allowing site-wide changes of appearance to be made just once, in a single stylesheet file, rather than in all of the pages containing the affected elements. The syntax and proper usage of CSS is not as simple as implied by many HTML/CSS books, most of which fail to provide enough detail as to how CSS is applied to page elements. Web developers relying upon these books soon find themselves hitting those limits, and becoming frustrated when trying to debug Web pages. CSS: The Definitive Guide, authored by CSS expert Eric A. Meyer, aims to fill that gap." Read on for the rest of Michael's review. CSS: The Definitive Guide author Eric A. Meyer pages 536 publisher O'Reilly Media rating 9 reviewer Michael J. Ross ISBN 0596527330 summary A comprehensive CSS reference guide.

Published by O'Reilly Media in November 2006, this title is now in its third edition. The first edition appeared in May 2000, and the second in January 2004 — with each one establishing the book as an immediate favorite among hard-core Web programmers. Each revision brought it up to date with the evolution of CSS as a standard, its support among the most popular Web browsers, and its usage within the Web development community. This latest edition covers CSS2 and CSS2.1, but does not include the CSS3 modules, including those that have reached Candidate Recommendation status, because their implementation is largely incomplete among most of the browsers.

Web veteran Eric Meyer presents the book's material in a methodical manner, starting with an overview of CSS's purpose and advantages, and quickly moving into the details of the technology: selectors, structure, inheritance, values, units, fonts, text properties, visual formatting, padding, borders, margins, colors, backgrounds, floating, positioning, tables, lists, and generated content (e.g., bullets of unordered lists). The last two chapters address user interface styles (system fonts and colors, cursors, and outlines) and non-screen media (such as paged and aural content). The book's 536 pages are organized into a total of 14 chapters and three appendices. The first appendix is a complete CSS property reference, spanning more than 40 pages, with visual, page, and aural properties grouped separately. For each property, Meyer explains its purpose, its valid values, the initial value, what elements it applies to, whether it is inherited, its computed value, and additional notes (if any). The second appendix is a reference for the selectors, pseudo classes, and pseudo elements. The third and final appendix is much shorter than the first two, but no less interesting, as it discusses a sample HTML 4 stylesheet, which is presented in the CSS2.1 specification as the recommended style sheet for developers to use.

As with all of their other titles, O'Reilly Media offers a Web page devoted to this book, where visitors will find links to online versions of the book cover, table of contents, index, registration form, reader reviews, and errata (of which there are none, as of this writing). In addition, the page has offers to receive a volume discount, and to read the book online as part of O'Reilly's Safari service.

Anyone who is considering purchasing this book might initially be concerned by the dearth of feedback on the Web sites of the publisher and the major online booksellers — in the form of few reader comments, and no reported errata. The prospective reader may wrongly conclude that this indicates a lack of interest in the book, and thus it must be unpopular — probably for good reason. But just the opposite is true, as demonstrated by the book's sales rank on Amazon.com alone: #4631, as of this writing. Unlike far too many of the other HTML/CSS books available, this one does not engender scathing reviews by customers angry with the books' shoddy writing and sloppy mistakes. Rather, Meyer's contribution is the type of solid reference book that the discerning Web developer will quietly place on their desk or bookshelf, within easy and frequent reach — possibly displacing a dog-eared first or second edition of the same title. Furthermore, the absence of errata should suggest that most if not all kinks have been worked out of the book, and not that the book is failing to receive careful readings.

CSS: The Definitive Guide benefits not just from its multiple revisions, but also from Eric Meyer's clear and complete writing style. Unlike his more advanced books, this one is far more approachable, making it possible for the reader to easily jump into the midst of any topic and quickly pick up the thread — as is essential for any technical reference work. The theoretical discussions and the sample code demonstrate his abundant experience in using CSS in the real world, discovering or verifying its idiosyncrasies, and pushing it to its limits. Most of the critical visual and positioning topics are well illustrated with diagrams and sample output, few of which are weakened by the lack of color in the grayscale figures. Last and certainly not least, readers should be pleased that the book's material has been updated for Internet Explorer 7, which promises to fix many inexcusable problems in earlier versions of the browser.

Rarely does one come across a programming book that has no significant flaws, and will likely become a favorite resource for developers everywhere. CSS: The Definitive Guide is a comprehensive, well-written, and welcome addition to the library of any Web developer who wishes to understand and utilize CSS better.

Michael J. Ross is a Web consultant, freelance writer, and the editor of PristinePlanet.com's free newsletter. He can be reached at www.ross.ws, hosted by SiteGround.

You can purchase CSS: The Definitive Guide from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

doom writes "I think they call them "exit polls" because people bolt for the exits when you mention them, but I'm still fascinated by the subject myself, and this book is one of the reasons why. In Was the 2004 Presidential Election Stolen?, the central focus is, of course, on the infamous exit-poll discrepancies of the 2004 US Presidential election; but the authors also put it into context: they discuss the 2000 election, the irregularities in Ohio in 2004, the electronic voting machines issues, and the media's strange reluctance to report on any of these problems. Further, in the chapter "How did America really vote?", they compare the indications of the raw exit-poll data to other available polling data. Throughout, Freeman and Bleifuss do an excellent job of presenting arguments based on statistical analysis in a clear, concise way." Read the rest of doom's review Was the 2004 Presidential Election Stolen? author Steve Freeman & Joel Bleifuss pages 265 publisher Seven Stories Press rating 9 reviewer doom ISBN 1583226877 summary Exit Polls, Election Fraud, and the Official Count

The heart of the book in my opinion, is Chapter 5, "The inauguration eve exit-poll report": The Edison and Mitofsky firms that conducted the NEP exit polls later released a report trying to explain how they could have gotten it so far wrong. Freeman and Bleifuss, of course, take issue with the presumption that the discrepancies must be "errors", and argue in a different direction. This section makes an exciting read (in a nerdy sort of way) it's an impressive piece of statistical judo: Freeman and Bleifuss take on Edison/Mitofsky with their own data, and totally shred their conclusions. The authors show: That the exit-poll discrepancies had a statistically significant correlation with the use of electronic voting machines, with races in battleground states, and in almost all cases favored the Republicans. The "Reluctant Bush Respondant" theory looks extremely unlikely: response rates actually look slightly better in Bush strongholds than in Kerry strongholds; and while media skepticism remains strong among conservatives, it has been on the rise among Democrats, and yet the data shows no shift in relative avoidance of pollsters. They also deal with the various other excuses that were floated shortly after the election: The discrepancies can't be shrugged off with an "exit polls are not reliable" — theory shows that they should be better than any other survey data, and history shows that they always have been pretty reliable. There was no upswing of support for Bush throughout election day — that impression was entirely an artifact of the media "correcting" the exit-poll figures to match the official results. One of the book's authors, Steven Freeman, was one of the first to examine the exit-poll discrepancies, and as a professor at University of Pennsylvania with a background in survey design, he was well equipped to begin delving into the peculiarities he had noticed.

Overall, this is an excellent book for people interested in evaluating the data; with lots of graphs that make it easy to do informal estimates of the strength of their conclusions (just eye-balling the scatter, the correlations they point to look real, albeit a little loose, as you might expect). There's also an appendix with a very clear exposition of the the concept of statistical significance, and how it applies to this polling data. There are of course, limits to what one can conclude just from the exit-poll discrepancies: "We reiterate that this does not prove the official vote count was fraudulent. What it does say is that the discrepancy between the official count and the exit polls can't be just a statistical fluke, but commands some kind of systematic explanation: Either the exit poll was deeply flawed or else the vote count was corrupted. "

This is a remarkably restrained book: unlike many authors addressing this controversial subject, Freeman and Bleifuss have resisted the temptation to rant or speculate or even to editorialize very much. Freeman claims that he is not a political person (and adds "I despise the Democrats"); possibly this has helped him to maintain his neutrality and focus on the facts of the case.

Personally, I found this book to be something of a revelation: in the confusion immediately after the 2004 election, I had the impression that the people who wanted to believe that it was legitimate at least had some wiggle room. There was some disagreement about the meaning of the exit polls: there was that study at Berkeley that found significant problems, but then the MIT study chimed in saying there wasn't, so who do you believe? The thing is, the MIT guys later admitted that they got it wrong: they used the "corrected" data, not the originally reported exit poll results. The media never covered that development, and I missed it myself...

On the subject of electronic voting machines, They include a chapter discussing electronic voting in general which covers ground that is by now familiar with most readers here: the strange case of Wally O'Dell and Diebold; and also the lesser known problems with ES&S. Have you heard this one? "In 1992, Hagel, then an investment banker and president of the holding company McCarthy & Co., became chairman of American Information Systems, which was to become ES&S in 1999. [...] In the 1996 elections, Hagel launched his political career with two stunning upsets. He won a primary victory in Nebraska [...] despite the fact that he was not well known. Then, in the general election, Hagel was elected to the Senate in what Business Week described as 'an unexpected 1996 landslide victory over Ben Nelson, Nebraska's popular Democratic governor.'"

My experience is that a lot of people need to hear this point: "The voting machine company Datamark, which became American Information Systems and is now known as ES&S, was founded in 1980 by two brothers, Bob and Todd Urosevich. Today, Todd is a vice president at ES&S and Bob is CEO of Diebold Election Systems."

It's impossible to see how you can come away from this situation without seeing that we badly need reform of the electoral system: even if you don't believe the 2004 election was "stolen", how do you know the next one isn't going to be? A paper trail that can actually be recounted would be a nice start, eh? But only a start. As the author's point out: "We devoted a chapter to the ills of electronic voting, but a critical lesson of the 2004 election is that not only DREs, but all kinds of voting machine systems are suspect. Edison/Mitofsky data showed that while hand counted ballots accurately reflected exit-poll survey results, counts from all the major categories of voting machines did not."

In one short passage, the authors list a few "grounds for hope", but following up on these points is not encouraging: The Diebold-injunction law suit in California brought by VoterAction has since been denied and one attempt at a paper trail amendment, HR 550 has stalled out.

If you're looking for an answer to the question posed by the book's title, the authors conclude: "So how did America really vote? Every independent measure points to a Kerry victory of about 5 percentage points in the popular vote nationwide, a swing of 8 to 10 million votes from the official count."

Of the many and various potentially depressing books out there about the state of the United States, I recommend this one highly: it addresses a critical set of issues that everything else depends on.

You can purchase Was the 2004 Presidential Election Stolen? from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

SpaceAdmiral writes "You've likely heard of Lee Smolin's book The Trouble with Physics. It has created a lot of controversy because it argues that string theory gets far too much attention and money, despite a complete lack of evidence. It accuses string theorists of groupthink. Smolin has dabbled in string theory from time to time but he's a proponent of the alternative loop quantum gravity. Although irrelevant to this book review, he has also suggested that it is possible that universes reproduce via black holes, making them prone to pressure similar to natural selection (universes that produce a lot of black holes are more successful spawners than those that don't). In The God Delusion, Richard Dawkins quotes Nobel-winner Murray Gell-Mann as once saying, "Smolin? Is he that young guy with those crazy ideas? He may not be wrong."" Read the rest of SpaceAdmiral's review. The Trouble with Physics author Lee Smolin pages 392pp publisher Houghton Mifflin Company rating 9 reviewer Fane Henderson ISBN 0618551050 summary The Rise of String Theory, the Fall of a Science, and What Comes Next

The Trouble with Physics is very unlike most pop-physics books not only in its criticism of string theory, but in its open adulation of Einstein and skepticism of the Copenhagen interpretation of quantum theory. Having said that, it does provide a very decent summary of 20th century physics (including string theory) for laypeople, not unlike more traditional pop-physics books (e.g. by Hawking and Greene).

The book's main criticisms of string theory are that it makes no testable predictions and that some things string theorists take for granted haven't been rigorously proven mathematically. Smolin is highly skeptical of many string theorists' reliance on the Anthropomorphic Principle.

The book becomes most interesting somewhere in the middle where he discuses truly controversial approaches to physics. This includes things like MOND, which, interestingly enough, Smolin is skeptical of.

In case you've forgotten your high-school physics, I'm going to use this paragraph to refresh your memory of special relativity to prepare you for the next couple paragraphs. The basic idea of special relativity is that the speed of light is constant. Pretend that I am shining a light at you while (A) standing still relative to you; (B) moving towards you at half the speed of light, and; (C) moving away from you at half the speed of light. In all three scenarios, I will accurately measure the light moving away from me at 3,000,000 km/s and you will accurately measure the light moving toward you at 3,000,000 km/s. To ensure this result, distances and times will have to be different for me than they are for you, except in case (A).

Now I'll quickly remind you of the Planck length: This is a theoretical limit on how small something can be. According to Smolin, all versions of quantum gravity seem to suggest the Planck length as a limit. But would observers moving relative to each other disagree about the Planck length?

I used to be a big fan of MOND (in a layperson sense) until Smolin introduced me to DSR (doubly special relativity) and DSR II. The basic idea is that it may be possible to modify the theories of relativity such that observers agree not only on a constant speed of light, but also on a constant Planck length. It's not unreasonable to guess that a modification of this sort could solve some of the same problems MOND does (e.g. explain astronomical observations without resorting to dark matter and dark energy). Furthermore, since DSR in its current incarnation predicts that more energetic photons are slightly faster than less energetic photons (only the speed of the least energetic photons is constant in DSR), it could also explain away, for example, inflation in the Big Bang model. (Immediately after the Big Bang, everything was hotter and more energetic, so the average speed of light would have been faster than it is now if DSR is correct.) Although I'm not qualified to judge the actual mathematics of such a theory, I find it very appealing for reasons of consilience.

I was slightly disappointed with the final chapters of Smolin's book since, despite an obvious effort to the contrary, it struck me as awfully bitter and reeked of sour grapes. Leaving physics in favor of sociology, he lambasted the current tenure and peer review systems (particularly in the United States) as favoring Master Craftspeople (like those scientists who developed the standard model of particle physics) over Seers (like Einstein, Bohr, and de Broglie) who look at the deep questions of physics that border on the philosophical rather than the latest technical problem. A few interesting things do emerge in these chapters. One such thing is that Smolin seems to have a soft spot for Paul Feyerabend as a philosopher of science (despite describing himself as a proud Popperazzo in an endnote). Another is that Smolin thinks a scientist who is hated by half his senior colleagues and loved by the other half is likely better than a scientist who is liked by all his senior colleagues. I strongly recommend this book.

You can purchase The Trouble with Physics from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

pankaj_kumar writes "A number of AJAX libraries and frameworks have emerged to purportedly simplify development of rich Internet Apps. None of them however can substitute a good understanding of what the recurring problems are, the potential solutions and what goes on behind the sleek facade of a browser to power these Apps . Michael Mahemoff, author of Ajax Design Patterns, said this best in his blog which became a popular wiki entry and later, this book." Read the rest of Pankaj's review. Ajax Design Patterns author Michael Mahemoff pages 635 publisher O'Reilly rating 9 reviewer Pankaj Kumar ISBN 0-596-10180-5 summary Creating Web 2.0 Sites with Programming and Usability Patterns

The Ajax Design Patterns book, with its more than 70 design patterns, documented in more than 600 pages with encyclopedic detail, is very effective in presenting the AJAX programming knowledge in a reader friendly format. In the spirit of seminal GoF Design Patterns work, it captures the essence of each of the topics with problem solving approach — first stating the problem in general terms and then presenting the solution, outlining the approach and discussing variations, alternatives, trade-offs and even listing actual uses in real applications. Btw, if you noticed I used the term topics in the previous sentence to refer to its 70+ "knowledge modules" and not patterns, mostly because I wouldn't categorize all of them as patterns. However, this disagreement on terminology doesn't take away anything from their practical usefulness and, for sake of consistency, I would continue calling them "design patterns".

A bit on scope and level of material presented in the book — most of the material is quite advanced and assumes good knowledge of technologies for writing web based applications: HTTP, JavaScript, (X)HTML, CSS, PHP and a bit of W3C DOM. The code fragments, and there are quite a few of those, are in JavaScript (for client side) and PHP (for server side). Most of the prominent AJAX libraries, toolkits and frameworks are also mentioned, often while discussing a particular pattern as a reference of actual use. The appendix lists them all at one place and highlights their main features. Though, the book carefully avoids to recommend any one as 'The AJAX toolkit'.

The book categorises the design patterns as Foundational Technology Patterns (those related to repainting the user interface, browser and web server communication, and event handling), Programming Patterns (those related to programming aspects of either end, browser or the service, of the application), Functionality and Usability Patterns (those related to functional widgets such as slider, data grid, progress indicator etc., page layout, visual effects and so on) and Development Patterns (those related to debugging and testing). Of course, the real value is in the details of each pattern, and not just the high level categorization or overview.

A reader of this review may be interested in knowing why should he or she buy the book when most of the content is freely available at the Ajax Patterns Wiki. Here is my take on this: although most of the content is available on the Wiki, the text in the book has gone through professional editing and is more readable. Also, the description of most of the patterns run into multiple pages, and it becomes hard to read long articles while connected to the Internet (I tend to click on links and wander away). As an additional bonus, the book includes illustrative diagrams, which I found quite helpful, and at times, funny. Most of the patterns included in the book taught me something new, I did end up with a list of favourites after finishing the book in less than a week: XMLHttpRequest Call: One of the most comprehensive treatment of XMLHttpRequest object and its various use patterns, limitations and alternatives. On-Demand JavaScript: How to do lazy loading of JavaScript code to improve responsiveness or get data from a different server. HTTP Streaming: How can a server keep sending data to the browser over an HTTP connection initially established by the browser. Call Tracking, Submission Throttling: How to protect your server from excessive load by very active users without compromising responsiveness. Browser-Side Cache: Ajax doesn't solve the inherent latency problem of the Internet. You still need the good old tricks to improve the user experience. Malleable Content: How to let the user edit some information on a mostly read-only page. One-Second Spotlight, One-Second Mutation: How to communicate change in a portion of the page without being obtrusive. Direct Login: How can you improve the user experience as well as the security of authenticating user using Ajax and JavaScript wizardry. Unique URLs: Going Ajax should not require your users to abandon joys of hyperlinking and the old and tried habits of navigating content by clicking on the familiar back and forward buttons.

So far I have only been talking about things that I liked but there are some things I would consider weak spots. I noticed a few minor typographical issues with certain code fragments, but they are rarely serious. For example the first code fragment on page 96 has uses variable requestTimer to store the return value of setTimeout() and then uses variable requestTimeout as argument to clearTimeout().

A good addition for a future edition could be patterns on AJAX program performance during development, deployment and runtime such as JavaScript compression to improve download times and execution speed and considerations on using multiple third party JavaScript libraries.

Another thing I found a bit annoying at times is presence of a lot of URLs all over the text with hints too brief to allow uninterrupted reading away from the computer. I would have preferred numbered footnotes, either in each page or at the end of each pattern, with URLs and a brief summary of its contents. Usually I read printed books when away from the computer and do not wish to go to the computer and type-in the URLs to just understand what is being said in the text. Although immensely helpful during online viewing, the embedded URLs are a hinderance during offline reading. This is one area where the structure of printed content should be different from the online content.

Overall, I would recommend the Ajax Design Patterns to all those who work or aspire to work on web development projects as an excellent reading and reference resource.

You can purchase Ajax Design Patterns from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Scott Walters writes "Many of the recipes in SQL Hacks will improve the SQL you write day to day, and many will give you the confidence to attempt much more involved tasks with SQL. Other recipes will rarely if ever be needed, but make for a entertaining and education reading in a similar way that "worse case survival scenario" books do — SQL is pitted against the most difficult analysis tasks just as survival scenario books pit humans against pavement and lions. SQL Hacks fits well in the Hacks series, which raises the bar on advanced books by offering large, eclectic sets of tricks for problems that an unambitious person (a non-hacker) wouldn't ever push technology hard enough to run into. Put another way, the questions answered in a good Hacks book are ones that would get a "good question" comment rather than a an "RTFM!" response. It does a good job continuing where O'Reilly's SQL Cookbook left off, which is always difficult with two books written at slightly different times by different authors. Still, it's harder to review a Hacks book than a Learning book as, with hacks, the sky is the limit, and the reader will always find herself wishing for more. To this end, I hope O'Reilly continues to publish newer editions of their various Hacks books, drawing in more and more content in each edition, and identifying recipes that might better serve in the Cookbook counterpart." Read the rest of Scott's review. SQL Hacks author Andrew Cumming & Gordon Russell pages 386 publisher O'Reilly & Associates rating 7 reviewer Scott Walters ISBN 0-596-52799-3 summary Tips & Tools for Digging into Your Data

SQL Hacks skips most of the tutelage and shows you very specific ways for doing specific chores, with more explanation of how to adapt it than theory behind it. Most hacks have database specific information for the five databases the book tackles, and many hacks are inherently different on each system, making them completely different solutions to the same problem. Those five databases are Microsoft Access, Microsoft SQL Server, MySQL, Oracle, and PostgresSQL; most of the ideas require work to adapt or are completely specific to the database system, so I wouldn't suggest straying from this supported set. The authors did their homework, and SQL Hack's strengths are the depth, detail, and level of knowledge with which each database system is covered, and the book's willingness to get down and gritty. There's never an impression that juicy details were omitted because the authors didn't want to expend the effort to pick a colleague's brain or hunt down a factoid that never got documented elsewhere. Learning how to create indices on functions with multiple arguments in Postgres was worth more than the "hack" it was a footnote in. This dedication carriers over to screen shots showing how something is done in Microsoft Access directly opposite Unix shell pipelines between grep, perl, and the SQL command shell. Most books, including mine, are a bit awkward or vague on either Unix or Microsoft Windows, but the author's and contributor's experience on this one expertly covered platforms specific database topics. Besides just database systems and platforms, the authors challenged themselves to show how to securely and efficiently use the database interfaces of a set of languages: C#, Java, Perl, Python, and PHP. The polish shows, and you'll have absolute confidence that all of the tricks really are at your fingertips, regardless of your choice of operating system, database system, or programming language.

It gets bonus points for mentioning non-obvious types of input, such as cookies, that must be sanitized or sent through bound parameters, in its discussion of SQL injections. In the security department, it looks at SQL injections from three points of view: early on in the book, correct code is shown; later, SQL injections are shown from the point of view of the attacker, with several pages of strategies and scenarios for formulating attacks; and then from the point of view of the defender, who has to defang and avoid these scenarios — extra bonus points for this comprehensive treatment.

If you're looking for a quick buy/don't buy indication, then, by all means, buy it. That is, assuming that it's not intended to be your first or only SQL book. By it's own indication, it won't teach you the basics of database normalization, installation, and so forth. I would buy it as a second SQL book, though, after the fantastic 'The Practical SQL Handbook', as it's written to a much higher standard than most books, and gets things right, such as security, the intricacies of using a database to handle accounts, and transactions and shopping carts. The cover text promises lots of advanced hackery, but that's vague. "Pushing the limits of SQL"... "Solve puzzles using SQL"... "Manage users and audit the changes they make to the database".

Here are the major sections: SQL Fundamental; Joins, Unions, and Views; Text Handling; Date Handling; Number Crunching; Online Applications; Organizing Data; Storing Small Amounts of Data; Locking and Performance; Reporting; Users and Administration; and Wider Access.

Wider Access requires some explanation. It deals with locking down the various database systems to securely providing guest accounts, or, more generally, to limit damage in the case of an SQL injection attack or similar compromise.

With some well designed tables, SQL Hacks will show you quite a few tricks, some of them quote involved, quite non-obvious, and quite clever, to extract meaning from the data. You'll probably learn quite a few new types of reports you can do — intersecting ranges from different sets of data, outputting SVG pie charts, swapping rows and columns, finding medians, computing running totals, and computing running functions such as compound interest struck me as the most useful and got mental bookmarks.

I have two metrics for this book. The first metric is whether I'd buy it if I came across it in a book store, and that's a function of whether I'd have exhausted what it had to offer after an hour or so of furious skimming and intentionally picking out the best parts from the table of contents. Very few books make this cut for me.

The other metric is whether the authors did at least what I imagine I would have done were I writing it. This test is also a difficult one but builds in a great deal of forgiveness as my ideas are quite likely dumb ones.

I totally dig the cut-and-paste ASCII query results. The authors could have easily marked all of those up in DocBook and made it prettier but also alien compared to what you'll see at the computer. They're not ashamed of the SQL command shell, and they're not ashamed of SQL.

Many hacks have several examples, covering the problem with different constraints and end goals in mind.

Multi-platform, and thoroughly so. One moment, it's showing how to use XSLT tools from the command line on Microsoft Windows, and on the next page, there's a Unix shell pipeline with wget, xsltproc, and grep. Perl one-liners abound, and there are screen shots from Windows applications with instructions for navigating the menus and setting the needed options. You won't feel shortchanged for running the "wrong" platform.

When a powerful, modern SQL extension, such as replace, gets ratified by the standards committees, the authors let you know. Sidebars are spread around sharing the good news that sometime you might not have heard of before is portable. At the same time, some features are just fluff, and you're warned off of operations intentionally left out of the SQL92 standard.

Sometimes database systems have non-portable local extensions, such as MySQL's full-text indexing and SQLServer's XML handling features, and lots of these get motioned too, usually as variations on examples demonstrating the feature as a short-cut or simplification.

The treatment of security is first rate. The polish is top notch. Writing a book is a huge undertaking, and the economics of book publishing gives publishers little margin for advances. A book that reads like it's third release but is actually in its first can only be the product of an exceptional level of dedication by the authors.

Rarely, the authors do get tutorial-ish, but only a little, and I think it works: "Choose the right join style for your relationship" deals the difference between inner and outer joins, and whether records should be partially populated with nulls or omitted entirely when relations between tables can't be made for a record. Another section shows how to convert between subqueries and outer joins, and talks about when it's possible, and this serves as a sort of lesson in demonstrating the equivalencies between the two.

The "Hacks" format is similar to the "Cookbook" format. Both offer small, randomly-accessible (flip to it when you need it) examples of how to accomplish various tasks. In the traditional, MIT circles, a hack is piece of work that's either brilliant in its simple elegance or else brilliant in its expediency and simple effectiveness, and as such, is worthy of some esteem. It's also work that's custom for a particular scenario and has limited domain — in other words, it's a highly specialized fix or improvement. If a stock fix is applied systematically, that's mechanical, not clever. By this definition, showing users how to invoke their SQL monitor, or showing users how to decide whether to use an outer or inner join, are not hacks. Few of the recipes triggered this peeve, and they were early in the book, but including those few muddles the question of who the audience is, and lowers the standard for the Hacks series, endangering its basic premise. 'SQL Hacks' isn't alone in this sin; most of the Hacks books do it to some degree.

It was written by two professors at Napier University in Edinburgh, Scotland. The style, grammar, and presentation are perfectly fine — but only that. It's not a bone dry college text book, but it was written with a dedication to professionalism that can make a technical book tedious and will certainly keep it from becoming a classic. The literary power of Brooks, Hoare, or Wall is conspicuously absent.

Authors of Hacks books are at liberty to tap the experiences of the best and brightest of the field, and the best and brightest often have tricks just too strange, clever, or specialized to fit into any ordinary sort of text. I'd like to imagine that if I were charged with writing one of these, I'd have hundreds of contributors (I'm not likable, but I am persistent). Nothing against the contributors (two of them more than 20 years experience each), but why stop at three?

I said I had two benchmarks: whether I'd be likely to walk out of a bookstore with it if I had an hour alone with it to try to get my fill, and whether it touched on the subject that I thought it should.

Before cracking the cover, I stopped to ponder what would really impress me, and what I'd like to see. The Internal Functional Programming Competition had a puzzle solved by the contest winner using SQL. I'd like to see similar combinatronics and optimization problems solved using SQL. I'd like to see a good implementations of semi-infinite-strings, the text indexing data structure and algorithm that Google uses. I've done a version of this, but my implementation leaves something wanting. When reforming badly non-normalized databases, I've had to build a normalized database in parallel and populate it from queries on the non-normalized one. It would be interesting to hear how other people approach that problem, and what I can learn from them. There are other jobs that I've tackled and managed despite never having been prepared for. Renumber a display_order priority on records in response to the user adjusting or reassigning priorities. Trees using self-joining tables is something more people should be exposed to, especially when presented with non-normalized data.

There was no semi-infinite-string implementation, but the book showed how to build full-text indexes the optimal way for each database, using built-in full-text indices and optional add-on modules offering full-text indexing. The renumbering example took the more general form of running-totals computations. There were a few examples of self-joining data, and one tree example visualized the structure. Normalizing data had tricks, including some with views, and it showed how to use Cartesian joins to do combinatronics problems. So, aside form one sort-of, the authors nailed my entire wish list. That's amazing — I've never had that happen before, actually.

The highest endorsement a book can earn from me (a cheapskate, who already has a good deal of knowledge from working the industry for ten years) is getting bought on a random trip to the bookstore where I hadn't been looking for or intending to buy anything, and paying full price on top of that. Books that are surprising, riveting, and so packed with information that I couldn't possibly copy all of the best parts down and exhaust it in an hour or two are the ones that get purchased in this manner. I have 'SQL Hacks' in my hot little hands here at home, so this benchmark is now synthetic, but... I'm somewhat undecided, and not sure whether I would or wouldn't walk out with it. More likely, I'd just put it on my wishlist and pick it up later, for a discount (I'm a cheapskate, remember). If you don't know how to do more than half of the things listed in the table of contents, most certainly buy it. If you find yourself frequently working with SQL and constantly face new problems, buy it. If you find yourself still learning SQL and wanting a variety of examples, buy it. If you're shopping for a handful of good SQL books, buy it.

On a scale of stuff laying around the house, I give it 7 gold stars, half a box of binder clips, some AA batteries, and a bottle of really good soy sauce.

You can purchase SQL Hacks from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

peterwayner writes "If you're jazzed by the communitarian impulses driving Wikis, idea agora, Web 2.0 and other collaborative happenings, you'll be pleased to know that the new book Wikinomics is a great gift for that boss, spouse, or friend who doesn't quite grok it yet. The only logic bomb hidden in this statement is that much of what is wonderful in this book is wonderful because it's a book printed on pulp and written by two and only two authors. That is, the book is good because it's not a wiki." Read the rest of Peter's review. Wikinomics: How Mass Collaboration Changes Everything author Don Tapscott, Anthony D. Williams pages 320 publisher Penguin Group rating 8 reviewer Peter Wayner ISBN 1591841380 summary The pros and cons of wikis and their place in business

This statement isn't exactly true. The authors, Don Tapscott and Anthony Williams, have a wiki site at www.wikinomics.com devoted to the book. You can edit the wiki and have your say, but that's not what they're asking folks to buy. For the price of the book, you get a well-designed collection of thoughtful anecdotes stitched together by two talented business writers and polished by a good editor. They've made a good attempt to cover most aspects of the topic and they do an excellent job of explaining why the ideas are important for CEOs that are struggling to move their business forward. All of this is almost as portable as an iPod , dramatically less expensive and guaranteed never to need new batteries.

The tone of the book is bright and optimistic about how openness and wiki principles will help companies. We hear about how the wikipedia covered the London subway explosions, the way that Innocentive is opening up the R&D process for companies and the surprising inventiveness of Google maps users. The descriptions are thorough and well-researched, as far as they go, and when they're done going, the writers summarize them well. It's clear that the writers feel that the word "wikis" should be the new one word answer that CEOs should trot out when faced with the kind an impossible question, the kind of question that they the answered with "Internet" during the 1990s and "China" after the turn of the millenium.

The great advantages of the pulp-bound book become clear as you work your way through the text. In one section, for instance, Tapscott and Williams dismiss Jaron Lanier's worry that wikis can devolve when a smart mob develops the the same kind of "mass stupidity" that brought us Pol Pot or the Stalinist movement. "The winners will outnumber the losers", say the authors and conclude that Lanier "ran afoul". I don't really agree with the easy way that they dismissed the danger and if I had a wiki edit button in front of me, I would change the text to amplify Lanier's warnings. I've watched the mob rule delete perfectly good information from the wikipedia for no other reason than it wasn't "notable". The revision wars are legendary and any savvy wiki reader knows that skirmishes are more common than we would like. The well-meaning editors at the Wikipedia have probably destroyed more knowledge in the name of notability than the book burners of history. At least it's still there in the article history. But since Tapscott and Williams wrote a book that doesn't come with a wiki edit button, the text is better off because I didn't glue in my own divergent rant.

The optimism of the book is contagious and it would be a shame for it to be limited by a neutral point of view. Wikis organize casual information like how to install software, and this is the kind of job that is very important to business. Wikis may just be the wrong tool for, say, capturing political truthiness, but the book gives several good examples of how they energize corporations by making it easier for divisions, groups, and project teams to cooperate without going through traditional channels. If a business wants to formalize its collective intelligence, a wiki offers an ideal amount of flexibility.

If the book needs any editing, it would be to add more skepticism. At the beginning, they hint that they will address the kind of concerns that led Bill Gates to wonder about how society will pay for innovation if there's no profit incentive, but analyzing the limitations of the wikiworld isn't really their goal. There's little discussion of endeavors that have largely failed like Wikinews. That experiment with collaborative reporting had two articles on the day I wrote this and one article on the day before. (December 19 and 20th).

I've begun to feel lately that there is a real danger that free information will drive out paid information in much the same way that economists note that cheap money drives out the dear.

It's probably too early for us to have a firm grasp on the downsides to the wiki world and so it might be unfair to expect the book to be much of a buzz kill. One of the biggest logical problems I've found with the wikipedia is the inconsistent way that the movement treats traditional scholarship. On one hand, we're supposed to revel in the way that the wikipedia is often better than traditional mechanisms, but on the other hand the wikipedia gives more weight to outside sources. On the day I wrote this, the guide counseled, "Avoid weasel words such as, `Some people say ...' Instead, make your writing verifiable: find a specific person or group who holds that opinion and give a citation to a reputable publication in which they express that opinion." If the wikis become good enough to rival if not replace original sources, where will the wikis find the outside beacons of authority? Any strict logician will realize that there's a danger of proving 1=0 with this system, although I realize that all grown ups know that life is filled with logical inconsistencies like that.

The book, for instance, doesn't really question why the Wikipedia worked but the Wikinews didn't, something that no one may really know. The tone is closer to Ray Kinsella than Crash Davis. It celebrates Cory Doctorow, the famous editor of BoingBoing.net, a wonderful blog that I read daily. The authors explain how Doctorow gives away digital copies of his books because "his problem isn't piracy, it's obscurity."

Perhaps that's true, but a deeper question is how the wikis, mashups, and mixes will find their benchmarks of authority, their geodetic markers in memespace, their means of support. To test this danger, I wrote this greasemonkey script to count the words in a webpage between certain tags. On the day I wrote this, the admittedly imprecise script found 11788 words on the front page of Boing Boing, of which 6472 were between <blockquote> tags. That's about 50% borrowed text.

So far, this non-stop homage, this pantheon of fair use sells ads and seems to do quite well — Wikinomics suggests that BoingBoing's "readership now eclipses most mainstream media outlets." So why bother playing by the old school rules when you can just let others do the work while you push the boundaries of fair use and make money? There is a real danger that the original sources will find themselves starved for air as the Wikipedia and others fair use devotees suck up the top search rankings.

This may be why I think the book was right to bring these wiki worlds to the business community. At first I thought it was rather cynical to package up the wiki ideals into a neat bundle for the business leaders, but now I think that businesses are the ones who can really use and support the ideals. We now know that wikis can't be trusted for important, contentious areas of truthiness like politics, news, history, or any place where there's a difference of opinion about the facts, but it can still be ideal for semi-closed environments with outside means of support. I can imagine that wikis would be great for a corporation that needed to manage communication between the two divisions in different states. Openness gets rid of the natural inertia of bureaucracies. And it's clear that every company should have a wiki devoted to the user's guide so the customers can add what the manual writers never anticipated. Wikis allows one group to move ahead without asking another "mother may I". The umbrella business can pay the bills for keeping the lights on.

My guess is the folks in business who need to get things done may be the only ones who support the wikiconomy in the long term after the average joe gets a bit bored and tosses the wikis onto the pile of amusing distractions with the CB radios. The businesses are the ones with the real incentives to embrace the values of wikiness. And if you've spent a few years in the cubicle trenches, you know that words like "truthiness" have a certain ring to them.

Peter Wayner is the author of Translucent Databases and 12 other books.

You can purchase Wikinomics: How Mass Collaboration Changes Everything from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Tony Parisi writes "Remi Arnaud and Mark C. Barnes' Collada: Sailing the Gulf of 3D Digital Content Creation is a great first book on a new technology for entertainment applications. Collada is a file format for the exchange of 3D game and interactive content, developed by a consortium of companies including Sony and leading digital content creation software vendors. Collada acts as an intermediate format between DCC tools and end applications — thereby promising to solve ages-old productivity issues in the 3D content pipeline. The authors have done a thorough job explaining this problem, and how Collada solves it, in an introductory book that is well suited for a technical audience building advanced 3D tools and applications." Read the rest of Tony's review. Collada: Sailing the Gulf of 3D Digital Content Creation author Remi Arnaud, Mark C. Barnes pages 240 publisher A K Peters rating 9 reviewer Tony Parisi ISBN 1568812876 summary Describes Collada, a new format standard for 3D graphics content

When I first heard about Collada in 2004, I was skeptical. I am no stranger to 3D file formats: I co-created VRML in 1994 and continue to push that rock up the hill with X3D, an XML-encoded 3D format for the web. After a decade of getting arrows in my back blazing this trail, it felt like the last thing the world needed was Yet Another 3D File Format. Developers in the game world, and to a lesser extent, the DCC tools world, had largely turned their backs on standards of any kind — the proverbial tough crowd. However, the laser-focus of the Collada design team seems to have paid off: the industry now has a common exchange format for game assets, and there is hope yet for developers who would rather spend their time building games than building tools to make games. This clarity of focus on the design comes through in the book as well. Arnaud and Barnes, principal designers of the Collada standard, have written a detailed and lucid book that explains Collada from concept through implementation.

Any first book on a new technology has the unenviable task of explaining the *why* of it, as well as the what and the how. The big risk there lies in devoting too much of the book's content to the background and overview materials before getting to the meat. The book excels in this regard, by clearly laying out a compelling case for an intermediate format, but quickly, so that experienced engineers and managers can get the point, and then move on to the useful information that comprises the bulk of the material. I suspect that Collada will serve as the seminal text on the subject for some time to come, and therefore the overview material is essential. However, if this had only been a survey or introductory book it would have missed the mark with its target audience — some of the busiest and results-oriented developers on the planet, people for whom what-is-it and how-do-I are where the rubber hits the road.

Most of Collada is devoted to explaining the format's core concepts: geometry, scenes, animations, and physics. These are the building blocks of all interactive graphics content. The book walks through these in a straightforward progression; I found it very easy to follow. After covering the basics, it combines them into useful end-to-end examples that give prospective implementers a sense of what it would take to build Collada tools. It worked for me anyway: we will be building Collada support into our products based what I learned in here.

Midway through, the book goes into a bit of a jag on the subject of effects. In its simplest form, the concept of effects simply refers to an object's basic visual appearance: color, textures, shading etc. Unfortunately, in modern graphics, nothing is ever that simple. What begins as a discussion about those basic concepts quickly cascades into a deep-dive on programmable shaders, effects-packaging techniques, multi-pass rendering, and profiles — the latter presenting a glimpse into the sausage-making stuff of standards and hardware consortia, things mere mortals were not meant to know. This is not really the fault of the chapter's author (contributor Daniel Horowitz from NVIDIA), but more a side-effect of the intensity of the subject matter. I am wondering if this all could have been handled better in a separate book or an appendix. The saving grace here is that it's at this exact point in the current printing of the book that we get the color plates — 8 gorgeous images courtesy of the biggest names in graphics: Epic, NVIDIA, Alias and the like. But that's the beauty of 3d graphics: when the math gets hard... go to demo!

Collada gets back on track with 2 excellent chapters on animation and physics — again, at just the right level for a seasoned 3D toolmaker like me. The final chapter explores the Collada content pipeline: how different Collada-aware tools can be mixed and organized to create the final content from all the original assets. Here the orientation of the book moves from a focus on specific features to a system view of how to assemble disparate software tools into working production solutions. Managers and decision makers reading the book will benefit most from this chapter, which I found to be not only thoughtful but provocative, as it touches on the issues at the heart of Collada's mission: how to make robust, open, cost-effective systems for creating rich content that lasts the test of time. The book also contains a handful of informative appendices on Collada plug-ins for the major DCC tools such as 3ds Max and Maya. The plug-in appendices cover build steps, supported features, practical use scenarios, and known bugs and issues.

Other than that effects digression, my only critique — a minor one — is that it is a bit heavy on the XML. From the second chapter, the book dives into details of XML syntax, document types, schema and such, and never looks back. I understand where the authors are coming from: rather than invent a pseudo-code to illustrate the concepts (which then would have to be translated into XML for the working examples anyway), it's more economical to just get the reader up the ramp with XML and get on with it. I am willing to believe that graphics-savvy readers who are not conversant in XML — and I am betting there are still many, many such 3D geeks out there — will be able to get over this quickly. You should: XML is *the* way to store and transmit data, period, full stop. Just in case you are naïve about XML, the authors have actually put in a short primer on it in the second chapter. It's good, and it should be enough to get you through.

I highly recommend this book. If you are a programmer with a reasonable understanding of 3D graphics programming and/or authoring using 3D scene graphs, you will be able to learn the basics of Collada. If you are an experienced 3D toolmaker, Collada contains everything you need to get up and running to build your game, game engine or content pipeline tool. If you are a manager or decision maker, you get the added comfort of knowing that — finally — you just might be able to write that tool once and not over and over again.

Tony Parisi is a software architect and entrepreneur who loves to solve hard problems. Tony's company, Media Machines, is building an open source, open standards-based platform for delivering 3D virtual worlds on the web. Tony is the co-creator of VRML, the original standard for 3D on the web, and is a principal developer of X3D, the XML-based successor to VRML for building web-based 3D virtual worlds.

You can purchase Collada: Sailing the Gulf of 3D Digital Content Creation from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Simon P. Chappell writes "It's good to learn a programming language, but it's a far better thing to learn to write programs in that language. What the world needs are less programming language books and more books on programming with the language of your choice. Enter Developing Java Software, 3rd edition by Russel Winder and Graham Roberts. Dr. Winder is the primary author and I became aware of this book when he mentioned it on the Groovy mailing list. Knowing him to be an intelligent and helpful member of the Groovy development team, I rushed to suggest that I could review it for him." Read the rest of Simon's review. Developing Java Software (3rd edition) author Winder and Roberts pages 885 (19 page index) publisher Wiley rating 7/10 reviewer Simon P. Chappell ISBN 0470090251 summary A good book for learning to write programs with Java.

Developing Java Software is a text book, and is targeted towards university undergraduates, most likely in some form of computer science curriculum. It is also completely suitable for self-learners who want to teach themselves how to write software in Java. The book has been used by the authors when teaching undergraduate classes at University College London, so it has been fully tested in the academic environment.

There are five parts, with twenty four chapters between the first four parts and ten appendixes in the fifth. Each of the chapters are short, most are less than 40 pages, tightly focused and fairly self-contained.

The first part, the longest of them all, starts out with the introduction chapter that no book is complete without. Really, how many people who want to learn Java don't know that it used to be called Oak and was originally designed for set-top boxes? Anyway, after that little excursion, the book moves onto useful stuff like "Programming Fundamentals", introducing concepts like statements, variables and expressions. Next is "Adding Structure" where we discover methods and control structures. Chapter four is "Introducing Containers" and does a good job of covering arrays and the whole slew of container data structure classes in the standard library. Chapter five is a little time off for good behaviour, where we get to spend some time "Drawing Pictures" before heading into chapter six for "Classes and Objects". Chapter seven explains "Class Relationships" while chapter eight introduces us to "Exceptions". Chapter nine is "Introducing Concurrency with Threads". We finish up with chapter ten covering "User Interfaces".

Part two addresses the "Process of Programming" and this is where it really differentiates itself from the rest of the Java book crowd. Chapter eleven gives an overview of "The Programming Process". Chapter twelve begins the process of making that real by addressing "Unit Testing". Chapter thirteen continues the story with "Test-driven Programming Strategies". More practical advice comes in chapter fourteen as they introduce the reader to "Programming Tools".

Part three brings two "Case Studies in Developing Programs". Chapter fifteen introduces the case studies. The first study, "Contacts Book" is in chapter sixteen and the second, a "Pedestrian Crossing Simulation" is in chapter seventeen.

Part four is "The Java Programming Language in Detail". This is the more reference portion of the book and it's seven chapters cover variables, types and expressions, flow-control, classes and packages, inheritance and interfaces, exception handling, threads and concurrency.

Part five is the "Endmatter" and holds ten appendixes.

The first thing to like with this book is that it has an engaging style. The style comes not just from the body text, but also from the notes, tips and references in the margins of the book. As someone who learned Java almost ten years ago, I have difficulty plowing through yet more body text explaining the same old stuff that every other Java book covers; yet, jaded and cynical as I am, I enjoyed the sparks of honesty and humour in the text.

As I alluded to in my opening remarks, this book takes the approach of trying to not only teach Java, but how to approach and actually write programs using Java. The book takes an iterative approach and emphasizes the use of testing tools. Interestingly, they use TestNG rather than the de facto standard JUnit. This is the first book that I've seen that uses TestNG; perhaps JUnit is finally getting some competition?

The book is completely targeted at Java 5. All of the code examples use the new features where appropriate. This makes the book worth considering for those that already know Java but want to finally climb onboard with the latest version.

Naturally, there is a website available at www.devjavasoft.org where all of the source code for the programs in the book may be downloaded, together with answers to the exercises and any updates or revisions of the material in the book.

One of the challenges of writing or updating a book of this size is that it's possible (nay, almost guaranteed) to miss important things. The tip at the top of page 190 is a classic example, where the reader is advised that calling System.gc() will force the Java Virtual Machine (JVM) to perform a garbage collection. This is not, and has never been, true. The most that the System.gc() call will do is let the JVM know that now would be a good time for it to garbage collect, but there are no guarantees that any collection will actually take place. With this being the third edition of the book, I expected errors of this sort to have been caught by now.

Another point to consider is that with this being a textbook the writing style is less like a mass-market book and it also includes questions and exercises at the end of each chapter. I normally avoid books of this sort, although this does seem to be one of the better ones.

I hate being picky about typography, especially with the average level being quite good these days, but this book is set in a smallish font for the amount of text on each page. It is a serif font, but I didn't find it the most comfortable to read. Also, and this is the most egregious fault in the whole book, the program listings are set in a proportional font! I could hardly believe it when I saw it. While I realize that the authors are unlikely to be responsible for the final font selections, I fear that it damages an otherwise strong book and does them a disservice.

This is a good book for learning Java. More importantly, it's a good book for learning to write programs with Java.

You can purchase Developing Java Software 3rd edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

James Edward Gray II writes "If you have been swept up by the Rails craze or are even just a casual fan, you have probably been waiting for the terrific books to start rolling in. Some early entries, like Agile Web Development with Rails, were very solid but for me greatness arrived with Rails Recipes. For those who are not familiar with it, Rails is a full-stack web application framework, for quickly developing state-of-the-art web applications. Rails Recipes is the latest book on the subject from the Pragmatic Programmers." Read the rest of James's review. Rails Recipes author Recipes pages 299 publisher The Pragmatic Programmers rating Excellent reviewer James Edward Gray II ISBN 0-9776166-0-6 summary A programming cookbook for all things Rails.

Let me tell you how I discovered Rails Recipes. At the Rails shop I work for, we needed a favorites system for our latest application. When I inherited the task of implementing favorites, I had heard just enough to guess that the new polymorphic associations feature of Rails might be just what I needed. Sadly, I had never even seen an example of their usage. Before leaving work that day, I checked the table of contents to make sure a recipe for what I needed was in there and and bought a combo pack, so the PDF would be waiting for me in the morning. The next day I built the entire favorites system and integrated it into our application with only the book as my guide. Total time for implementation, from cracking the book to a complete solution: just over three hours.

Needless to say, the book had completely won me over by that point. I started sneaking in recipe reads whenever I had a free moment or two and had literally devoured the book in no time. I completely expected it to show me cute AJAX tricks and handle common issues like login code and it certainly does these things. It also covers popular plugins, including Acts as Taggable and Acts as Versioned, as it should. What I didn't expect was for the book to include so many excellent low-flash coding recommendations as well. There are terrific recipes for DRYing up your code in various circumstances, building your own output forms for views, how to use models in migrations even if the files are long gone, integration testing as a DSL, routing methods, code generation, and a whole lot more.

The book has some surprising depth to the Rails insights it provides, not because the recipes are long but more because the topics are well chosen. Even the small "Snack Recipes" generally dive right to the heart of a commonly encountered matter. You get typical solutions and often some tips on how to customize the relevant Rails behaviors. For example, the book covers how to add inflections Rails can use in its singular/plural text transformations and how to tie your own form building classes right into the standard Rails helper methods.

I'm a long time Ruby user and I consider myself fairly knowledgeable with regard to the language, but this book taught me new tricks. I've read the Pickaxe, but for some reason IRb sessions never sunk in for me until this book showed the perfect example of using the on an ActiveRecord model to create a Ruby syntax database shell. The book even taught me some great YAML tricks for use in fixtures and configuration files.

Now I realize I've been gushing a little, so let me to balance it with at least some words of caution. First, this book assumes you know Rails. You will not learn Rails here. This should not be the first Rails book you read, though it does make an ideal second read and daily reference. I should also note that the recipe sections seem pretty arbitrary to me. I expected to find the login discussion in the "Big-Picture Recipes" section and the console tips in "Database Recipes", but they are located elsewhere. This might be a minor challenge for those who try to thumb straight to a recipe, but I've found searching the PDF makes this a non-issue. (The paper version of the book does have nice tabs drawn on the edge of pages to lead you to recipe types though, unrelated to the sections.) Finally, I should note that I've gone hunting in the book for about four work projects now, and found all but one. It didn't cover Acts as Threaded usage. Obviously it is impossible for a single book to answer all your questions about Rails, but a 75% ratio seems like a great start to me!

There are 70 recipes in this book split among user interface, database, controller, testing, big-picture, and email categories. I must stress again though how well these recipes pack in the tips. Don't be at all surprised if you learn an applicable view layer or even pure Ruby trick in a database recipe.

If you are a Rails user, I must recommend you pick up this title immediately. I really believe there is something in here for all.

You can purchase Rails Recipes from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ravi writes "IPCop is a GPLed firewall solution targeted at Small Office/Home Office network. It is favored by many for its ease of configuration and setup and its support for a variety of features that you would expect to have in a modern firewall. IPCop is famed for letting users setup a sophisticated firewall for ones network without ever having to write an iptables rule themselves." Read the rest of Ravi's review. Configuring IPCOP Firewalls - Closing borders with Open Source author Barrie Dempster and James Eaton-Lee pages 230 publisher Packt Publishing rating 8.5 reviewer Ravi ISBN 1-904811-36-1 summary A practical book that takes a hands on approach in setting up and configuring IPCop firewall on ones network

Configuring IPCop Firewalls published by Packt Publishing is authored by two people Barrie Dempster and James Eaton-Lee and is divided into 11 chapters. The first chapter gives a brief introduction to firewalls and explains technical concepts such as OSI reference model, an introduction to TCP/IP and a brief outline of the parts that comprise a network. Even though I did not find anything new in this chapter, I realized that this is meant for people who are new to the world of computer networks and aims to bring them up to date with the various technologies associated with it. A network administrator intending to pick up skills in configuring and setting up IPCop, can circumvent this chapter and go to the second chapter which gives an introduction to IPCop and its different features. The authors have explained the concepts in an easily understood way with the aid of necessary screen-shots. One of the salient features of IPCop is its web based interface which allows one to configure all aspects of it from a remote location. In fact, IPCop is designed to be controlled from a remote location and serves all its configuration parameters via the Apache web server.

In the second chapter, one gets to know all the features of IPCOP including the different services it offer. One thing that struck me while going through this book was that the authors are fully immersed in explaining the configuration aspects of IPCop which is done entirely via the web interface. Other than the first, third, and 10th chapter, where the readers are made to digest some theory, the rest of the book is as a how-to. I found this to be ideally suited for people who are the least bothered about theory and just want to set up IPCop and get on with what they were doing.

In the third chapter, we are introduced to the unique feature used by IPCop to segregate the network depending upon its vulnerability. And in the succeeding chapter, the authors walk one through installing IPCop. Here each and every installation step is explained with the help of a screenshot which makes understanding the procedure much more intuitive.

The chapter titled "Basic IPCop Usage" gives a good introduction to the web interface provided by IPCop. Reading this chapter, I was able to get a good feel for the IPCop interface. More specifically, you learn how to configure IPCop to provide different services such as DHCP server, support for Dynamic DNS, editing the hosts file and so on. The IPCop interface is quite rich in functionality even providing options to reboot or shutdown the machine remotely. In this chapter, apart from the introduction to the web interface, the authors have also provided a few tips related to logging in to the remote machine running IPCop using SSH.

Put in simple terms, IPCop is a specialized Linux distribution which contain a collection of tools which revolve around providing robust firewall capabilities. The tools bundled with IPCop range from the ubiquitous iptables, services such as DNS, and DHCP, to tools which specialize in intrusion detection such as snort.

The sixth chapter titled "Intrusion Detection with IPCop" explains the concept of intrusion detection and how one can use snort IDS bundled with IPCop to effectively find out what is passing through our network and thus isolate any harmful packets.

The book moves on to explain how to use IPCop to set up a virtual private network (VPN). By way of an example, the authors explain how to setup a VPN between two remote networks with each end having a IPCop firewall in place. This chapter covers different VPN scenarios such as host to net, net to net connections as well as configuring IPCop to detect the Certifying Authority certificates.

The 8th chapter is a rather short one which explains how to effectively use proxying and caching solutions available in IPCop to manage the bandwidth.

One of the biggest advantages of IPCop is that it is possible to extend it to provide additional features by way of add-ons. Add-ons are generally developed by third parties and are usually developed with an aim to provide a feature that the developers of IPCop have missed. There are a whole lot of add-ons available for IPCop. The 9th chapter introduces the most popular add-ons available for IPCop such as SquidGuard — a content filtering add-on, LogSend — an add-on which send the IPCop logs to remote email accounts, AntiSpam, integrating ClamAV anti virus solution and more. The authors have also explained how to install and enable these add-ons using the IPCop web interface.

The tenth chapter titled "Testing, Auditing and Hardening IPCop" has more of a theoretical disposition where the authors list some of the common attributes towards security and patch management and also some of the security risks and a few common security and auditing tools and tests.

One thing I really like about this book is the practical approach taken by the authors in explaining how to accomplish a certain task. Each section is accompanied by the relevant screenshots of the web interface with a brief explanation of the options available. The book is well designed with a number of tips provided in each section highlighted in big square brackets which makes it quite eye catching. Even though I found the book a bit short on theory, it is an ideal resource which provides a hands on approach to people who are more interested in installing and setting up IPCop firewall solutions in ones network rather than pondering about the theoretical concepts of the same.

Ravi Kumar likes to share his thoughts on all things related to GNU/Linux, Open Source and Free Software through his blog on Linux.

You can purchase Configuring IPCOP Firewalls - Closing borders with Open Source from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Trent Lucier writes "If you've browsed the web design section of any bookstore lately, you've seen him staring at you. The blue hat. The mustache. The blinding neon background. He's Jeffrey Zeldman, publisher of the influential web development magazine, 'A List Apart' and author of the book Designing With Web Standards (DWWS). The first edition of the DWWS was published in 2003, and now 2006 brings us an updated 2nd edition. In a market flooded with XHTML, CSS, and web standards books, is DWWS 2nd Ed. still relevant?" Read the rest of Trent's review for the answer. Designing With Web Standards, 2nd Ed. author Jeffrey Zeldman pages 410 publisher New Riders rating 8.5 reviewer Trent Lucier ISBN 0321385551 summary Foundations for creating standards-based websites using XHTML and CSS.

DWWS is more of a survey course than a deep dive into a particular topic. In fact, a large part of the book is dedicated to the philosophy of web standards, as opposed to their specific implementation. The reader is given background information on the turbulent early years of the web, when Netscape and Microsoft battled each other with proprietary features, driving coders crazy and sending development costs through the roof. Inconsistent support for HTML, JavaScript and CSS often meant that a single page had to have multiple versions written to support different browsers. Predictably, many companies decided to "standardize" their websites on one browser (usually Internet Explorer), causing much pain for users who wanted or needed to use other programs.

Out of this mess came the web standards movement, whose goal was to encourage browser-agnostic design practices. However, the web standards proponents faced several problems at the outset. "Standards compliant design" was synonymous with "ugly." CSS was a 4-letter word, due to buggy and inconsistent browser support. Additionally, few people understood that standards compliance was a continuum and not an all-or-nothing affair.

Which brings us to Zeldman's book. Part 1 of DWWS explains the concepts above in terms that non-technical people can understand. The book states that it is for "designers, developers, owners, and managers..." Of course, the idea that a non-technical person would choose to read a book on web standards doesn't comply with what I like to call "reality." But tech leads may find some ammunition in these chapters for their arguments with management about the benefits of browser-neutral web design.

XHTML and CSS are the main focus of the second part of the book. Readers without any HTML experience will likely have difficulty following these chapters. Those with some experience will learn to master the DOCTYPE, tame font sizes, and conquer annoying Internet Explorer bugs.

Zeldman is a pragmatist, never forgetting that his readers live in the real world with real limitations. Some developers still have to support older browsers, or integrate with proprietary technologies (ex: Flash and Quicktime). He recommends solutions for these circumstances, letting his audience know the pros and cons of each approach. Early in the book, Zeldman states his motto of "No Rules. No Dogma." The book adheres to that statement, explaining that some standards can be maddeningly vague, or that the XHTML Strict DOCTYPE isn't for everyone.

As always, Internet Explorer 6 requires special attention. The (in)famous CSS box model hack is explained, in which jujitsu-like techniques are used to fix one IE bug (the way width is measured) by exploiting another (broken support for the CSS voice-family rule):

.content
{
width:400px; /* All browsers read this line */
voice-family: "\"}\""; /* IE chokes here and bails out of this block */
voice-family:inherit;
width:300px; /* Other browsers make it to the end and use the correct width */
}

Every time someone codes this, a kitten dies. But it is valid markup, and it is used by many standards supporters. A few references to IE7's improvements are sprinkled here and there, but this book was published before the browser was formally released so don't expect too much info.

One of the hottest topics in CSS is the pure CSS-based layout. Pure CSS layouts usually involve the concept of floating elements and calculating widths. In DWWS, we get a chapter dedicated to the hybrid layout. Hybrid layouts make use of CSS and HTML tables to layout a page, although the table usage is minimized. Zeldman is correct to take this approach, which gives readers practical advice and then lets them decide if they want to move on to more complicated CSS layouts.

The chapter on accessibility is one of the most illuminating. Zeldman has well-reasoned retorts to all the common graphic designer excuses for ignoring accessibility. Accessibility does not mean that a site has to be ugly. Rather, accessibility is something that happens under the hood, in the markup itself. The business case for accessibility is also strongly made. Think you can ignore blind users because your flashy site targets a small, hip audience? Be prepared to get punished by Google, since the GoogleBot is the most powerful blind user on the web ("The Blind Billionaire", as it is called in the book).

A brief chapter is dedicated to DOM-based scripting (aka JavaScript), and the discussion is mostly limited to what scripting can do, and not how to do it. The DOM (Document Object Model) is the model for describing the hierarchy of content on a webpage. Modern techniques like AJAX make extensive use of the intimate relationship between XHTML, CSS, and JavaScript DOM support. However, accessibility, usability, and maintainability are still challenges in the hyper-scripted world of Web 2.0. Zeldman doesn't offer much advice on these topics, but provides a book list for further reading.

I have not read the first edition of DWWS, but the second edition makes it clear where Zeldman has changed tactics and techniques. For example, the image replacement technique described in the first edition wasn't accessible in certain screen readers, so improvements are suggested in the second edition.

Overall, DWWS is a good book for web developers that already know the basics of HTML and CSS, but want to update their 1997 coding techniques. Those new to web design, however, may want to start with a book that is a little more comprehensive. Zeldman does a good job of explaining how to create leaner, lower-cost, and more maintainable web sites. On more than one occasion, I put down this book mid-sentence, loaded up my text editor, and was able to make a quick change to solve a problem that was bugging me. In a book dedicate to making the web designer's life easier, what more can you ask for?

Trent Lucier is a software engineer. His latest experiment is localhost80.com

You can purchase Designing With Web Standards, 2nd Ed. from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Cory Foy writes ""Whatever you do, don't touch that module of code. The guy who wrote it is no longer here, and no one knows how it works." In Practices of an Agile Developer, Venkat Subramaniam and Andy Hunt put that quote as an example of something we are all afraid to hear, but probably have in our careers. They then go on to list a collection of practices which can keep you from hearing, or worse, saying that phrase. How do they do?" Read the rest of Cory's review for the answer. Practices of an Agile Developer author Venkat Subramaniam and Andy Hunt pages 184 publisher Pragmatic Programmers rating Buy reviewer Cory Foy ISBN 0-9745140-8-X summary A book to become a better developer (even without the agile part)

I was excited when I received this book. Having gotten the chance to meet and talk with both Venkat and Andy, I knew they were passionate about getting developers to understand how to deliver value to the customers. Both are proponents of Agile development in one form or another (XP, Scrum, Crystal etc). But rather than try to sell you on one of the methodologies, they laid out seven goals: Beginning Agility, Feeding Agility, Delivering What Users Want, Agile Feedback, Agile Coding, Agile Debugging, and Agile Collaboration

In the first, Beginning Agility, they lay out the basics of becoming an Agile developer. Things like Working for Outcome (in other words, don't blame people for bugs, find out how to fix them and fix the process that caused them) and Criticize Ideas, Not People. Or avoiding the pitfalls of making quick hacks without trying to understand why the hack was necessary (Quick Fixes Become Quicksand). They finish up the chapter with a key word I personally feel is absolutely necessary in software development — courage. They put this in the context of Damn the Torpedoes, Go Ahead. In other words, if the code you are working on is stinky, and you'd like to throw it away, don't be afraid to bring that up. Or if code you are in the middle of building suddenly becomes the wrong direction, stand up and explain that (being sure that in both circumstances you have alternatives for getting it on the right track).

The second chapter, Feeding Agility, discusses ways to keep the flow going while being Agile. Things like Keeping Up With Change remind us to keep our skills sharp and honed. Invest in your Team shows that if you don't bother to spread your knowledge, they'll be unlikely to spread theirs with you, and if the goal is to deliver the best product we can to our customers, that just seems counterintuitive. Of course, it is just as important to Know When to Unlearn. Sure, that ASP solution you've had for 10 years works Ok, but that shouldn't stop you from exploring other new technologies. When you don't understand something, you should Question Until You Understand and finally Feel the Rhythm that Agile brings.

Now comes the contentious part. If our goal really is to deliver the most value to our customers that we can, then it makes sense that they should be able to drive the process. In Delivering What Users Want we hit some turbulent waters with topics like Let Customers Make Decisions, Let Design Guide, Not Dictate, and Fixed Prices are Broken Promises. But, to me, this is one of the most important chapters, and they do a good job of explaining how to accomplish all that with things like Getting Frequent Feedback, Automating Deployment Early, Integrate Early, Integrate Often, and Keep It Releasable. In addition, the use of Short Iterations and Releasing in Increments helps keep the flow going and communication with the customer high.

In order to keep up with the high level of customer communication (and confidence), you are going to need assurances your system is working properly. In Agile Feedback, Andy and Venkat discusses ways to get feedback in ways other than from your customer. At this point, if you've been on traditional projects, you are probably thinking the only way you could do this is with Angels on Your Shoulders, which they explain how to get with a safety net of automated unit tests. To really get a good sense of how to keep the design clean, they use techniques such as Use It Before You Build It and running it on a build machine other than your own since Different Makes a Difference. Finally, to understand how you are really doing, you have to Measure Real Progress which you can do through Automating Acceptance Testing (using something like FitNesse). Finally, you have to Listen To your Users. Similar to the way that you should treat compiler warnings as errors, customer complaints are a sign that something is wrong — especially if it is a high number of customers experiencing the problem.

Now that you are Agile with your customer, the authors begin to target the specific code you are writing in Agile Coding. This is a list of some key tenants of good development, such as Programming Intently and Expressively and Communicating in Code (and not chiefly through comments, either!). But there are some practices that are harder, but just as important like Keep It Simple, Actively Evaluate Trade-Offs and Code in Increments.

No matter how hard we try, though, defects still creep in. Or, we don't get the chance to work with pretty Greenfield code, but are dropped in the middle of a big ball of mud. How do we get out? In Agile Debugging, Andy and Venkat cover some great techniques including Warnings Are Really Errors (mentioned above), Report All Exceptions, and Provide Useful Error Messages.

But one of the techniques was something I had not done before, and I thought was excellent — a Solutions Log (also called a Daylog). In other words, when you come across a problem, document it, and when you solve it, document it. No doubt, you'll come across that problem again, and when you do you'll be glad to be able to go back and figure out how you solved it — especially if you don't have the code you fixed it in the first time. (I have a tendency to record anything I come across that I know I will see again on my blog, and I tell you that typing a question into Google and the first result being your own website is the perfect way to make you feel like a total moron).

The final section, Agile Collaboration, is my idea of a dream team. First, you have to Schedule Regular Face Time to talk about what is going on in the project — especially if you all are working on the same code base! You have to be able to practice Collective Code Ownership (meaning anyone should have the knowledge to change another part of the system), and also means that Architects Should Write Code. To help grow the team, you can Be A Mentor, but to do it effectively you have to Allow People To Figure It Out. Some final practices are around respecting your team by Sharing Code Only When It's Ready, being available to Review Code, and Keeping Others Informed about what you've learned.

I enjoyed the layout of the chapters too. Each one starts with a "devil" which often times was saying something I've heard on one team or another. It finishes with an "angel", and a section of what it feels like to be doing the practice. Andy and Venkat also pepper the text with plenty of real world situations that reinforce just how bad software development can be.

In summary, if you want to be a better developer, but think Agile is a misused buzz word, go to your local bookstore, put a small piece of masking tape over the word "Agile" in the title, and buy this book. You won't regret it.

You can purchase Practices of an Agile Developer from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ravi writes "Fedora — the Linux that is developed as a community effort, is the sand box of Red Hat. They incorporate all the new features after they have been exhaustively tested into its commercial product, namely Red Hat Enterprise Linux . Fedora has a 6 month release schedule and the most recent release is core 6. In all respects Fedora is the same Red Hat Linux but with cutting edge packages. What I really like about Fedora apart from the vibrant community participating in its development is the mark of quality it has from its association with Red Hat." Read the rest of Ravi's review. Fedora Linux author Chris Tyler pages 650 publisher O'Reilly rating 9 reviewer Ravi ISBN 0-596-52682-2 summary An excellent book on setting up and configuring all aspects of Fedora Linux.

Coinciding with the release of the latest version of Fedora, O'Reilly brought out the new book titled Fedora Linux authored by Chris Tyler. The book is divided into 10 chapters spanning over 600 pages with each chapter catering to a particular topic. Like all books of this genre, this book also starts by explaining how to install Fedora on ones machine. But what is different regarding the Fedora installer is that it provides a lot of flexibility, variety and finer control over the install process. Not surprisingly, the author has dedicated two chapters for explaining the various ways in installing Fedora. The first chapter titled "Quick start: Installing Fedora" covers the basic installation from start to finish. Where as the 10th chapter titled "Advanced Installation" covers the advanced features of the installer such as creating logical volumes and Raid during installation, automating the installation process using the kick start file, installing from locations other than a CD/DVD such as NFS and PXE boot as well as a detailed coverage of the Grub boot loader. This chapter also has a short section explaining how to install and use Xen virtual machines.

At a first glance, one might be tempted to bundle this book with the rest of the books available on this subject. But on close scrutiny, I discovered a certain method to the madness. That is each topic that is covered in the book is divided into 4 broad sections. There is a section titled "How do I do that?" which explains the nuts and bolts of accomplishing the given task. The next section titled "How does it work?" gives a good understanding of the theoretical concepts if any behind the topic, the third section titled "What about...?" introduces potential configuration bottlenecks and any additional tasks related to the topic and provides solutions to them. And lastly, there is a section titled "Where can I learn more...?" which provides a bunch of resources on the web and pointers to the respective documentation which will provide further insights about the topic being discussed. It is really refreshing to see this book take such a unique structured approach to explaining the concepts.

The 2nd chapter titled "Using Fedora on your Desktop" apart from covering details about Gnome and KDE Desktops also provides information about additional topics like configuring the XServer, adding new fonts and configuring sound and printing to work with Fedora. There are topics like partitioning a flash drive which makes this particular chapter quite interesting.

The third chapter titled "Using Fedora on your Notebook" explains how to configure Fedora to handle laptop specific features such as power management, mobile networking and configuring touch pad. This chapter also gives a firm introduction to configuring the networking interfaces be it the ethernet or wireless. One thing which holds Fedora in good stead over its peers is the good set of GUI front-ends available to configure each and every aspect of Linux. And configuring networking is no different. But the author does not limit himself to explaining the GUI way of configuring but also explains how to do it the command line way.

No book on Linux is complete without an in depth coverage of the basic commands used for system maintenance. The fourth chapter titled "Basic System Management" is one of the largest chapters in this book where the author explains all the important commands one might be expected to know to keep Fedora Linux in ship shape. Apart from the ubiquitous commands, I also found detailed pointers in enabling secure remote access to Fedora using SSH.

Package management forms the basis for the fifth chapter. Fedora has a great set of tools which aid the user in a variety of ways in installing, removing and upgrading packages. Fedora uses the software management system called RPM Package Manager. But with popular demand, it has also incorporated an apt-get like tool called Yum which automatically resolve dependency issues. I found this chapter to provide an in-depth coverage of all the tools related to package management in Fedora. For example, the author explains how to roll back the installation of a package to a state 10 minutes ago or for that matter to a previous date using the RPM tool. There is also a section which explains how to create ones own RPM packages.

The chapter titled "Storage management" gives a broad explanation of Logical volume management and setting up Raid. Fedora comes with its own LVM administration tool which makes it a snap to set up and manage logical volumes. The author after explaining how to accomplish creating, resizing and deleting logical volumes using this GUI tool, goes on to describe how to do it the command line way too which makes this chapter really useful. All along the chapter, I found useful tips on tasks such as creating backups of the disk and how to go about doing it, stopping a raid and so on.

But the one chapter which I found really comprehensive was the seventh chapter titled "Network Services". Here the author explains how to setup the gamut of network services including but not limited to DHCP server, BIND, CUPS print server, MySQL server, sendmail and more. This chapter spans around 100 pages. There is also a short section providing tips on analyzing the web and ftp logs.

Lets face it. Even though Fedora is a community supported venture backed by Red Hat, it has all the characteristics which propel it to the enterprise level. One of the notable characteristics is the extensive integration of SELinux (Security Enhanced Linux). SELinux controls what a program is and is not allowed to do, enforcing security policy through the kernel. Fedora has very good support for SELinux and has even developed GUI front-ends to make it much more easier to configure. In the 8th chapter, the author explains in detail the steps needed to configure and fine tune selinux on Fedora. This chapter also contain sections which explain the pluggable authentication module as well as other security related features such as configuring a firewall and using access control lists.

The unique structure in which the chapters are layed out makes it more suitable to be used as a reference more than a cover to cover read. The author is eloquent in his narration of the topics and has done a good job of explaining the concepts. I found this book to be an ideal resource for coming up to date with all the system and network administration tasks that can be accomplished in Fedora Linux.

Ravi Kumar maintains a blog where he shares his thoughts related to GNU/Linux, Open Source and Free Software at linuxhelp.blogspot.com. He has also reviewed in a concise way the history of GNU/Linux.

You can purchase Fedora Linux from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ben Rothke writes "In Search of Stupidity gets its title from the classic, albeit infamous business book In Search of Excellence: Lessons from America's Best-Run Companies, by Tom Peters and Robert Waterman. In Search of Excellence quickly became a best-seller when it came out in 1988 and launched a new era of management consultants and business books. But in 2001, Peters admitted that he falsified the underlying data. Librarians have been slow to move the book to the fiction section." Read the rest of Ben's review. In Search of Stupidity: Over Twenty Years of High Tech Marketing Disasters, Second Edition author Merrill Chapman pages 373 publisher Apress rating 9 reviewer Ben Rothke ISBN 1590597214 summary Excellent analysis of hi-tech software marketing disasters

In Search of Stupidity is not a traditional business book; rather, it's a high-level analysis of marketing mistakes made by some of the biggest and most well-known high-tech companies over the last 20 years. The book contains numerous stories of somewhat smart companies that have made stupid marketing mistakes. The catastrophe is that these mistakes have led to the demise of many of these companies.

For those who have been in technology for a while, the book will be a somewhat nostalgic look at what has happened over the years from the world of high-tech marketing. Combined with Chapman's often hilarious observations, the book is a most enjoyable and fascinating read and is hard to put down once you start.

The first chapters of the book discuss the story and mythology around the origins of DOS. It details such luminaries as Digital Research, IBM, Microsoft, Bill Gates and Gary Kildall and more. The first myth about Microsoft is the presumption that the original contract with IBM for MS-DOS gave Microsoft an immediate and unfair advantage over its competitors. The reality is that over time, MS-DOS did indeed become Microsoft's cash cow; but it took the idiocy of Apple, IBM and others to make this happen.

The book also notes that throughout its history, Microsoft would consistently make the most of its competitor's mistakes and stupidity to its advantage. The book repeatedly notes that yes, Microsoft has not always been ethical or nice; but the reality is that such behavior has also been practiced by many in the software industry. Not that it rationalizes what Microsoft has done, and to a degree still does. But it is unfair to pinpoint Microsoft as the sole miscreant in the dirty software waters.

For the better part of the last decade, Microsoft has owned the desktop. But that was not always the case. In the early 1990's IBM was frantically working on its nascent OS/2 operating system, working alongside Microsoft as a trusted partner. IBM had the cash and talent to ensure that OS/2 would own the desktop. So why did OS/2 miserably fail? It was primarily IBM's own ineptitude in marketing OS/2 which led to Windows 95 taking over the desktop. The desktop was IBM's to lose and that is precisely what it did.

Microsoft at one point was working with IBM to develop OS/2 and many have written that Microsoft took advantage of IBM in that joint effort. But Chapman writes that complete and direct responsibility for the failure of OS/2 falls completely on IBM. He notes that it is difficult to find a marketing mistake around OS/2 that IBM did not make. At the time, the market was ready to accept almost any GUI and it was Microsoft that gave the people what they wanted. It was not so much that Microsoft beat IBM; rather that IBM imploded with OS/2 and Microsoft was there to pick up the pieces.

As to ownership of the desktop, Chapman notes that even with Microsoft's near endless budget, bullying tactics, and use of the FUD factor, those alone did not enable Microsoft to monopolize the desktop operating system market. Chapman notes that the following key factors, all which are unrelated and out of Microsoft's control had to take place in order for that to happen.

First, Xerox, the original inventor of the GUI had to never develop a clue about how to commercialize the groundbreaking product that came out of its own labs. Digital Research then had to blow off IBM when it came calling to them for an operating systems for the original IBM PC. IBM would then have to fall victim to Microsoft during its joint development of OS/2.

Finally, Apple would have to decide not to license the Macintosh operating system. That decision led Apple to have a 30% share of the desktop market in the early 1990's to its current irrelevant 4% share.

Chapman lists numerous secondary factors that also contributed to Microsoft's dominance. While the accepted wisdom is that Microsoft single-handedly cornered the desktop operating system market; the reality is that the ultimate success of Microsoft is as much a result of their near endless good luck combined with the recurring stupidity of its competition.

The stupidity of IBM and Apple gave the desktop market to Microsoft. Similarly, Novell gave the NOS market to them. In the mid-1990's, Novell owned the NOS market. Netware along with myriad CNE's (Certified Network Engineerswere the dominant force in network computing. When Windows NT version 3.1 shipped (it was really version 1.0), it was clearly inferior to Netware, as myriad product reviews stated.

Yet a few years later, Windows NT was the dominant NOS and Novell was struggling. While Netware was clearly superior to NT from a functionality perspective, the genius of Microsoft was that it knew better how to deal and communicate with its development community. Today, Netware is an irrelevant NOS and Novell has effectively abandoned it to primarily focus on its Linux strategy.

Exactly at the same time Microsoft was pushing Windows NT and wooing developers, Novell shutdown its third-party development center in Austin, TX. Novell also became preoccupied with its misguided purchase of WordPerfect. Novell developers were left hanging until Microsoft came calling with its promises of NT development and marketing support. Similarly, it was Novell failures that directly lead to the success of Windows NT.

Novell had myriad chances to decimate Windows, but it never stepped up to the plate. Novell's inexperienced marketing department thought that "if you built a great NOS, they would come." But come they did not, and leave Netware they did.

It is chapter 10 that will likely give Slashdot readers a fit. The author attempts to set straight additional myths around Microsoft: that their products are of poor quality, that they have only succeeded because of its market monopolies, that they are not innovative, and more. For those who want all of the details, they should read the book. But the authors notes for example that while Microsoft has been widely criticized for not being an innovative company, it is no different from companies such as Lotus, Borland, Xerox and more.

Most recently, when Microsoft found itself behind the 8-ball and lacking a browser, Internet Explorer was quickly developer and in time, surpassed the capability of Netscape Navigator. By 1998, most reviews were giving IE a higher rating than Navigator. Of course, Microsoft has more cash and developers than Netscape, but that alone was not what doomed them. Simultaneously, Netscape derailed itself in an attempt to completely rewrite Navigator in Java. This led them to the state where they would permanently fall behind Microsoft in the development race.

The book contains 12 chapters each with a different set of stupid marketing actions. Rather than simply being a Monday morning quarterback, chapter 14 contains an analysis of each scenario and what the respective companies should have done.

In Search of Stupidity: Over Twenty Years of High Tech Marketing Disasters is a most valuable book and is a wonderful read for anyone in the software industry. For those in sales and marketing, it is clearly required reading, and in fact, should be reread periodically. While In Search of Excellence turned out to be a fraud, In Search of Stupidity is genuine, and no names have been changed to protect the guilty.

You can purchase In Search of Stupidity: Over Twenty Years of High Tech Marketing Disasters, Second Edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "Anyone involved with the coding of Web sites likely knows that Cascading Style Sheets (CSS) should be used for styling the content of their sites' pages — setting text sizes and fonts, setting background colors, sizing margins, positioning images, and more. CSS allows the Web developer to specify the visual appearance of the site, separately from the HTML, and thus to be able to make changes in the future within a single stylesheet, rather than hunting through the HTML and modifying every occurrence of each affected element. The benefits of CSS are many, but so too can be the frustrations when the developer turns for help to CSS books heavy on theory and light on practical explanations. For every Web site 'cook' feeling the heat in their cyber kitchen, there is an ingredient that can help: CSS Cookbook." Read the rest of Michael's review, CSS Cookbook author Christopher Schmitt pages 538 publisher O'Reilly Media rating 8 reviewer Michael J. Ross ISBN 0596005768 summary Practical solutions to common CSS challenges

Written by award-winning Web designer Christopher Schmitt, this book is published by O'Reilly Media, under the ISBN 0596005768, and is in its second edition, having been updated for Internet Explorer 7 and Firefox 1.5. The book has its own Web page on the publisher's site, offering the book's table of contents, the index, Appendix D ("Styling of Form Elements," in PDF format), and links for reading and submitting book reviews/comments, as well as reading and reporting errata (there are none, as of this writing).

The book's 538 pages are organized into 12 chapters, which cover the major areas of interest to the Web developer: CSS overview, typography, images, page elements, lists, links and navigation, forms, tables, page layouts, printable pages, hacks and workarounds, and design considerations. Appendix A briefly describes some of the better online CSS resources, including tutorials, design guides, discussion groups, technical references, and tools, such as the W3C validators. The next two appendices cover CSS 2.1 properties, proprietary extensions, selectors, pseudo-classes, and pseudo-elements.

The fourth and last appendix, on the styling of form elements, details how 20 CSS properties affect eight form elements, as displayed within Windows Internet Explorer 5, 5.5, 6, and 7; Mac Safari 2; Windows and Mac Firefox 1.5; Windows and Mac Netscape Navigator 7.2; and Opera 8.5. The form elements considered are: checkboxes, file upload elements, radio buttons, text fields, multiple options, select elements, submit buttons, and text areas. The author does not explain exactly what page elements are meant by "File Upload" (at the beginning of the appendix) or "File Input" (the actual section title). Presumably he is referring to the file display field and Browse button, and not the file locator dialog box, which is determined by the browser and operating system. More importantly, he does not explain what is meant by "multiple options" nor "select elements," and neither term is listed in the book's index. Future editions of the book would benefit by beginning every element's section with an example, showing the code as well as the element's appearance on a Web page. Despite this obvious omission, this appendix could prove a godsend to anyone concerned with how these various types of elements are affected by CSS within these eight major browser versions. As noted earlier, the appendix can be downloaded for free.

HTML/CSS books generally fall into two broad categories: Introductory books are usually sufficient for beginners, because they cover the basics. But they are typically useless to the veteran developer who is struggling to understand why Internet Explorer is mucking up yet another page that looks fine in Firefox, Opera, and Safari — and how to work around the problem. Advanced books assume that the reader already has a relatively solid understanding of the technologies, and uses that basis as a foundation from which to explore sophisticated design techniques. But even those books prove inadequate for the developer who is simply wondering how to best use pure CSS to do such presumably straightforward tasks as positioning some images horizontally, with small captions centered underneath each one. In fact, many of those advanced books seem to have little interest in clearly explaining how the reader can do what the author has done, largely because the sample projects and their source listings are too long and involved, thus burying the critical HTML and CSS in pages of code.

There is clearly a great need for one or more HTML/CSS books aimed at the developer who already understands the basics, and wants to apply that knowledge for building robust Web pages, all while following defensible best practices. The O'Reilly "Cookbook" titles are intended to fill that gap, by presenting the material in the form of recipes, each comprising a brief statement of the problem to be solved, a summary of the solution, and a discussion of the solution's details. Oftentimes additional resources are referenced, in a "Sea Also" subsection, which might have one or more links to relevant Web sites. The discussion subsections usually have sample code, in addition to a figure showing the code's output.

Possibly the greatest benefits of the cookbook format, is that it forces the author to clearly state the purpose of each section, and then to get right to the point of how to achieve that purpose. This prevents the meandering seen in many of the advanced design books, which is the main reason why they can be so frustrating for the developer who wants to quickly find out how to perform a specific task on a Web page, such as the image positioning task mentioned earlier. Possibly the biggest downside to the cookbook format is that it results in contrived problem statements, such as the very first one in CSS Cookbook: "Problem — You want to use CSS in your web pages." Is that truly a problem? Is it not much more a goal or task, than some sort of problematic difficulty?

Yet aside from any misleading subsection titling, the recipe format does cause any (largely) expository material in a technical book to get chopped up into somewhat artificial pieces. It is more noticeable in the first chapter of this particular book, titled "General," in which Schmitt explains the fundamentals of CSS: selectors, classes and IDs, properties, the box model, style sheets, comments, shorthand properties, floating images, absolute and relative positioning, and using CSS with the more common page development tools. As the author gets into more advanced topics — for which individual subsections can stand more on their own — the recipe format works fine. One advantage is that the section titles end up being detailed enough that the reader can, in most cases, quickly find the relevant section to address their needs.

Overall, this book is a fine addition to O'Reilly's growing list of programming titles. However, like all books, it is not perfect. It does not cover all of the more common tasks that the average Web programmer might want to accomplish — but it does hit the bulk of them. Sadly, all of the figures in the book are in black and white, including those displaying colors on the sample Web pages. Shades of gray are just not optimal. Fortunately, in most cases, the crux of the technique is discernible. In addition, the sample code has too many instances where layout is achieved using tables, and not pure CSS. Lastly, the book's index — similar to that of so many other technical books nowadays — could certainly use some beefing up. After all, if the reader cannot find the desired material using the table of contents, the index is their last hope, before resorting to time-wasting page flipping.

In terms of HTML and CSS information, the topics are well chosen, and the coverage of browser hacks and workarounds is excellent. Also, the most critical parts of the code are helpfully bolded. For those readers completely unfamiliar with JavaScript, it is used only where unavoidable. The book's material is neatly presented, and the author's writing style is straightforward and approachable.

On balance, CSS Cookbook is to be recommended to any developer looking for a CSS guide that is concise, clearly written, well-illustrated, and addresses the most common challenges in building Web pages.

Michael J. Ross is a computer consultant, freelance writer, and the editor of PristinePlanet.com's free newsletter. He can be reached at www.ross.ws, hosted by SiteGround.

You can purchase CSS Cookbook from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Andrew Leigh writes "On The Edge: The Spectacular Rise And Fall Of Commodore by Brian Bagnall is fodder for anyone interested in the buried history of the personal computer. Whether you owned a Commodore computer or want to hear a new angle on the early stages of computer development, you'll find this book easy to pick up and almost impossible to put down. Bagnall has gone to a massive amount of effort in telling this tale, researching and interviewing the real personalities involved. It takes readers on an important and often emotional ride that will many times leave you shaking your head at how painfully it all went wrong." Read the rest of Andrew's review On The Edge: The Spectacular Rise and Fall of Commodore author Brian Bagnall pages 557 publisher Variant Press rating 9 reviewer Andrew Leigh ISBN 0973864907 summary Tells the story of Commodore through first-hand accounts by former Commodore engineers and managers

Before Commodore entered the home computer market, they were primarily a calculator manufacturer. The story begins in the mid 70's with the development of Chuck Peddle's famous 6502 chip, through to the release of the first personal computer, the Commodore PET. It then reveals how the VIC-20 became the first home computer to break the elusive one million barrier. Then comes the Commodore 64, and how the company made it the best selling computer of all time. The Commodore 128 is given plenty of coverage, along with the failed Commodore 16 and Plus/4 computers (which are probably better off forgotten). At this point, Commodore seems like it is losing its way, and the story cuts to the struggling company responsible for the original Amiga computer. You'll learn about the various Amiga models that followed, including the successful Amiga 500 and the pre-DVD CDTV and CD32 units. The hirings, firings, disagreements, discontent, resignations and celebrations that occurred during the company's run are given more than their fair share of coverage. It doesn't always show Commodore in the best light, which is what readers should demand from any history.

It's a sad truth, and the book describes this in an often bitter fashion, that the early history of computers seems to focus on Apple, IBM and Microsoft while Commodore's massive contributions to the industry are routinely ignored. The common misconception that Apple started the home computing industry is simply wrong. Commodore was the first to show a personal computer, the first to deliver low-cost computers to the masses, the first to sell a million computers, and the first to arrive with a true multimedia computer. Fortunately this book sets a lot of the record straight.

On The Edge delves deeply into the business strategies behind the company. Students of any business discipline will be well advised to heed the lessons about how not to run a company. One of the book's main characters and the founder of Commodore, Jack Tramiel, was an incredibly ruthless business man. Whether you love him or hate him, he was ultimately behind the incredible success of the VIC-20 and Commodore 64 computers. The book outlines how he managed to be the first to sell his home computers to the mass market through department stores, driving prices down and annihilating most of the competition. It also amusingly tells how he would regularly lose his temper and have what employees referred to as "Jack Attacks" when things went wrong. Many people referred to him as the scariest man alive and he probably was. Jack Tramiel unfortunately does not publicly talk about the Commodore days, so Bagnall was not able to personally interview him, however family members and those close to him give their personal accounts of events.

The book also explains how Irving Gould, the money-man and venture capitalist behind Commodore, constantly interfered when things were seemingly running smoothly. It is widely recognized that Irving Gould and Medhi Ali (the CEO he instated at the time) ultimately caused the sad demise of Commodore through 1993-94, yet the details of how it happened have always been sketchy until now. Thomas Rattigan, former CEO of Commodore, was interviewed by Bagnall and gives his personal thoughts and experiences during his time with the company. He also talks about his untimely dismissal by Gould. The later sections of the book describe how numerous marketing mishaps and poor business sense led to a dwindling stock price and an eventual filing for liquidation. Bagnall accurately describes the heartbreaking end to a great company that deserved much more success and recognition.

This book certainly does not shy away from getting its metaphorical hands dirty with the technical details and manufacturing processes involved in building the Commodore computers. If anything, more detail would be welcome here, as the personalities interviewed obviously drove their designs by an enormous amount of passion. Bagnall has interviewed all the original key players involved on the technical side, including the humble and personable Chuck Peddle. You'll read how he built the MOS 6502 microprocessor, with the talented layout artist Bill Mensch. The chip was used by not only Commodore but rivals Apple, Atari, and Nintendo. Many other notable and significant technical pioneers have also been interviewed and give their experiences and opinions.

You'll learn why your 1541 floppy disk drive was so unbearably slow. You'll learn how millions of dollars worth of Amigas were scrapped because of a cheeky message placed in the ROM by a disgruntled employee. You'll learn how exhausted coders had to take naps at their desks while code compiled on a mainframe. You'll also learn why those tedious "peek" and "poke" functions weren't built in as BASIC commands for easier usage on your C64.

Interestingly, Steve Wozinak, one of the co-founders of Apple Computers, claims in his new book (titled "iWoz") that he invented the personal computer and provided Chuck Peddle with the idea for the first Commodore PET. When you read On The Edge, you'll find that it tells a different story. Chuck Peddle receives a great deal of coverage, and after reading about his efforts you will feel this is deservedly so. His efforts have gone largely unsung and On The Edge may well be the first step towards him earning the title of being the father of the personal computer.

Commodore Business Machines was a company that produced superior computers for the mass market. Their legacy deserves to be told and more importantly heard. Computing history didn't just involve the big players that still exist today. Commodore, Atari, Radio Shack, and others all shaped the future. On The Edge is an experience that will change the way you view computing history and maybe even entice you to dust off that old Commodore computer that's been sitting in the cupboard. Bagnall tells it like it is and also leaves you thinking "what if?" many times. The great stories are filled with characters that anyone who works in the IT industry will recognize in their own workplace. It truly demonstrates the fragility and ad-hoc nature of not only Commodore itself, but the entire industry back then. It really makes you cringe in disbelief at how some stupid and insignificant decisions shaped the future as we know it now. No one could have known how important these decisions were back then.

At a hefty 557 pages, On The Edge is good value. Bagnall's informative and relaxed writing makes it a breeze to travel through decades at a blistering pace. It sheds some much needed light on a period of history clouded by revisionism.

You can purchase On The Edge: The Spectacular Rise and Fall of Commodore from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Cam Turner writes "In late August, Slashdot reported that a lost Robert A. Heinlein novel was mere months away from being released. True enough, it was completed and released on October 18th, 2006 by Spider Robinson, himself a distinguished speculative fiction writer. On the back cover, John Varley is quoted as saying "Completing a book from notes by a dead author is almost always a mistake. But apparently Robert A. Heinlein isn't really dead. He was at the side of Spider Robinson as he wrote this book." I'd have to agree. This story is a valuable addition to any speculative fiction collection, even that of a purist Heinlein fan." Read the rest of Cam's review. Variable Star author Robert A. Heinlein and Spider Robinson pages 320 publisher Tor Books rating 8.5/10 reviewer Cam Turner ISBN 076531312X summary An excellent additon to your speculative fiction collection.

In the afterword Spider Robinson describes how he came to be the writer who took Heinlein's eight pages of notes — penned in November 1955 — and turned them into a full length novel released half a century later and 18 years after Heinlein's death. He describes it as "literally the most difficult and intimidating challenge that could be handed to a science fiction writer." However, as a lifelong fan of Heinlein's work, Robinson said "I wanted to read a new Heinlein novel so badly that I didn't care if I had to finish it myself."

The protagonist, Joel Johnston of Ganymede, is a man of his late teens or early twenties. His life as he knows it falls apart when his fiancé turns out not to be who she says she is. As he struggles to regain control of his identity and his direction in life, he decides to join a starship as it travels 85 light years — and 20 ship years — to found the colony on a newly discovered Earth-like planet. Variable Star is the story of his journey, his regrets and the friends he makes en route.

Identifying the antagonist is a little more complicated — as it is with many of Heinlein's novels. It could possibly be his struggle with adapting to his new life in a small colony of only 500 people, his regrets over leaving the love of his life, or his tenuous escape from her family's vast influence. Regardless, the possibilities weave together to create a richly imagined story that is a believable description of how events might unfold for a character in Joel's position on a long journey between the stars.

The rest of the characters are also vivid and well constructed. At no time did they act counter-intuitively to their rich back stories. Certainly each character is revealed and built up over the course of the book, but I found their actions and motivations to be entirely believable and flawed in the way that only humans — even future humans — can be.

Heinlein fans will recognize many nods to the Future History timeline. From Leslie LeCroix being the pilot of the first moonship to the Covenant (and Coventry) that brought enforceable peace and tolerance to the human civilization after the fall of the Prophet. Robinson also incorporates many of the various sexual ideas that Heinlein had in his works like The Moon is a Harsh Mistress and Stranger in a Strange Land, however he doesn't go into as lavish and descriptive detail as Heinlein often did.

As a downside, I don't think that Variable Star is going to be as timeless as some of Heinlein's better works. Robinson managed to work into the Future History (timeline two) nods to both the 9/11 terrorist attacks and the Iraq wars. Reading through them jarred me back to reality momentarily and thus detracted from the story. Robinson is careful not to mention these events by name, but readers for years to come may find their mention distracting. It's true that we'll look back on these events in the future as part of our violent history, but invented wars would have served the same purpose in terms of story development and would have allowed the reader to stay in the imaginary world.

As mentioned, the outline was created in 1955 and, as expected, fits perfectly into the Heinlein Juvenile and Young Readers works of that time. It appeals to teenage boys and furthers Heinlein's propaganda agenda about the colonization of space. It is not what Heinlein would have described as "adult" fiction and has a single, linear storyline and a well defined main thread. Teenage readers will be able to identify with many of the struggles Joel faces through the course of the book and Heinlein fans will get a kick out of seeing how Robinson weaves in numerous references to Heinlein's earlier works. For other adult readers the story is still a fantastic, quick and entertaining read.

In the afterword Robinson makes a point of mentioning that the notes Heinlein left behind contained no climax or ending. Robinson tells the story of how both were inspired by some audio clips of Heinlein interviews in the 80's and extrapolated from his views on the true future of humanity. That said, the climax was not a typical Heinlein climax and was entirely unpredictable up until the exact moment it occurs.

To be honest as the number of remaining pages dwindled I began to wonder how exactly Robinson was going to get where I thought he was going in the pages he had left. I feared a Neil Stephenson-like abrupt ending was the fate of the story and characters I had come to love. I was very happily surprised with what I got. The ending fits the situation, motivations and expected behaviors of the characters so perfectly that, in hindsight, I can't imagine it concluding any other way.

Ultimately I give this book an 8.5/10. Robinson has done an excellent job of writing a strong story with strong characters as well as paying homage to the Grand Master and the vast legacy of richly imagined universes he left behind. Make no mistake, Variable Star isn't of the same caliber as The Moon is a Harsh Mistress or Stranger in a Strange Land, but it certainly holds up against many of the novels that have been nominated for the Hugo or Nebula awards the last few years. It might not win next year, but I'd be surprised if it didn't at least make both of the final ballots.

Lastly, potential buyers of this book should note that profits from the sales will help fund the $500,000 Heinlein Prize for innovation in commercial manned spaceflight, a goal Robert A. Heinlein considered crucial to humanity's long-term survival.

Aside: I haven't yet had an opportunity to read anything else by Spider Robinson, but I am now a fan of his work and intend to work my way back through his collection too. Does the Slashdot community have any suggestions on where to start?

Cam Turner is the author of Beginning Google Maps Applications, an internet software developer, a father and a long time Heinlein fan.

You can purchase Variable Star from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Tim Hunter writes "Hal Fulton's The Ruby Way, Second Edition doesn't try to be the only book a Ruby programmer needs. It tries to be a book every serious Ruby programmer needs, and it succeeds. The Ruby Way is a book about programming with Ruby, the object-oriented programming language from Japan. Ruby is free software and runs on Linux, Microsoft Windows, Apple OS X, and other operating systems. It is available for download from its web site, www.ruby-lang.org or its companion site www.rubyforge.org. Read the rest of Tim's review. The Ruby Way, Second Edition author Hal Fulton pages 839 publisher Addison-Wesley rating 9 reviewer Tim Hunter ISBN 0-672-32884-4 summary A task-oriented book about the Ruby programming language

I read the first edition of The Ruby Way when it was published in 2002, not long after I starting programming in Ruby. I was a member of the discussion group Fulton organized during the writing of this edition. I am also the author of RMagick, one of the libraries described in this book, and did the technical review of that section.

This is a review of the second edition of The Ruby Way. The first edition described the then-current Ruby syntax and libraries and showed novice Ruby programmers how to perform common programming tasks. In the past four years Ruby has evolved and its community has grown immensely. Consequently, the first edition was starting to look a little long in the tooth and the Ruby community has been eager for the appearance of a new edition. This edition is almost a complete rewrite. Saying that it's 260 pages longer minimizes the actual scope of the changes. There are a dozen new chapters. Some of the new material expands on topics that were present in the older work, like regular expressions and data structures. However, much of the new material covers topics that simply didn't exist 4 years ago, such as Ruby's XML and RSS libraries, RubyGems (Ruby's answer to CPAN), and Rake, the Ruby version of make.

The Ruby Way doesn't try to teach how to program in Ruby. For that, you need Dave Thomas' Programming Ruby: The Pragmatic Programmer's Guide or a similar book. The goal of The Ruby Way is nothing less than describing the universe around the Ruby programming language. In one 800+ page volume, it describes Ruby's design principles, history, syntax, built-in classes, standard libraries, 3rd-party add-on libraries, related development tools, and user community. The examples and Fulton's explanations emphasize Ruby programming best practices, hence the title.

Fulton describes The Ruby Way as an "inverted reference." A typical reference book for a programming language lists the libraries, classes and methods by name, which you can use to discover their purpose. The Ruby Way, on the other hand, groups Ruby's libraries, classes and methods by purpose, from which you can discover their names. Section titles tend to describe tasks, such as "Tokenizing a String" and "Interacting with an IMAP Server". The sections then describe the split method in the String class and the net/imap library, respectively. Several chapters group Ruby libraries by related tasks. For example, Chapter 15 describes Ruby libraries used to process specialized data formats such as XML, RSS, images, and PDF. In this chapter you will learn that XML processing in Ruby is typically done with REXML and that PDF files can be created with PDF::Writer, etc. Organizing topics by purpose or function instead of by name makes it easy to discover what parts of Ruby you need to complete a task.

Unlike many of the 2-inch thick books about programming for sale lately, there is no fat in The Ruby Way. It hits the ground running with an introduction to object oriented programming and a whirlwind tour of Ruby syntax. It covers Ruby's built-in classes in considerable depth. The String class gets an entire chapter, as do regular expressions. Array and Hash rate yet another chapter. Fulton continues with an in-depth survey of Ruby's extensive standard library. Interested in object persistence? Chapter 10 describes Ruby's YAML library. Wondering about unit testing? Go to Chapter 16 to read about the Test::Unit library. One of the most frequently asked questions to the ruby-lang mailing list is "what GUI libraries are there for Ruby?" Chapter 12 supplies sample applications that demonstrate graphical interface libraries such as Ruby/Tk, FXRuby, and QtRuby. Chapter 19 is dedicated to web application development tools ranging from the famous Ruby on Rails to the lesser-known but equally useful Nitro. Chapter 22, "The Ruby Community," tells where other Ruby programmers hang out. Catering to his programmer audience, Fulton peppers each section with code snippets and complete example programs. (The source code for the book can be downloaded from Fulton's web page.)

Although Ruby is thought to be a "Linux-centric" language it also has a large audience in the Microsoft Windows community. Fulton addresses these users' needs with a description of the "One-Click Ruby Installer" for Windows. This description is accompanied by a section about the Ruby libraries available for scripting on Windows. For example, Fulton shows how to open a file dialog box using the Win32OLE library.

Fulton says that he doesn't expect anybody to read his book from front-to-back. Nevertheless The Ruby Way is quite readable and (if not for its considerable weight) would make a good book for browsing while waiting for the bus, or between classes. Some sections contain a surprising amount of general background information, such as the remarkably in-depth description of Unicode in Chapter 4. Not content to simply educate the reader, Fulton continues his practice in the 1st edition of entertaining the reader with thoughtfully chosen quotes, geek humor, and personal observations.

Is there anything not to like about this book? Well, to be perfectly honest I occasionally found myself wondering if sometimes Fulton spread himself too thin. The amount of coverage for individual classes and libraries varies widely. Some of the standard libraries, like REXML, get several pages of description and an accompanying example while others, such as open-uri, get only a cursory introduction and a pointer to the on-line documentation. At 4 pages, the section on Rails is perfunctory and, given the number of very good books already available on the subject, redundant. (Fulton himself says the material is "cursory.") I have to wonder if it isn't there simply because "everybody" expects books about Ruby to say something about Rails. Similarly he devotes a single page to ActiveRecord, which, as a part of Ruby on Rails, is capably documented elsewhere. That page would've been better used to double the number of pages spent on Og, another Ruby ORM which is not so richly documented.

I recommend this book to any programmer who has already learned the basics of Ruby syntax and its built in classes and who wants to learn more about using Ruby to accomplish typical programming tasks. While it will be particularly useful to the novice Ruby programmer, it is a handy reference for Rubyists at any level of experience.

You can purchase The Ruby Way, Second Edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ravi writes "Python, the dynamic object oriented programming language created by Guido van Rossum is known to deliver both the power and general applicability of traditional compiled languages without the complexities accompanying them. Coupled with its ease of use, programs written in Python can be run on multiple Operating systems and system architectures which gives it the same portability of any interpreted language. My first brush with Python was when I tried out a beautiful game called PySol — which is more like a collection of over 200 card games and PySol is entirely coded using the Python language. Nowadays a variety of Python web frameworks have also cropped up which promise the same kind of rapid application development that is possible using other programming languages." Read the rest of Ravi's review Core Python Programming - 2nd Edition author Wesley.J.Chun pages 1050 publisher Prentice Hall rating 9 reviewer Ravi ISBN 0-13-226993-7 summary An excellent book to learn the Python programming Language

I found the book titled "Core Python Programming" authored by Wesley.J.Chun and published by Prentice Hall to be an ideal book to learn the wonderful Python language. This book is quite voluminous, with 23 chapters spanning 1050 pages. The book is divided into two parts the first part titled Core Python which contain 14 chapters which impart a sound understanding of the semantics of the language and the second part titled "Advanced Topics" which contain a collection of 9 chapters which give a good introduction to the specialized uses such as in database programming, network programming, using threads in python, GUI programming and so on.

In the first chapter of the book, the readers get to know the various features of Python and the steps needed to install Python on ones machine. When you install Python on your machine, it also provides its own shell where you can execute pieces of python code. The author has taken advantage of this functionality of Python in narrating the concepts throughout the book. Each concept and syntax is followed by bits of code which the readers can try out in the Python shell in its entity. I found this process much easier in learning this language as one need not go through the write — compile — execute cycle which is more prevalent in the traditional languages.

In depth coverage has been provided for important concepts such as lists, tuples and dictionaries as well as data-types and string sequences and they have been provided separate chapters of their own. The sixth chapter titled "Sequences: Strings, Lists and Tuples" is the second largest in the book and is quite detailed in its coverage of the topic.

Chapter 9 deals with file manipulations where the author introduces all the built in functions available in Python which allow one to open, read from and write to a file. Interestingly, the functions are also illustrated by aid of short easy to understand examples. A couple of modules related to file handling are also introduced in this chapter.

Errors and exceptions form the basis of the 10th chapter where different errors and exceptions supported in Python are explained. This chapter also explains how programmers can create custom exception classes which I found quite informative.

One of the biggest advantages of Python is that all its functionality is split up into modules. A module could be just a single python file which contain a collection of functions or classes which can be re-used in programs written in Python. And all one has to do is import the module into ones programs to start using those pieces of code. The chapter 12 titled Modules give a firm understanding of this concept and also introduces different ways in which you can import external pieces of code into the Python program.

Chapter 13 titled "Object Oriented Programming" is by far the largest chapter in this book and spans over 100 pages. In this chapter, the author endeavors to give a sound base to Object oriented concepts as well as how they relate to programming in Python. The author introduces a large number of Python classes, methods and descriptors in this chapter.

Regular expressions play a very important part in programming verily because manipulating text/data is a necessity. And it is possible to easily modify and mould data to ones choosing by way of regular expressions. Python has strong support for regular expressions. The second part titled "Advanced concepts" of the book starts with a chapter on regular expressions. In this chapter, one gets to know about the regular expression module and many functions associated with the module. The author also provides a couple of examples which give insights into the ways in which regular expressions can be used in Python to reformat data.

The next two chapters give an introduction to the world of sockets and how Python can be used to write client server programs.

Multithreaded programming forms the basis of the 18th chapter. Here the author introduces a couple of modules available in Python which make it quite easy to create threads in ones Python program.

I found the chapter titled "Web Programming" very interesting to read. Especially since Python is used in a large way to create dynamic websites. And the next chapter titled "Database programming" gives a sound introduction to the Python objects which allow one to easily connect to and retrieve data from the databases.

I found this book really informative, especially suited for upcoming Python programmers. At the end of each chapter, there is an exercise section which imparts a nice touch to this book as it allows you to test your knowledge. Even though the advanced topics (second part of the book) are not covered in depth, the author succeeds in providing enough knowledge about the relevant Python modules and functions followed by a couple of examples which whets ones appetite without overwhelming the reader. This is the second edition of the book and it has been significantly revamped to include new features introduced in Python 2.5.

The author Wesley J. Chun has been a former employee at Yahoo and has played a major role in creating Yahoo Mail and Yahoo People Search using Python. He has over 20 years of experience in the IT field with over a decade of experience programming in Python.

Ravi Kumar likes all things related to open source and free software and enjoys sharing his experiences and thoughts through his blog All about Linux.

You can purchase Core Python Programming - 2nd Edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Trent Lucier writes "Google depends on new content constantly being added to the web. No Google initiative has done a better job at encouraging new content than the AdSense/AdWords programs. Google Advertising Tools by Harold Davis is a book that teaches you to use these tools effectively." Read the rest of Trent's review. Google Advertising Tools author Harold Davis pages 353 publisher O'Reilly rating 8 reviewer Trent Lucier ISBN 0596101082 summary A guide to using Google's AdWords and AdSense programs, along with some additional advertising strategies.

For those wondering how Google made $6 billion last year without every charging you so much as a penny for all your searching, AdWords and AdSense are a big part of the answer. AdSense is the program that lets webmasters post targeted advertisements on their websites. When a visitor clicks the ad, both the webmaster and Google get some money. AdWords is the other side of the equation. It is the program by which merchants submit their ads and bid on ad rates. Google tries - and generally succeeds - at matching ads with the most relevant websites (that's the "target" in "targeted ads").

I have sympathy for anyone who has to write technical literature. Sometimes, the process can be like living in an M.C. Escher painting where you don't know which part of the stairs should come first. Davis must have felt this way too, since he provides a lot of background information before getting to the goods on Google. Before one can discuss AdSense, search engine optimization should be learned...but before that, driving traffic to a website is useful...but before that, you have to understand what makes riveting content. Perhaps this is why the chapters on AdWords and AdSense don't begin until page 141.

My interest is primarily in AdSense, and this book has some great tips for improving the relevancy of the ads that run on your site.

For example, META keywords always seemed useless to me, tossed into the dustbin of irrelevance by spammers. Davis, however, argues that keywords are worth using if your site doesn't contain a lot of text content. He provides an example of a site that is mostly made of images, and shows how the META keywords appear as the page's description in Google search results. This is good stuff if you run a tool-based site with little text-content and are having trouble teaching Google what your site is about.

Davis spends a lot of time explaining the AdSense and AdWords statistics and screens (the book does get a little pedantic with screenshot after screenshot). The almighty CTR (Click-Through Rate) is one of the most important statistics, representing what proportion of your visitors clicked on ads. I previously had no idea what was a good or bad CTR. Davis says that a good rate is 0.5% to 2% (with the latter being a homerun). "If your CTR is consistently below 0.5%...your traffic is going to waste."

That's a good tip, and it gives readers a concrete way to measure progress.

Webalizer and other tools are also briefly explained in terms of how the information they provide can be used with AdSense. For example, it is important to know the top exit pages for your site, because if users are ready to leave, they are more likely to click an ad.

Click-fraud gets half a page, but I would have liked more information. The section ends with the eyebrow-raising statement: "A recent study shows that less than 6% of all advertisers regard [click fraud] as a problem."

Really? What study was that? I also wondered how click-fraud is usually committed. Davis says that detecting it is primarily a statistical matter.

Non-Google advertising also takes up a large part of the book. In fact, the first 140 pages are almost Google-free. Search engine optimization, driving traffic to your site, affiliate programs... all are discussed at length. The affiliate program section is quite good, although it did have one questionable piece of advice: "You should test that each affiliate link on your site works by buying something and making sure the sales commission shows up when you check the tracking software."
He must be working with some really nice merchants, because this violates practically every terms-of-service agreement that I've seen.

Right before you get to the Google section, Davis devotes an entire chapter to adult sites.

In truth, the adult sites section is informative and practical. If you ever wondered how to privately create an adult site and profit from it, Davis pretty much gives you all the info you need to get started. He even provides links to some real adult sites and tools for hosting content. (One of his tips on obtaining adult content: "Create content yourself." Uh, no thanks.)

But the chapter on adult content leads to the biggest "Huh?" moment in the book: "Although Google will not accept adult-content sites into its AdSense content network, it will accept ads into the AdWords program that direct traffic to adult sites."

Let me get this straight: Google refuses to run ads on adult sites, but it has no problem driving traffic to adult sites via ads? Does this strike anyone else as backwards? Sadly, the book has no further explanation of what the quoted sentence means, or how to use AdSense/AdWords if you are providing borderline adult-content.

The last part of the book describes how to use the AdWords API. For advertisers whose needs are too massive to create individual ads through the AdWords GUI, the API can be used to programmatically interact with the AdWords servers. Examples using C# and PHP are provided.

The book was published in January of 2006, and I found it to be as timely as can be expected from a computer/internet book. A few of the screens look a little different (the AdSense color-scheme chooser has changed), but none of the info seems to be harmfully wrong. Perhaps the biggest sins are those of omission. The AdSense API is not mentioned, and the AdSense Calendar did not make the cut, either. However, as I write this review, these new features are only a few weeks old, so Davis can hardly be blamed.

Overall, Google Advertising Tools is a good book to get if you are an AdSense or AdWords user. There is a little bit of fluff, but keep your eyes open and you'll find some gems. Whether your ads are currently making money or not, this book might pay for itself in short order if you use it wisely.

Trent Lucier is a software engineer. His latest pet project is ChessUp.

You can purchase Google Advertising Tools from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

clndnng writes "Roughly 90% of web content consists of discussions of software patents, so it's a little surprising that Ben Klemens has written what may be the first dead-trees book analyzing their validity. It has a lot of ground to cover: you could approach the topic from the perspective of the geeks, the lawyers, the economists, or the businessmen. Klemens is equal-opportunity, addressing every perspective." Read the rest of the review. Math You Can't Use: Patents, Copyright and Software author Ben Klemens pages publisher Brookings Instituion Press rating 9/10 reviewer ISBN 0-8157-4942-2 summary Explains why patents don't make sense for software

The first question you are probably asking yourself is whether this book says anything that you haven't already read on Slashdot's pages. Barring any omniscient readers, the answer is probably yes, because the book covers so many different angles. You might already know what he will say about the Church-Turing Thesis, but you probably don't know the law of scènes à faire or contributory infringement. Slashdot chestnuts like Amazon.com's one-click patent and the SCO v IBM case make only passing appearances, leaving room for more interesting examples about Garbage Pail Kids and Banana Protective Devices.

Chapter two of the book gives a quick-and-dirty overview of the economic motivations for patent law. I should tell you that Ben Klemens and I were both students at Caltech's PhD program for Social Sciences, so I was half expecting him to whip out the infinite sequences of integrals over a Riemann manifold here. But he either didn't think the Greek relevant or chose to spare us mere mortals, because he keeps the theory pretty simple: patents are supposed to maximize the size of the market. If nobody is providing a good, patents should induce somebody to provide, but if many people are providing the good, then a good patent regime shouldn't diminish that number of providers to one.

You can see where this is going: patents on software are often not necessary to induce code-writing, and when they do exist they seriously diminish what could have been a crowded market. He ties this to finding the optimal breadth of a patent, because a too-broad patent gives the owner a cheap monopoly over a range that could have held a large number of competitors.

The next chapter is the computer science chapter. He goes into detail about how we go from transistors to instruction sets, which turns out to be important in the next chapter when patent examiners try to draw a line between the two. He also talks about how one could write up a symbol table to translate any given program into lambda calculus expressions, which are pure math by any definition of the term. If pure math isn't patentable, and a program can be translated into a pure mathematical expression, then where does the program get off being patentable?

Chapter four shows how U.S. law went from disallowing software patents to letting through patents on anything sort of techy-sounding. The first alibi by the courts is that code may be pure math, but a machine on which is programmed pure math is a physical device, just like a toaster. Klemens tries to address this via the discussion above about how the transistors are soldered on at the factory, but the programs coded onto them are just states on a state machine. He brings up the breadth problem above: a patent for an algorithm on any general-purpose computer is a patent of huge breadth.

The second alibi by the courts is that the application of an equation to a useful purpose is distinct from the equation itself. As tenuous as such a distinction is, it hasn't held, so there are now patents on the books for math applied to useful purposes like a "Method for performing complex fast Fourier transforms," a "Method of efficient gradient computation," and a "Cosine algorithm for relatively small angles."

That's the thrust of the theory that Klemens covers. Most of the rest of the book shows how software patents in the real world create problems. He cites interviews with venture capitalists by a University of Texas researcher in which they say that they just expect to be violating patents left and right in the normal course of business. He cites another set of researchers who surveyed technologists in a variety of fields, and found that companies in most fields mostly patent in order to protect their inventions, while computing companies are most likely to patent so they can game the system.

Klemens seems to be downplaying the role of open source in all of this. In Chapter 6, he points out that the U.S. software market is evenly split between software companies (32.6%), consultants (36.4%), and in-house software (31.0%). That is, most software isn't written by software companies, and some of that not-software-company software is OSS. It's the decentralization, not the openness, that matters. Patents have never been applied to a decentralized industry before, and they don't work there because independent invention is not a valid defense against claims of patent infringement, and independent invention is inevitable in such a decentralized industry.

Finally, the book covers copyright, which makes sense because if patents really are going to be thrown out, then coders will be relying on copyright more. For example, the GPL is based on copyright protection. The recommendation here is that copyright be aimed at detecting plagiarism anywhere along the line, so if you cut and paste my FORTRAN code and run it through f2c, your C code is still infringing my copyrights. He points out that software is uniquely well-suited to enforcing copyright all along the development process, because coders have backups and RCS repositories that poets don't keep.

Klemens's anti-software patent position happens to be the position I believed when I started reading, so I can't say that he changed my mind. But he did point out many arguments, stories, and facts that I hadn't known (or had misheard) beforehand.

Klemens covers a lot of ground in an ADD-friendly manner, and if you don't like one of his arguments against software patents, he has ten more for you to try out. For me, he made the injustice in software patents salient, and by the end of the book I wanted to find a machine to rage against—or to at least send my copy of the book to my Congressman. In fact, on the Brookings Institution website, Klemens suggests political action, because Congress has patent reforms in process that won't fix software patents without a push from the rest of us. Hopefully, this book will be a step in the right direction.

You can purchase Math You Can't Use: Patents, Copyright and Software from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Andre Carregal writes "In the second edition of Programming in Lua Roberto Ierusalimschy presents the Lua programming Language in a simple yet precise format for both novice and advanced programmers." Read the rest of Andre's review. Programming in Lua, 2nd Edition author Roberto Ierusalimschy pages 328 publisher Lua.Org; 2nd edition (March 5, 2006) rating 10 reviewer Andre Carregal ISBN 8590379825 summary Shows how Lua is the language of choice for anyone who needs a scripting language that is simple, efficient, extensible, portable, and free.

The Lua programming language has been around for more than 10 years, but only recently has it started to appear on the mainstream radar screens. It has evolved from a simple scripting language to a full-fledged solution for scripting and embedding. Lua is portable, fast and small, and the language of choice for applications as diverse as games, Web sites and robot controllers as the Lua Users Wiki and LuaForge will confirm.

Lua portability can be shown by the long list of operating systems it runs on, which includes not only Windows and Linux, but also small systems and mobile devices. The memory and CPU requirements for the runtime are really low, and Lua has been used in environments that most other scripting options would not dare go into.

One of the milestones of the history of Lua has been the release of the book Programming in Lua (a.k.a "PiL"), by Roberto Ierusalimschy, in 2003. This review is about the second edition of Programming in Lua, a.k.a. the "Blue PiL" due to the color of its cover.

Lua is free software and can be obtained from its site (www.lua.org). There you will also find the reference manual of the language and the full contents of the first edition of Programming in Lua.

As a disclaimer, let me say that I'm one of the technical reviewers of the book and I have been working with Lua since 1993, most of the time interacting with Roberto Ierusalimschy, even when not working in the same projects as him.

The second edition manages to surpass an already good book in various aspects. The "Blue PiL" presents not only the language itself, but also gives an excellent view of how one could see Lua as the foundation of solid scripting techniques. The original Programming in Lua was focused on Lua 5.0, while the second edition focuses on Lua 5.1. While the differences between Lua 5.0 and 5.1 are not radical, the newer version has a lot more to offer, both in terms of the modularity aspect and of language features. The second edition of Programming in Lua indicates clearly when some concept or detail relates only to a specific version of Lua, but most of the contents can be applied to both Lua versions.

Programming in Lua is oriented to both the novice programmer who wants to get a first feeling for Lua, and to the advanced Lua or C programmer who wants to use the full potential of the language. The book clearly separates the two aspects and indicates the sections that can be skipped for each reader profile. The author manages to keep a light and easily readable style during the whole book and the examples are simple and direct, making the flow of the reading quite pleasant. I can say that, even having some reasonable experience with Lua, I was surprised by a lot of details in the book. The "Blue PiL" is one of those books that you can read many times over, and each time you learn something new.

The "Blue PiL" starts with an overview of the Lua language and slowly evolves through the more advanced concepts and the features that make Lua such a unique language. Even though it's a relatively thin book, it goes from the starting concepts to the more sophisticated ones with a grace that is really rare to find. The one other book that comes to mind with an effect like this is the classical Structure and Interpretation of Computer Programs by Harold Abelson and Gerald Jay Sussman, which says a lot.

The first part of the book presents the language and the basic features. In particular, concepts such as iterators, coroutines and closures are presented in a clear way, which is no small feat considering that many readers will be having contact with such concepts for the first time.

One of the strong points of Lua is its simplicity, but don't assume that this implies lack of power. An example of this balance is the table data structure, in fact the only data structure for Lua. Tables allow the construction of every other data structure (arrays, sets, bags etc) but also allows the use of sophisticated techniques such as metamethods, function environments, modules and object orientation.

In fact, instead of providing every feature one might want to use, Lua provides the meta mechanisms so you can create your own features, or use them as modules created by third parties. In order to explain the full power of these meta mechanisms the second part of the book takes the reader from the basic steps of creating a table and shows how each of the mechanisms can add features or help the usage of some advanced concepts.

As an example, the chapter on object-oriented programming not only shows how to use objects in Lua, but also how to think of objects as prototypes for other objects, and how to implement inheritance on such a model without using anything too fancy.

There are also chapters on the use of metatables (basically tables that define the behavior of other tables), the use of tables as function environments (a really powerful mechanism once understood), modules and finally weak tables. Weak tables allow the advanced use of memory resources in an automatic way, providing mechanisms for data structures that tend to be hard to implement in other languages, if even possible at all.

This slow but efficient presentation of concepts that, though complex, can be easily assimilated by the reader is a predominant aspect of Roberto's work. He is not only a skilled author but also knows how to present things in a way that a novice can grasp and an expert can master.

The third part of Programming in Lua covers all the language libraries (math, table, string, system, debug and I/O) in clear prose and shows that even with a small set of libraries Lua can pack a lot of power on a very small footprint.

Finally, the last part of the book is directed to programmers that want to use Lua to its full potential. Lua can be used as an extension language or as an embedded language, and knowing how to interact with the host language (C, C++, Java, Delphi etc.) is mandatory for that. The book presents the C API for Lua in the same progressive pace, but also manages to cover every ground needed so one can add Lua to a project without much pain, if any.

One important thing to note about the book is that it follows the same philosophy that guides the language, showing that simplicity and lightness has nothing to do with lack of power or coverage.

I really recommend this book to anyone interested in learning Lua, and also for those who already know how to use Lua but would like to fully master its way of thinking, the so called "Lua way" of doing things. The book has been considered by many as an excellent guide on programming, even if one is not interested in Lua in particular."

You can purchase Programming in Lua, 2nd Edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Simon P. Chappell writes "Is there anyone left in our industry that hasn't heard of Ajax, the ultimate client-side technology for web developers? Like many, I've read several books on it and now I'm even brushing up on JavaScript so that I can try it out. There is, however, an aspect of Ajax that often seems to get lost in the rush to play with the new browser tricks; Ajax enhanced web applications still need to work closely with server-side components. To even up the balance of books that concentrate on the browser end of Ajax, Apress brings us Practical Ajax Projects with Java Technology by Frank W. Zammetti. Practical Ajax Projects with Java Technology author Frank W. Zammetti pages 504 (16 page index) publisher Apress rating 9 out of 10 reviewer Simon P. Chappell ISBN 1590596951 summary A useful and practical book for those wishing to write web applications that combine Ajax front-ends with Java technology on the server-side.

This is a book for anyone developing web applications with Java server-side components. It does assume a minimum level of Java ability, but not that you should know any specific frameworks. If you know basic Servlet and JavaServer Page programming, then you'll be fine for working your way through the frameworks presented in the book.

The book is divided into two parts. The first part is just three chapters and covers the principles of programming using Ajax and Java. Chapter one is the "hurrah for Ajax", obligatory examples and brainwashing. A discussion of the "classic web" and its problems leads into examples of the new web and Ajax enhanced websites. Chapter two is an introduction to the technologies behind Ajax for those who may be less familiar with JavaScript, the DOM, XML and parsing XML using JavaScript and Cascading Style Sheets (more usually known by its acronym CSS). Don't expect to learn these technologies from scratch out of this chapter, but if you have some amount of exposure to them, it will remind you of all the bits that you'll need for Ajax. Chapter three then does a similar thing for the server-side Java technologies. Again, if you snoozed through Java classes at school, don't expect this to get you caught up, but it will refresh your memory on the useful pieces.

The second part of the book holds the seven example projects. These are the meat of the book, given that the title promises practical projects and I think that the book pretty much delivers on its promise All seven projects are interesting; six are practical and the last one is just good old fashioned fun. The projects build in terms of size, so the first one is the simplest and the game, coming last is the most complex. The first project is a type-ahead suggestion engine, modeled after Google's Suggest. Next we have an Ajax-based webmail client. Chapter six builds a RSS newsfeed reader (because, as the book says, every Ajax book has to have one). Chapter seven is a photo sharing application, which, while it may not compete with Flickr, is quite usable for its size. Chapter eight is an organizer. Umm, needless to say you'll either love this or ignore it. (What can I say? If I was organized enough to use an organizer, I'd be organized enough not to need it!) Chapter nine brings yet another chat program to the world.

Last, but as the phrase goes, not least, chapter ten is the grand finale of the example projects. As befits the author's fine sense of humor, the final project is a game; Ajax Warrior! This application has graphics designed by a professional graphic artist and looks far above any other example application that I've ever seen.

As soon as I saw that Mr. Zammetti had written a book, I rushed to be the first to volunteer to review it. This will need no explanation to members of the Struts mailing list, but for the rest of you it might help if I explain that he is that wonderful combination of a funny and helpful guy. I knew that anything he wrote was going to be first rate technically and was also going to be written in a light and relaxed style; always a winner in this kind of book.

I liked the fact that Mr. Zammetti covers a number of approaches to writing both the client and server-sides of the applications. For the server-side of a number of the applications, he uses plain JavaServer Pages, yet for others he uses industry-leading frameworks including WebWork and Struts. On the client-side he continues to mix it up, with some applications using "naked" Ajax, others using DWR, AjaxTags from Java Web Parts, DWR, Dojo, JSON and Prototype.

One more thing to like about the book is that the applications actually look very nice and quite professional. Perhaps the folks at 37signals shouldn't be nervous, but Mr. Zammetti has certainly raised the bar for the appearance of example applications for books.

The flip side of the use of multiple frameworks and Ajax libraries is that all of the breadth means reduced depth. Each of the frameworks and libraries is introduced and demonstrated, but then just as it begins to get interesting, it's off to the next one. If you're looking for more depth in each introduced item, then this book may not be for you.

In conclusion, this is a useful and practical book for those wishing to write web applications that combine Ajax front-ends with Java technology on the server-side. Strongly recommended.

You can purchase Practical Ajax Projects with Java Technology from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "Experienced and conscientious Web developers, in their efforts to learn from the mistakes of others and to avoid repeating them on their own projects, tend to accumulate tips and recommendations for the many aspects of successfully creating Web sites. These best practices take the form of bookmarked Web pages, saved articles, downloaded PDF files, scribbled notes on scraps of paper, and hastily created documents that will be better organized one of these days, when the developer's schedule becomes less hectic (sure...). Being difficult if not impossible to find later, these pearls of wisdom are rarely consulted before or during each new Web site project. What the developer needs is a book that brings together as many of these best practices as possible, without being overwhelming. Deliver First Class Web Sites: 101 Essential Checklists may be the answer." Read the rest of Michael's review. Deliver First Class Web Sites author Shirley Kaiser pages 331 publisher SitePoint rating 8 reviewer Michael J. Ross ISBN 0975841904 summary A collection of Web site development best practices.

Authored by Shirley Kaiser, this book was published by SitePoint in July 2006, under the ISBN 0975841904. The publisher maintains a Web page devoted to the book, where visitors will find the book's table of contents online, a free preview (chapters 6, 12, and 14, in PDF format), editorial and customer reviews, a link to download all of the checklists (also in PDF) for all customers, links and an FAQ for ordering directly from SitePoint, and errata (none reported, as of this writing). The fact that SitePoint is willing to allow readers to post unmoderated comments and ratings of their books, suggests that it has real confidence in the quality of the book's material and readers' evaluations of it.

The aforesaid Web page also offers an online version of the index, but without any of the book's page numbers. At first glance, this might seem rather odd, but it does make some sense: Page numbers online would be of little use without the book itself, which of course already contains the index. Perhaps the index keys are offered to supplement the table of contents in helping the prospective customer learn what topics are covered in the book. In any case, this is the first time that I have seen a book's index online, and it will likely not be the last, if other publishers see the value in following suit.

In the preface, Shirley Kaiser explains that the book is intended to be "...a single source of solid information on best practices for everything from planning, designing, developing, and testing, to launching a web site and maintaining it in the long term. By compiling all this information into checklists, we've turned a vast wealth of detail into convenient, easy-to-scan, simple-to-use chunks organized by topic." A technical reader quickly scanning the book, would likely conclude that the author's goal has been achieved, because the book's 101 checklists comprise over 500 checkpoints, and almost all of them are expanded with at least a paragraph of more detailed explanation; many have accompanying code or images to illustrate the checkpoint.

The book's 331 pages of material are organized into 16 chapters, followed by an appendix that focuses on e-commerce advice. The topics covered in the chapters are: how to get started on a Web development project; planning the Web site with a client; assembling the site's content; managing that content; site usability; color schemes and functionality; information architecture; designing the site's navigation; W3C standards and recommendations; site accessibility; optimization of site performance; search engine optimization; design principles; site testing, including accessibility and usability; launch preparation and execution; post-launch follow-up and maintenance.

In terms of the specificity and usefulness of the checkpoints, they are not all consistently stellar, which arguably would have been an impossible expectation anyway. They range from the obvious (e.g., "Use consistent markup") to the not-so-obvious but equally valid (e.g., "Perform content audits"). Some of the checkpoints may on the surface appear mundane, but they could be a lifesaver further down the road, should a project turn sour (e.g., "Archive a copy of the handover package"). Some of them may seem painfully obvious to any decent developer (e.g., "Check all hyperlinks" and "Test all scripting functions"), but even the majority of those are violated on a daily basis, even by major Web sites, which have no excuse for such sloppiness.

The primary value of this book is how it neatly consolidates a considerable amount of worthy advice culled from the author's research and decade in the trenches of the Internet. The book probably will not replace all of the best practices that any top-notch developer will have assembled over the years — especially as none of it addresses advanced topics — but it could easily serve as a solid foundation upon which to add any supplemental recommendations that the book does not cover. Moreover, the book's material is presented in a fairly concise and quite readable format, making use of what appears to be a font slightly larger than is found in the typical computer programming book.

My only complaint with this title is the way that SitePoint continues to include a growing number of advertising pages, at the end of the book, with the bulk of each page black (sometimes even a bit smeared), and containing absolutely no details about the books being advertised. When SitePoint first began publishing books, if memory serves, they would only include one or two such over-the-top pages — possibly because they had so few titles to advertise at the inception. But now they are truly overdoing it. In Deliver First Class Web Sites: 101 Essential Checklists, no fewer than a dozen pages are wasted on this unwanted advertising. It would have been far more effective and efficient to simply list the 11 books' titles with a brief summary of each. Whoever decided to waste all that paper and ink, clearly did not read and understand some of the most basic checkpoints presented earlier in the book concerning type size and page content.

But overall, Deliver First Class Web Sites: 101 Essential Checklists is a much-needed book that brings together a wide range of valuable Web development best practices.

Michael J. Ross is a computer consultant, freelance writer, and the editor of PristinePlanet.com's free newsletter."

You can purchase Deliver First Class Web Sites from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ravi writes "Asynchronous Javascript And Xml, popularly known as Ajax, is a combination of Javascript, XML and some coding on the server side. Even though this technology existed for years, many believe it was Google which brought it to the front by implementing it on its sites and thus raising it to the cult status it enjoys now. There is something magical in seeing a website update its content without reloading the whole page, which is the visual essence of Ajax." Read the rest of Ravi's review. AJAX - Creating Web Pages with Asynchronous JavaScript and XML author Edmond Woychowsky pages 390 publisher Prentice Hall rating 9 reviewer Ravi ISBN 0-13-227267-9 summary A useful introductory book in picking up the skills in using Ajax

I found the book titled "AJAX — Creating web pages with Asynchronous JavaScript and XML" authored by Edmond Woychowsky to be a very good introductory level book on learning the basics of Ajax. Spanning 390 pages and 16 chapters, this book imparts a sound understanding of the basic features which make ajax possible.

The author starts by giving a brief introduction to the different types of web pages — static and dynamic, the tools and code used to serve them.

In the second chapter which is titled "Introducing Ajax", the author dives into the philosophy and principles of Ajax and with the aid of three simple examples explains three different ways of implementing ajax in a webpage. I found this chapter to clear some of the doubts that a newbie will have about the hype surrounding ajax.

The third chapter takes a step backwards in that it gives a birds eye view of all the XHTML elements and their associated attributes. The author also provides a table which lists the most commonly used CSS 1 elements. I found this chapter more of a ready reference than an indepth thesis on XHTML and CSS.

The fourth chapter titled "Javascript" provides a very good understanding of the language. Javascript plays an invaluable part in the greater scheme of the working of Ajax. Apart from the snippets of code and explanations, this chapter also has a number of tables listing things such as the essential JavaScript functions, characters used to create regular expressions, event handlers, Javascript operators and so on.

In the next chapter titled "Ajax Using HTML and JavaScript", the author explains how to use HTML, Javascript and stored procedures incorporated in the latest version of MySQL to create a semblance of an Ajax shopping cart. What is worth noting is that this chapter explains an old fashioned but very reliable technique which uses hidden frames and inline frames to update the data on the page. Of course the author is quick to point out that this technique is not really Ajax in the sense that it lacks the XML part.

I found the author's narration quite refreshing as he explains each concept one at a time with the aid of snippets of code, gradually building up and eventually tying all the threads together to write a true Ajax web application.

XML — eXtensible Markup Language is the successor of SGML — the language which powers HTML. XHTML on the other hand uses the XML schema. XML is a vast subject which can easily fit in a book of its own. Perhaps knowing this, and because XML plays a significant part in Ajax, the author has intelligently provided just the necessary information about XML in the sixth chapter.

The seventh chapter is a very important chapter which gives an indepth understanding of the XMLHttpRequest object which can be considered the brain behind Ajax. The author also provides some insights into the XML document object model, RSS and Web services such as SOAP.

In Chapter 8, the author gives a more indepth take on the XMLHttpRequest object and the other technologies explained in the previous chapter and illustrates by applying them in building a shopping cart application. Throughout the book, the author has highlighted the fact that ajax is a browser dependent technology and if people disable javascript in their browsers, then the whole effort will come to naught.

XPath is a technology which can be used to locate and navigate the various parts of an XML. The ninth chapter gives an introduction to the syntax used by XPath.

The next two chapters explain the concept of eXtensible Stylesheet Language for Transformations (XSLT) and how it can be used to implement Ajax. XSLT can be compared in some ways to CSS but is much more powerful and can be used to display pure XML in different styles targeting diverse media. These two chapters contain all the necessary details such as the syntatic reference and snippets of code which walks one through creating an Ajax application using XSLT.

In chapter 12, the author talks about the advantages of code reuse where creating javascript objects are explained. Surprisingly, there are two chapters on Ruby on Rails — the latest fad with the web developer community.

I found the book to be a valuable reference for upcoming Ajax web programmers. The number of tables listing the tags and their attributes itself will more than make up for the cost of the book. It has the right amount of content covering all pertinent topics without overwhelming the reader, which makes it a very good introductory book on Ajax.

Ravi Kumar is passionate about all things related to open source and free software and likes to share his thoughts and experiences related to these through his site "All about Linux".

You can purchase AJAX - Creating Web Pages with Asynchronous JavaScript and XML from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Simon P. Chappell writes "We've all seen them, those icons that decorate blogs and websites; sometimes they're just little orange squares with white stripes, while others say RSS or Atom. Many of us have heard of feeds and podcasts and aggregators. What are these things and where did they come from? Well, Dave Johnson, the author of the open source Roller blogging software, is glad you asked and by way of an answer, he's written RSS and Atom in Action." Read the rest of Simon's review. RSS and Atom in Action author Dave Johnson pages 368 (8 page index) publisher Manning rating 8 out of 10 reviewer Simon P. Chappell ISBN 1932394494 summary For blog applications, this book brings the right information at the right time.

This is a book for programmers that want to use blog technology rather than programmers that want to blog. A subtle difference perhaps, but it'll make the world of difference whether this book is useful for you. So if you want to be the next Paul Graham or Steve Yegge, pass over this book and concentrate on your copy of Strunk and White's The Elements of Style. For those of use who have a need for automated information distribution, where a blog or an aggregator or a podcast might make sense as the delivery channel, this book is the right information at the right time.

The book is organized in two parts. The first part is called "Programming the writable web". In it Mr. Johnson covers the "what" of blogging technologies. The first chapter covers the taxonomy of blogging terms and components. The second introduces us to the situations and characters that we'll be following through the rest of the book. Next we learn how to download, setup and run the example software available for the book. Chapter three takes us on a guided tour of the anatomy (Mr. Johnson's words) of blog and wiki servers and how to choose between them for your information distribution needs.

With all that level setting information out of the way, chapter four begins the process of rolling our sleeves up and getting geeky as we look at the RSS and Atom newsfeed formats. Now, we know what they are and what they look like, chapter five takes us through fetching and parsing those newsfeeds. Chapters six and seven show the use of the Windows RSS platform and the ROME newsfeeds utilities respectively. Chapter eight starts our journey to producing rather than just consuming newsfeeds. Chapters nine and ten then address publishing using XML-RPC based APIs and Atom.

Part two of the book addresses "Blog Apps", where a blog application seems to be fairly loosely defined as any application that interacts programmatically with a blog. The eleven chapters are fairly short, with part two totaling only about one third of the whole book. This works well, each chapter is very direct and doesn't waste any time getting into its subject matter. The subjects walk you through creating a group blog via aggregation, searching the blogsphere through services like Technorati, keeping your blog in sync, blogging by email, generating email digests, using a blog to report on software build processes, blogging chatroom conversations, distributing files as podcasts, how to automatically download podcasts, validating newsfeeds and then a whole wrap up chapter on interesting ideas that could be implemented using blog technologies.

When looking at things to like about this book, it doesn't hurt to have a forward written by Simon Phipps, the Chief Open Source Officer at Sun Microsystems and an endorsement from Tim Bray, co-creator of XML and Co-Chair of the IETF Atom Working Group. That got my attention.

The typography and layout of the book are up to the usual excellent standard of the "... in Action" series. Manning are to be commended for their dedication to enforcing the series style in their books, because a well-laid out and typeset book is a pleasure for the reader.

The examples in the book are written in a mix of Java and C#. This is interesting, because previously the majority of books have been dedicated to single platforms. Perhaps, this is a sign that the I.S. world is becoming more comfortable with the increasingly heterogeneous computing environments that we find ourselves surrounded by. Of course, it doesn't hurt that Java and C# share more similarities than differences, if I can say that without triggering visits from the attack lawyers at Sun or Microsoft.

Some of the lead-ins to the technologies use stories of folks at an imaginary company facing problems and overcoming them using blogging technology. You may find this a little too twee for your liking. I don't mind it, suspecting that it helps to give good context to the discussion, but you may not care for it.

Naturally, there is also the danger that the information may be outdated in a few years, but if you're in this industry that's just part of the package. I actually suspect that this book will be useful for quite a while, because while the activity of blogging is changing the world, the technologies behind it seem to be relatively stable at this time.

I like this book and I think that it brings the right information at the right time. If you want to work with blog technology, this book will give you a great deal of help. Now, get out there and publish!"

You can purchase RSS and Atom in Action from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ravi writes "It is a fact that GNU/Linux has grown from a hackers operating system to be a viable alternative to any commercial proprietary operating system. And the plethora of books on Linux that are being published underlines the popularity of this OS. There are hundreds of flavors of Linux distributions — some of them more popular than the others. Ubuntu Linux is one such distribution which has caught the fancy of many Linux enthusiasts and which enjoys the number one position in the popularity rating chart." Read the rest of Ravi's review. Ubuntu Linux for non-geeks author Rickford Grant pages 360 publisher No Starch Press rating 9 reviewer Ravi ISBN 1-59327-118-2 summary A very good book targeted at newbies for installing and configuring Ubuntu Linux

I recently came across a very nice book titled "Ubuntu Linux for non-geeks" authored by Rickford Grant and published by No Starch Press. What attracted me to this book was the obvious title which makes no bones about the fact that this book is targeted at non-geeks.

The book is divided into 18 chapters and 3 appendices spanning over 300 pages. The author starts the narration by imparting a good understanding of the history of Linux and the relationship between Ubuntu and Linux. In this chapter, the author clears a few doubts arising in a lay person's mind about Linux such as the difference between a distribution and an OS, the hardware requirements for running Ubuntu and so on.

In the past, I have seen Linux books using well over 50 pages just to explain the installation process but Ubuntu is famed for its simple 6 step installation. The next chapter is a very short one which gives a good illustrated explanation of the steps needed to boot Ubuntu using the latest version of Ubuntu live CD (included with the book) and install the OS on the hard disk.

The third chapter explores many common features of the Gnome desktop which is the default desktop in Ubuntu. Here the readers are introduced to different aspects of the desktop from the panels, the menus, the applets to the steps for customizing.

One thing I really like about this book is the obvious way in which each task is split into separate chapters. For example, you have a chapter explaining the file and disk management , a chapter which explains how to set up the network and log on to the internet, another for setting up your printer and scanner, still another explaining different ways of downloading and installing software and so on.

I especially liked the 8th chapter titled "Getting to know the Linux terminal and command line", where the author introduces the shell and a number of command line tools to the readers. What I found really interesting was that at the end of the chapter, the author walks you through installing and configuring so you get to try out all the commands introduced earlier.

In the 11th chapter, the author explains how to make the fonts on the Ubuntu machine look prettier and the steps needed to install different kinds of additional fonts such as Microsoft true type fonts.

Ubuntu Linux bundles with it a rich set of applications which more than meets the need of an average home user. The 13th and 14th chapter introduces some of the most popular ones such as office suites, image viewers and so on.

The next three chapters deal exclusively in setting up and configuring audio and video in Ubuntu. Considering that some of the audio/video formats are patented, it is not possible to include support for them by default in Linux. Rather, it is up to the user to get these proprietary audio and video formats to work in Linux. And through these chapters, the author explains all that needs to be done to get all audio and video formats to work in Ubuntu.

The appendix also contain a section where the author gives a list of web resources where one can find more information related to Linux — more specifically Ubuntu Linux.

This very nice book on Ubuntu Linux is clearly targeted at the neophytes who wish to take their first steps in installing and using Ubuntu. The author explains in a step-by-step manner the solutions to the problems that one might face in installing, configuring and using Ubuntu Linux.

If you are a person who has installed and used Linux in the past, this book probably doesn't cover anything new to you. Having said that, it could be an ideal gift for your grandparents, parents or even friends who wish to learn to setup and use Linux. Another positive aspect of the book which attracted me was that the narration was surprisingly devoid of any slang. One of the common mistakes that authors make when writing a book targeted at newbies is treating them like idiots and introducing a lot of slang in the narration, but Rickford Grant has stayed clear of this and his language is clear and lucid.

Ravi Kumar is a Linux enthusiast who likes to share his thoughts on all things related to GNU/Linux through his blog All about Linux.

You can purchase Ubuntu Linux for non-geeks from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page

Trent Lucier writes "Why Software Sucks professes to be a book for computer users, not programmers. Author David Platt wants to be the informant, pulling back the curtain on software development so mere mortals can get a glimpse inside the sausage factory. Platt flaunts his geek cred, all the while implying that he's not one of those geeks. But ultimately, trite observations and a condescending tone left me wishing that the book would end long before it did." Read the rest of Trent's review. Why Software Sucks...And What You Can Do About It author David S. Platt pages 272 publisher Addison-Wesley Professional rating 5/10 reviewer Trent Lucier ISBN 0321466756 summary Explains to non-tech people why software quality is so bad.

The spectrum of what constitutes bad software is mostly limited to usability, security, and stability. No mention is made of supremely sucky software features like digital rights management, spyware from "reputable" companies, and bundled bloatware. There is plenty of information about these topics that the general public could benefit from, but none is to be found here. To his credit, Platt does mention annoyances like "free registration required" news sites and privacy issues.

The chapters focusing on software shortcomings all have a similar structure. The problem is put into historical context, a reason is posed about why the problem still exists, and readers are given advice on how to fix it. The insights into the world of software development are limited and stereotypical. In Platt's world, programmers are ego-driven, awkward geeks who only care about creating whiz-bang features at the expense of usability and usefulness. They're elitist and lazy, passing off responsibility to the user via confirmation dialogs and convoluted options menus. They go to tech conferences and pay more attention to the amazingly realistic software rendering of a bikini babe as opposed to talking to the real woman standing right next to them.

Of course, stereotypes are often true for a subset of any population. But Platt's characterizations are shrill and condescending, often reading like they were co-written by Comic Book Guy and Ann Coulter. Little mention is made of anyone else in the development process besides programmers. (Because, you know, in the history of the world, a marketing manager has never had a bad influence on a product. Nope, never happened).

Usability labs are cited as a great way to improve product quality. Great, but who is in charge of funding usability labs? Not programmers. Most programmers I know would love to have their product improved upon with usability testing. And by the way, if you think the previous sentence lacked supporting evidence, get used to it, because that's the level of research that is found (or not found) throughout Why Software Sucks.

The examples are typically shopworn (Yes, the Google homepage is simple and easy to use. We get it. Lord Jesus, we get it.) or trivial. UPS.com is constantly scorned throughout the book because it asks the user for their home country instead of detecting it via the user's IP address. Starbucks.com commits the deadly sin of defaulting to a 5-mile radius for it's store locater instead of just listing closest stores. Yes, these are annoying faults, but are they really the best cases out there?

Readers are given advice on how to improve software quality, and it all boils down to boycotting bad products, sending letters to companies, and spreading the word among friends. If you need more firepower, you're out of luck. How can I get my employer to use better software products? Or my local government? Can I leverage accessibility and usability laws in the fight against bad websites? Are those crickets I hear?

In the second half of the book, Platt takes a turn towards sociology and tries to explain the environments that geeks gravitate to. His prime example is the Microsoft Tech Ed conference, which, given the way he describes it, doesn't sound very different from any other kind of conference. Marketing bozos, gratuitous tschotchkes, after-hours drinking by the speakers...it could just as easily be the annual gathering of the Coffin Retailers of America.

Platt has mastered the art of the non sequitur. Theorizing that maybe the problem with software is that the field is too male dominated, we are told that, "Many people think that the recent child molestation and cover-up scandals in the Catholic church stem at least in part from the hierarchy's all-male culture." Gotta love those "many people" and what they think might "in part" be a cause of a problem. "Like Israel, Microsoft is finding out that being on top isn't quite as much fun as it looked like it would be when it was on the bottom." Does that make Apple the PLO? My favorite example is when Platt draws inspiration from How To Win Friends and Influence People. "Dale Carnegie lists rules #7 for making your home life happier as 'Read a good book on the sexual side of marriage'." I had to re-read the enclosing paragraph several times before I realized that Platt's advice was basically, "Read new books."

The biggest problem with the book is that it just feels lazy. Platt constantly references other authors that write better and have more insight into the topics he covers. Bruce Schneier. Vincent Flanders. Eric Sink. It's like watching a bad documentary about sci-fi movies, and constantly getting tortured with short clips from Star Wars, The Matrix, and Blade Runner. At a certain point, you just want to throw the damn thing down and go straight to the source material.

Sometimes, Platt saves you the time and quotes the source material wholesale, as in his section on Po Bronson's spoof "The Seven Habits of Highly Engineered People." Each entry is listed, and Platt explains it all to the reader. As I read this chapter, the introduction to Strauss's "Thus Spake Zarathustra" began to play in my mind. I slowly looked toward the sky as I realized that, yes, if this is what it takes, then maybe I, too, could write a book.

Platt invites readers to join his software quality movement and devise some type of "software seal of quality". The accompanying website, suckbusters.com, is clearly unfinished, so I cannot be too critical of it. However, it's hard for me to resist mentioning that a site about sucky software appears to be written in FrontPage and uses frames.

Is there anything in the book worth recommending? For a seasoned software developer, no. If you want a mature analysis of why software is hard to develop, read Brooks' The Mythical Man-Month or Demarco & Lister's Peopleware. If writing human-usable programs is hard for you, check out the writings of Steve Krug or Jakob Nielsen.

But what about non-technical users? Will they learn why software sucks? I keep trying to imagine someone having an intelligent discussion about bad software after reading this book. I can't. They will probably have the courage to say "software sucks". But these days, who needs to read a 272-page book to realize that?"

You can purchase Why Software Sucks...And What You Can Do About It from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Carla Schroder writes "IPv6 is halfway here, so network administrators need to learn their way around it whether they want to or not. Adoption has been slower in the United States because we possess the lion's share of IPv4 addresses, but even so, someday IPv4 is going away for good. And, there is more to it than just increasing the pool of available addresses. IPv6 has enough improvements over IPv4 to make it worth the change even if we weren't running out of IPV4 addresses, such as built-in IPSec, simplified routing and administration, and scalability that IPv4 simply can't support. We're moving into gigabyte and multi-gigabyte backbones, and high-demand real-time services like voice-over-IP and streaming audio and video that require sophisticated QoS (quality of service) and bandwidth prioritization. IPv6 can handle these, IPv4 can't." Read on for the rest of Carla's review. IPv6 Essentials, 2nd Edition author Silvia Hagen pages 436 publisher O'Reilly Media, Inc. rating 10 reviewer Carla Schroder ISBN 0-596-10058-2 summary practical, in-depth guide to implementing and administering IPv6

IPv6 Essentials, 2nd edition, by Silvia Hagen, released in May 2006, is a well-written, clear, up-to-date guide to understanding IPv6 in-depth. This is a real accomplishment, because computer networking protocols are completely abstract, and translating all of these abstractions into understandable language is a noteworthy feat. The book explains how it all works to a very practical depth, so that the reader will be well-prepared to begin implementation.

What it does not cover is the specifics of configuring network devices, such as routers, switches, and interface cards, and this is not a flaw, because those things are platform- and vendor-dependent. Having a solid understanding of the protocol itself is more important, and something that is sadly lacking even in today's IPv4 world. The Internet would be a better place if more network admins would take the time to learn IP fundamentals.

Ms. Hagen does a nice job of covering the following topics: Strengths and advantages, such as auto-configuration, and good-bye to NAT, The structure of the protocol itself, including header format, Improved security, Real genuine QoS, Simplified routing, Co-existence with IPv4, Painless mobile networking, and Addressing. Addressing is one of the scariest parts. When you're used to slinging around something like 192.168.1.100 with ease, coming eye-to-eye with something like this, 3ffe:ffff:1001:0000:2300:6eff:fe04:d9ff, is a bit disconcerting.

But fear not, for Ms. Hagen dissects IPv6 addresses clearly and in detail, showing that they have a logical, consistent, understandable structure. For example, the first quad (3ffe) tells you that this is a 6bone.net address, so it is already obsolete because the 6bone closed down in June 2006. Other prefixes tell you if it is a private address, link-local, site-local, and so on. The book lays this all out in tables, and explains what each one is for.

How would you like to retire your DHCP servers permanently? No problem. IPv6 auto-configures hosts all by itself, or you may exercise as much control as you like. Ms. Hagen explains the various options- link-local, site-local, stateful, stateless, neighbor discovery, and so forth, and what you can do with them. For example, with IPv6 you can whip up an ad-hoc LAN with hardly any effort, and without needing special servers or client software.

Security is built-in to IPv6, instead of bolted-on as it is for IPv4. However, IPSec (IP Security) is still largely untested and unproven on a number of levels, so the book discusses both the pros and cons.

The book covers the problems, hassles, and compromises that come with using NAT (network address translation). We're used to it now, but sometime down the road we're going to look back and think "Wow, that was one big fat pain. Good thing it's gone."

The chapter on Mobile IPv6 is almost worth the price of the book by itself. IPv6 supports both wired and wireless mobile users in an elegant, hassle-free way. Say good-bye to setting up multiple profiles, or hassling with scripts. Roaming users can keep the same IP as they travel — across different networks, wired to wireless- anywhere they go. This little bit of magic occurs because IPv6 assigns them multiple IPs. One is the home address, which is permanent. A second address is the care-of address, which changes as the user moves around. Of course there is a lot more to it that just having multiple addresses, and like everything else in this book, Ms. Hagen explains how it works clearly and understandably.

The book is abundantly illustrated in the usual quality O'Reilly fashion, and the illustrations are invaluable for understanding the material.

We're at the stage where IPv6 support is pretty much universal- you can count on both network hardware and software supporting it. So the network administrator only needs to focus on learning the ins and outs of implementation. I recommend IPv6 Essentials as an essential reference, and a great starting point for mastering IPv6.

You can purchase IPv6 Essentials, 2nd Edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ben Rothke writes "Mark Osborne doesn't like auditors. In fact, after reading this book, one gets the feeling he despises them. Perhaps he should have titled this book 'How I learned to stop worrying and hate auditors'. Of course, that is not the main theme of How to Cheat at Managing Information Security, but Osborne never hides his feeling about auditors, which is not necessarily a bad thing. In fact, the auditor jokes start in the preface, and continue throughout the book." Read the rest of Ben's review. How to Cheat at Managing Information Security author Mark Osborne pages 302 publisher Syngres rating 8 reviewer Ben Rothke ISBN 1597491101 summary The adventures of an information security professional and his efforts to secure corporate networks

The subtitle of the book is 'Straight talk from the loud-fat-bloke who protected Buckingham Palace and ran KPMG's security practice'. Essentially, the book is Osborne's reminiscence of his years in information security; including the good, the bad, and more often then not, the ugly.

The book is written for someone looking to develop an information security program, or strengthen an existing program, to ensure that all of the critical technology areas are covered.

The thirteen chapters of the book cover the main topics that an information security manager needs to know to do their job. The author candidly notes that this book is not the most comprehensive security book ever written, but contains most of the things a security manager needs to get their job done. The author also observes that information security is different from other disciplines in that there are many good books about disconnected subjects. The challenge is getting the breadth of knowledge across these many areas, which is quite difficult. The challenge of information security is to effectively operate across these many areas.

Chapters 1 and 2 deal with the information security organization as a whole, and the need for information security policy. Chapter 1 details the various areas where a security group should be placed, and describes the pros and cons of each scenario. As one of the scenarios which place information security below the head of audit, Osborne notes that 'if you have any sort of life, you don't want to spend it with the auditors, I promise you'.

Wherever the security group is placed in an organization, its ultimate success or failure is likely to be determined by its level of autonomy and independence. Unfortunately, in far too many organizations, information security is not given that liberty. It is often placed in a subservient role to groups with opposing interests. Any security group or security manager placed in such a situation should likely start working on their resume.

The scenario is described in 'Practical Unix and Internet Security' where author Professor Gene Spafford spells out Spaf's first principle of security administration. This principle states that 'if you have responsibility for security but have no authority to set rules or punish violators, your own role in the organization is to take the blame when something big goes wrong'. Spaf's principle is a cruel reality faced by many of those responsible for information security.

Between those chapters and a few more auditor jokes, Osborne makes the blatently obvious observation that wherever possible, one should eradicate single points of failure. As a corollary to this, Osborne notes that while trying to eliminate these failure points, companies will often build redundant systems. Part of their admiration for these redundant systems is the hope that this will simultaneously reduce performance bottlenecks. But these companies do not realize that the routers, firewalls and switches are not the bottleneck, rather it is the software application which is the bottleneck.

Osborne plays the role of contrarian in chapter 8 when he asks why we need firewalls. He notes that if every database maker, operating system programmer and CRM/ERM vendor put as much effort into security as the firewall vendors do, then there would be no need for firewalls. Furthermore, if each system administrator worked as hard on security as the typical firewall administrator did, and devoted as much time to hardening their servers and laptops as they did; then centralized firewalls would likely not be needed. Given that the firewall-free reality is not happening any time soon, chapter 8 provides a lot of good information on everything you need to know about firewalls.

Chapter 9 is about one of the most maligned security tools, the IDS. After providing an anecdote about a network manager who did not understand the fundamentals of how DHCP operates, and how he used Snort to debug the problem; Osborne provides a meaningful piece of security wisdom when he notes that IDS can help any network or security person understand network traffic. These devices can even give you information on new attacks and how they can be mitigated. But for an IDS (or any security hardware or software device for that matter) to be truly useful, a security professional needs to understand their IT infrastructure, the mechanics of networks and applications and the risks involved. Those who don't understand those three things will only be able to use these security technologies with minimal benefit.

Overall, How to Cheat at Managing Information Security, is an informative and often entertaining introduction to information security. For those that want to get a good overview of the core elements of information security, or strengthen their existing knowledge base, they will find this book to be an informative and valuable read."

You can purchase How to Cheat at Managing Information Security from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ben Rothke writes "In an important new book Brave New Ballot: The Battle to Safeguard Democracy in the Age of Electronic Voting, Avi Rubin writes 'too often in American life, when it comes to divisive issues, the facts can be less important than the weight of public opinion'. That basically sums up Rubin's story in this fascinating story of his frustrations in dealing with government and corporate officials in his quest to show that e-voting was not as secure as it was originally made out to be." Read the rest of Ben's review. Brave New Ballot: The Battle to Safeguard Democracy in the Age of Electronic Voting author Aviel Rubin pages 272 publisher Morgan Road Books rating 10 reviewer Ben Rothke ISBN 0767922107 summary Electronic voting systems are being deployed with inadequate levels of trust and security

Brave New Ballot (BNB) is Rubin's story of how in 2003, he and his graduate students at Johns Hopkins University demonstrated that the Diebold Election Systems electronic voting technology in wide use was full of security problems. It was just in 2002 that Sherron Watkins of Enron was named Time magazine person of the year for her work in uncovering fraud at Enron. It would have been thought that Rubin's work would have immediately won him some sort of patriot of the year award for his work.

While the accolades were indeed many, his team's research was maligned as being that of a homework assignment, and the Administrator for Elections for the state of Maryland (where Rubin lives and works) publicly stated that 'computer scientists (a direct reference to Rubin and his team) who question the security of electronic voting machines are undermining our democracy.' Such a scenario makes up much of the story that the book tells in Rubin's team's efforts to blow the whistle on unsecure e-voting machines.

As to the Administrator for Elections for the state of Maryland and her disdain for computer scientists, she would likely find constituents such as the zombie-like Stepford wives more to her liking. Unfortunately, she ended up with Professor Rubin.

It is not that secure electronic voting is inherently unattainable. Rather, nearly all of the commercial solutions that have shipped to date have not been adequate designed with security in mind. This is due to many factors, some of which are that the makers of these devices do not completely understand the security risks and countermeasures, in addition to public officials who are far too trusting of these commercial e-voting vendors.

The early chapters of the book detail how Rubin's team analyzed the security and cryptography used within extremely sloppy coding of the Diebold Accuvote-TS director recording electronic device. One particularly humorous incident is when the Diebold programmers reference Bruce Schneier's Applied Cryptography in their C++ code for their decision of which algorithm to use of a for pseudorandom number generation. The only problem is that Applied Cryptography states that the specific algorithm they used should specifically not be utilized for random number generation. Rubin comically states about that incident that Diebold should have consulted with Schneier, rather than have their staff misunderstand what they read in his book.

I had a similar frustrating incident when consulting on an e-voting systems some years ago. The lead developer (who obviously was no expert in cryptography) documented that the e-voting system used 120-bit encryption. Upon analysis, we found that the system was using 40-bit encryption. When countered about that, the developer replied that they perform the 40-bit encryption routine three times using the same key, for an effective 120-bit key length. Of course, 40-bit encryption will always be (insecure) 40-bit encryption, no matter how many iterations he put it through; but it is frightening that he did not know that.

After his team presented their report in 2003, Rubin writes in detail how Diebold started a smear campaign against him. Not only was it Diebold, but also election officials in municipalities that had deployed the Accuvote-TS system that also maligned Rubin. This was done primarily by misinterpreting his objections, and also by refusing to pay attention to other independent reports on the insecurity of the devices.

For a more timely and somewhat humorous account of how insecure Diebold really is, see 'Hotel Minibar Key Opens Diebold Voting Machines'.

Being a whistle-blower always takes a toll on a person and Rubin was no different. He work on e-voting consumed him and took a toll on his family, career and his students. The book chronicles how Rubin found himself caught in a crossfire between big business, partisan politics, and overworked election officials. Rubin also found himself between the crosshairs of the ITAA (Information Technology Association of America), powerful vendor-based lobbying group. The ITAA, of which Diebold was a client, attempted to discredit him on many occasions, but their evidence was always weak and reckless, and in the end only served to bolster Rubin's claims against the Diebold systems.

Part of the absurd claims of the ITAA was that the open-source movement is using the issue of e-voting security to wage a 'religious war' that pits open-source software against proprietary software. Rubin could have filed chapters with similar ITAA absurdities, but wisely chose not to.

Similarly, an article I wrote 'E-Voting: It's Security, Stupid' also was the recipient of the wrathful ITAA reply. In their so-called rebuttal mistakenly titled 'E-Voting Does Work', Harris Miller of the ITAA follows his modus operandi of first attacking the person, avoiding the issue, stating vague meaningless comments, and concluding the issue by missing the point.

99% of the voting public does not know about backdoors, insecure code, Trojan Horses, insider threats, and scores of other security issues that the e-voting vendors have yet failed to fully address. The election process as we know it is rapidly being migrated to these electronic voting machines that are replacing the older, but more reliable mechanical systems.

BNB is a timely and important book as it details the very real defects on which these e-voting systems are built on (and Windows is only one of them). The ITAA made claims such that the only vulnerability within e-voting is that of a rogue programmer conspiring to steal public office. Such politicking only serves to confuse the issue for a public that is inherently trustful of these voting machines. Yet if these e-voting machines were built to the same stringencies and regulations that the aviation and pharmaceutical industry faces, they would never make it within a mile of a voting booth.

Brave New Ballot is to e-voting what Rachel Carson's Silent Spring is to the global environmental movement. It is a vitally important book that details the problem of e-voting and what can be done in the future to make certain that it can one day be carried out in a secure manner.

Of course, the image of an embedded crypto key or plaintext password in an e-voting system does not convey the same impact on the public as that of a thalidomide baby. Pictures of thalidomide babies caused heads to roll at the FDA, and one should hope the that the publication of Brave New Ballot will awaken the public from their slumber on the topic of electronic voting, and encourage the Election Assistance Commission to immediately ban electronic voting until it can be secured.

Deforest Soaries, the first Chairman of the United States Election Assistance Commission sums it up best when he states 'If the integrity of our sacred right of voting is less important than partisan politics, corporate interests, or bureaucratic systems, then shame on us for presenting ourselves as the global standard bearers of democracy. As Brave New Ballot shows, there is a lot of shame going around.

You can purchase Brave New Ballot: The Battle to Safeguard Democracy in the Age of Electronic Voting from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Simon P. Chappell writes "Classics are funny things, especially in the world of books. There are books that people say "should' be classics (I'll refrain from mentioning names to protect the pretentious) and then there are books that people are too busy actually using to get around to listing as classics. Mastering Regular Expressions, now in it's third edition, is in the second group. It's one of those books that you see on desks in computer departments the world over. This is a real "doers" book." Read the rest of Simon's review. Mastering Regular Expressions author Jeffrey E.F. Friedl pages 515 (31 page index) publisher O'Reilly rating 11 out of 10 reviewer Simon P. Chappell ISBN 0596528124 summary A classic of modern computer literature.

This is a book for programmers; managers, project managers and architects need not apply. If you talk about code instead of writing it and have teams of programmers report to you, then consider buying this book and giving it to them. If you're a technical lead or lead programmer, then shame on you if an earlier edition of this book isn't already on your shelves! The majority of examples are written using Perl, but if you can read basic Perl (Pidgin Perl, perhaps?) then you'll be fine with the examples. Programmers in PHP, Java, .NET and Ruby also have dedicated sections of the book, so it's very inclusive and almost platform agnostic.

The book has ten chapters divided into two parts. Chapters one through six are what Mr. Friedl calls the "story" of regular expressions. Chapters seven through ten are an examination of the specific regular expression capabilities of Perl, Java, .NET and PHP.

Chapter one is an introduction to regular expressions. At only 33 pages, you might think that it would be shallow, but rather, it is knowledge dense. The examples in the first chapter use egrep extensively. This makes a lot of sense as it's an advanced tool, easy to use and freely available for most modern operating systems.

Chapter two builds on this introduction with extended introductory examples. These are written in Perl (again, simple and easy to follow), but there is no doubt that the regular expressions are the stars of the show around here. The examples are small Perl programs, but their benefit is that Mr. Friedl talks the reader through the process of creating each of them. This is more useful than just presenting example programs, because with just pure examples, you are out of luck if your specific problem is not covered. With this approach, you're coached towards thinking in regular expressions and are more equipped to address your personal regular expression needs.

Chapter three provides an overview of regular expression features and flavors. It starts with a historical view of the development of regular expressions, including a few asides about the influence that the earlier versions of the book have had on that development. After that, the chapter uses a search and replace example to demonstrate some of the differences between flavors of regular expression capabilities provided by different programming languages. Strings, Unicode and metacharacters round out this overview.

Strap yourself in for chapter four; it's time to talk about the computer science that makes all of that matching work. If you didn't know the difference between an NFA and a DFA regular expression engine before you start this chapter, you most certainly will by the end of it. At first sight, it might seem that this is chapter for the pure propeller heads amongst us. While there is much theory here, it's all presented in the light of how your regular expression engine is trying to do what you asked. By understanding the approaches to regular expression processing, we can learn to help ourselves. We help ourselves when we write regular expressions that run faster and use less memory. We write better regular expressions when we understand the consequences of what we write. For example, the oft written ".*" (dot star) seems like a great way to ignore a bunch of stuff in the middle of an expression, but such simplistic use is just waiting to bite you. This chapter explains why and how to deal with the situations where you'd be tempted to use simplistic expressions and how just a little extra thought can bring you the behavior you want.

Chapter five is a practical counterpoint to the previous theory chapter. Here, Mr. Friedl discusses practical regular expression techniques. There are a number of short examples, before he works through medium sized HTML processing examples and finished up with a look at processing Comma Separated Value (CSV) data.

Chapter six is efficiency. Your regular expression can be as correct as you like, but if it takes what seems like eternity to run, then it's of little use. This chapter mostly addresses NFA based engines, because they have the greatest variability based on how the regular expression is written.

Chapters seven through ten cover the specifics of using regular expressions in Perl, Java, .NET and PHP. They're well written and cover everything you need to apply the content of the first six chapters to your programming language of choice.

Everything about this book is great. This is the kind of book that O'Reilly built its reputation with. A master of the subject matter, writing in a clear, easily understood manner, leaving the reader educated and able to operate comfortably with the subject matter. I may not be a regular expression guru, but I feel that I have a much better grasp of the fundamentals that I would need if I did want to be such a guru.

Mr. Friedl is to be commended for his clear explanations of what is, in all reality, much more complex computer science than many of us are used to dealing with. The fact that his explanations are highly readable and enjoyable is a significant bonus.

There is a website for the book, regex.info and a blog at regex.info/blog, where Mr. Friedl has some wonderful photographs of Japanese gardens with their autumn colors. (Nothing to do with regular expressions, but they appealed to my inner photographer.)

Lastly, while the book is not intended to be an encyclopedia of regular expressions, all of the examples are very relevant to programmers needs and this book can easily serve that reference role.

At the risk of sounding like some kind of O'Reilly shill or a relative of Mr. Friedl, I must report that I don't think that I found a single thing I didn't like about this book.

This is a classic of the first order. Nail it to your desk unless you want to be constantly retrieving it from your co-workers. If I might be permitted a Spinal Tap reference, this one goes to eleven. If you ever use regular expressions, are thinking of using regular expressions or are in the same room as a regular expression, then you need this book.

You can purchase Mastering Regular Expressions from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

peterwayner writes "There are few corners of the world that are more closely associated with the word "nerd" than comic books and physics. Despite the large overlap in the fan base, the two disciplines seem doomed to live forever in different corners of our minds. Superheroes don't have to obey the laws of physics and that's probably what makes them so attractive to the poor physicists who labor long and hard in the hope of making those laws work correctly. James Kakalios, a physics professor at the University of Minnesota, has produced a book, "The Physics of Superheroes" (now in paperback). The surprise is that the two don't behave like matter and anti-matter. They don't explode on contact." Read the rest of Peter's review. The Physics of Superheroes author James Kakilios pages 340 publisher Gotham Books rating 9 reviewer Peter Wayner ISBN 1-59240242-9 summary Why superman isn't as far fetched as it may seem.

There's no reason to spoil the book. You'll have to read it if you want to know why Superman can't change history, how Magneto becomes Electro when he runs, and whether Spiderman could really do those amazing things with spider silk. Some of the chapters are devoted to celebrating the accuracy of the comic strips by working through the physical equations. Much of what the comic book writers imagined is actually pretty reasonable. These sections bring new discipline to those old debates over who's stronger, bigger or most capable.

Other sections spell out just how wrong some of the assumptions are. Even when he's deflating the hopes of those kids who wish they could fly like Superman, he uses the disconnection with reality as a chance to riff on some what-if questions. What if Superman came from a planet that had a gravitational field 15 times stronger than earth? Would he be able to leap tall buildings? And then what would happen to a planet that was 15 times denser than earth? Would it fly apart as it rotated? Could you build one by just making a bigger version of Earth? What if you put some superdense material in the center of your new Earth? These are the questions that Kakalios works through.

The core theorem or narrative device of the book (choose your point of view) is that comic book authors can't bend too many rules. In fact, they usually can't get away with breaking more one or two. Then the hero must live a conventional life in our world and that's what makes it interesting. Spiderman may have a superstrong webbing, but he's still as vulnerable to depression as the next man. Batman may have unlimited wealth, but that won't bring back his parents. To paraphrase Robert Frost, comic book authors aren't playing tennis without a net.

In this world, science and comic narrative aren't bizarro versions of each other. Stories are sort of like free-form experiments where the scientist tries to change just one thing and measure the results. From this viewpoint, there's little difference between the two disciplines. A comic book is just a shorthand version of a scientific experiment.

This link implies an interesting and perhaps dangerous notion: science is just a longhand version of comic books. Sure, the folks at the cell phone companies have been striving mightily to make real that button on James T. Kirk's chest. That's the good news. But what about the darker notions? Anyone who's dealt with the side-effects of supposedly safe drugs like Vioxx knows that the bench scientists are as constrained as the comic book authors. They've got to come up with research that satisfies their customers and provide a simple resolution before that customer loses interest. (And won't those scientists come up with an ending for the debate about the link between cell phone-brain cancer before a jury does?)

But such speculation may kill the fun in the book. It's really just an excuse to toss around some equations and ask "what if" with a bit more rigor. This book may not be a grand, unifying theorem for the big plots of comic books and the big theories of science, but it's a neat first cut. It's as fascinating as much for its nuts and bolts description of physics as its offhand way of mixing together mathematical frameworks with narrative understanding.

Bio: Peter Wayner is the author of 13 books like Translucent Databases and Disappearing Cryptography .

You can purchase The Physics of Superheroes from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "Ever since Cascading Style Sheets (CSS) first appeared on the Web scene in the late 1990s, a plethora of books have been written and published that purport to explain how CSS works, and how to make it work for you. So why would any publisher decide that what the technical world needs is yet another CSS book? Perhaps because they have taken a close look at the bulk of those available titles, and found them to be wanting — filled with overly theoretical explanations and sample code that is far too focused on some pet domain of the author. Such books may be adequate for the veteran Web developer, who has the time and inclination to separate the wheat from the chaff. But developers new to CSS need much more approachable material, with clear examples. Perhaps that is the thinking behind CSS: The Missing Manual." Read the rest of Michael's review. CSS: The Missing Manual author David Sawyer McFarland pages 494 publisher O'Reilly Media rating 7 reviewer Michael J. Ross ISBN 0596526873 summary An accessible guide to using CSS with HTML.

Written by David Sawyer McFarland, CSS: The Missing Manual is published by O'Reilly Media, as part of their Pogue Press series, under the ISBN 0596526873. It first came out in August of 2006. The publisher maintains a Web page for the book, where visitors can find a link to register their copy of the book (does anyone do that?), a page for submitting errata (none yet, as of this writing), a form for posting a review on the O'Reilly site (again, be the first!), and a sample chapter (Chapter 1: Rethinking HTML for CSS) as a PDF file. There are also links for purchasing the book in the U.S. or the UK, and for reading the online version, as a part of O'Reilly's Safari service.

The book's 494 pages are organized into 14 chapters and three appendices, grouped into five parts. In addition, there is an index, as well as a terse but meaty introduction, which even includes a summary of HTML. The humor for which the Missing Manual books are known, begins early, in introduction, though in this case probably not intentionally: Page 9 claims that the book "is divided into four parts," and then lists the five parts. Before commenting upon those five-ish four parts, it should be noted that the table of contents runs seven pages, listing the book's parts, chapters, sections, and subsections. Future editions of the book would benefit from an overview table of contents, similar to those used in an increasing number of technical books, to good effect.

The 14 chapters cover most if not all of the essentials: writing HTML for CSS; creating styles and style sheets; determining what to style; using inheritance; using cascading; formatting text; setting margins, padding, and borders; styling graphics; styling links and navigation bars; styling tables and forms; creating float-based layouts; positioning page elements; creating print stylesheets; and writing maintainable CSS code. The three appendices include a CSS property reference, a discussion of CSS use in Dreamweaver version 8, and a listing of CSS resources to supplement the book.

On the positive side of the ledger, the author does a commendable job of clearly explaining all of the essential topics that the typical developer would need to understand in order to begin developing a robust Web site based on HTML and CSS, or reworking an existing site that is in desperate need of an overhaul. The clear explanations and bite-sized examples demonstrate that David Sawyer McFarland is not only an experienced Web developer, but likely has spent considerable time explaining to others how to do the same — as a writer, trainer, and instructor. This book is not his first, for he has previously written Dreamweaver: The Missing Manual.

One valuable aspect of the book under review, is that McFarland discusses how to overcome the most commonly encountered browser problems, in which Web pages employing CSS are not being formatted as one would expect and as specified in the CSS standards, by misbehaving browsers (that means you, "Internet Exploder"). Moreover, the book is also one of the first to document the significantly enhanced, long overdue, and welcomed CSS support in version 7 of the most commonly used Web browser (yes, we're still looking at you, "Browser by Bill").

The book is one in a series of many so-called Missing Manuals, whose tagline is "The books that should have been in the box," and whose Web site characterizes them as "Warm, witty, and jargon-free, [with] enough clarity for the novice, and enough depth and detail for the power user." In many respects, McFarland's latest contribution matches that description. In addition to the straightforward and yet comprehensive discussions of each topic, the author imbues his writing with a bit of humor, without overdoing it, or trying too hard, as is sometimes seen in other books covering subjects that admittedly can be quite dry.

On the negative side of the ledger, someone — or, more likely, some committee — somewhere along the decision chain, stipulated that almost every page of the book should be formatted so that the outside 1.5 inches, which is the easiest for a reader to see, should be consumed by a mostly empty and useless gutter, the bulk of which is filled with a light gray bar. This pushes the text, which slightly more than 4.5 inches wide, further in, toward the book's binding, and thus more difficult to read. This is true even though O'Reilly has wisely chosen to use RepKover, a flexible lay-flat binding. This exasperating style of layout is not characteristic of O'Reilly's books, which are generally much easier to read, with more sensible margins and often larger font.

One of the first principles taught to those learning Web design, is to avoid using white text on a black background. Such Web pages usually try to appear cool and edgy, but instead often comes off as immature in the eyes of an Internet veteran, and sinister to the Internet newbie. It doesn't work on Web sites, and it doesn't work in Web books. Sadly, O'Reilly chose to use white-on-dark-gray for many of the book's sidebars, making them difficult to read, especially as the sidebar text font size appears to be a bit smaller than that of the regular text.

In a nutshell, the content of this book is excellent, while the presentation of that content leaves much to be desired — ironic for a book focusing on CSS, whose primary purpose is to modularize and simplify presentation, neatly separating it from content. Ranking the content and presentation on a scale of 1 to 10, I would give them 9 and 5, respectively. Yet on balance, just as is true for most Web pages, the content is more important than its layout and other aesthetic considerations. CSS: The Missing Manual is a well-written, lighthearted, up-to-date, and easily accessible guide to modern CSS and how to use it in the real world.

You can purchase CSS: The Missing Manual from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Martin Ecker writes "Until now, if you were looking for an introduction to the OpenGL graphics API, the "OpenGL Programming Guide" (also known as the Red Book) was your best bet. Now Addison Wesley Publishing provides a new alternative that is easier to digest than the all-encompassing Red Book with its more than 800 pages. Paul Martz's "OpenGL Distilled" concentrates on discussing only the important fundamentals you need to program 3D graphics using OpenGL 2.0 and provides a concise introduction to the most important cross-platform graphics API currently available." Read the rest of Martin's review. OpenGL Distilled author Paul Martz pages 266 publisher Addison-Wesley Publishing rating 8/10 reviewer Martin Ecker ISBN 0-321-33679-8 summary A concise introduction to the OpenGL graphics API

Before going into more detail and reviewing the chapters of the book I have to disclose that I was a technical reviewer of the book before it was published.

"OpenGL Distilled" is aimed at people interested in learning the basics of OpenGL. The reader should already be familiar with programming in C++ and have a basic grasp of linear algebra, in particular vector and matrix algebra. Familiarity with other 3D graphics APIs, such as Direct3D, is an advantage, but not a necessity. The book does a good job of presenting only the fundamental aspects of OpenGL and 3D graphics programming in general and never overwhelms the reader with too much unnecessary detail. The author draws a good line between what to discuss and what is beyond the scope of the book. More advanced features of the API are only mentioned shortly with appropriate references to more in-depth literature. Some deprecated features, such as the feedback buffer, that are no longer commonly used are left out as well. In my opinion an unfortunate omission, is shader programming with the OpenGL Shading Language, which is only briefly mentioned in an appendix. A full chapter introducing the basics would be a nice addition to the book. Until then the reader is referred to the Orange Book, which discusses shader programming in OpenGL in detail.

One thing I highly appreciate about "OpenGL Distilled" is the introductory section of each chapter, which contains a "What You'll Learn" and a "What You Won't Learn" bullet list. This makes it clear what the chapter is about and - more importantly - what it is not about. Especially the latter is mostly missing in other books.

The book has a total of 8 chapters and 4 appendices. The first chapter explains what OpenGL is, talks a bit about setting up a development environment on the most common operating systems to actually develop OpenGL programs, and immediately gets your feet wet with a first simple example program. The chapter is concluded by a whirlwind tour through the almost 15-year history of OpenGL and its predecessors.

Chapter two focuses on drawing primitives, such as lines and triangles, and the various ways supported by OpenGL to specify vertex data. In particular, vertex arrays and vertex buffer objects (VBOs), a fairly recent addition to OpenGL to allow high-performance rendering, are the focus of this chapter. Additionally, a first overview of the OpenGL pipeline that a primitive passes through until it finally ends up in the framebuffer is presented. A more detailed discussion of this pipeline, in particular with regard to coordinate transformations, follows in chapter three. The various coordinate systems used in OpenGL programming, such as object, world, eye, and clip coordinates, are presented and discussed in detail in this chapter.

Now that we can render primitives we need to light them to make them look more interesting. Chapter four sheds some light on this by discussing the lighting and material model used in OpenGL's fixed-function pipeline. The best part of this chapter is the section titled "Debugging Lights", which gives some insights and helpful advice on how to debug OpenGL programs that use lighting. Many other books only describe the features of OpenGL lighting but do not explain common debugging techniques that can be applied when all you get is a black window instead of a nicely lit scene.

Chapter five is about pixel rectangles, in particular how to read from and write to the framebuffer. Some performance considerations are also discussed, which is a good thing since reading from the framebuffer is a costly operation. Again, this chapter concludes with a nice section on debugging techniques. The explanation of the raster position in this section is probably the easiest to understand that I have read to date.

Chapter six is a comprehensive chapter on 2-dimensional texture mapping that also discusses some more advanced applications of the technique, such as light maps and depth maps. Also using cube maps as environment maps is introduced. 1-dimensional and 3-dimensional texture mapping was omitted from the discussion.

Chapter seven deals with detecting the feature set of the OpenGL implementation, in particular, determining the version of the OpenGL specification the implementation adheres to and the available extensions. This chapter also discusses how to retrieve and use entry points for available extensions.

Finally, chapter eight deals with the platform-specific interfaces required to hook up an OpenGL program with the underlying operation system. These platform-specific interfaces are called GLX for Unix, WGL for Windows, and AGL for Mac.

The book has four appendices, which deal with a quick overview of advanced features, best practices, performance-related issues and debugging tips and tricks. Especially the latter two appendices on performance and debugging contain a lot of insights invaluable to programmers just starting out with OpenGL.

The book is printed in black and white throughout. Having some color plates in the book itself would have been a welcome addition considering that the topic is computer graphics. However, you can download some color plates from the books website at where you will also find the source code to the example programs in the book.

In conclusion, "OpenGL Distilled" is an excellent introduction to OpenGL, not only for someone new to 3D graphics programming but also for those that have worked with other 3D graphics APIs in the past that wish to get up to speed with OpenGL quickly. The book omits advanced and deprecated features that would unnecessarily overwhelm a beginner with OpenGL and is a good companion on the way to becoming an experienced OpenGL programmer.

The review author has been involved in real-time graphics programming for more than 10 years and works as a games developer for arcade games. In his rare spare time he works on a graphics-related open source project called XEngine http://xengine.sourceforge.net./

You can purchase OpenGL Distilled from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Michael J. Ross writes "Just as PHP and other Web scripting languages have made it possible to create dynamic Web pages, online mapping services are making it possible to create dynamic maps that can be customized by a Web site owner, or made customizable by a site visitor. In the case of Google Maps, this is done using the built-in application programming interface (API), which is described in a new book, Beginning Google Maps Applications with PHP and Ajax: From Novice to Professional." Read on for the rest of Michael's review. Beginning Google Maps Applications with PHP and Ajax author Michael Purvis, Jeffrey Sambells, and Cameron Turner pages 384 publisher Apress rating 8 reviewer Michael J. Ross ISBN 1590597079 summary How to use the Google Maps API to make dynamic online maps.

But first, a brief background: During the mid-1990s, the only generally available mapping applications were desktop programs with location data limited to major cities within the United States. Yet less than one decade later, those programs were obsolete, replaced by Web-based mapping services such as MapBlast, MapQuest, and Yahoo Maps. In early 2005, Google raised the bar, with its own Web-based mapping service that was far more attractive than the others. For countless Internet users, it was their first glimpse of the power of AJAX, a new combination of technologies that allows Web pages to be refreshed asynchronously, providing a faster user interface. But Google Maps later packed another feature, an API that allows Web developers to leverage the service's capabilities in previously unimagined ways.

The authors of Beginning Google Maps Applications with PHP and Ajax — Michael Purvis, Jeffrey Sambells, and Cameron Turner — are based in Waterloo, Ontario, Canada. The book was published in August of 2006, by Apress, under the ISBN of 1590597079. The publisher maintains a Web page devoted to the title, where visitors can find an online table of contents, a sample chapter (Chapter 3, "Interacting with the User and the Server") as a PDF file, and a link for submitting errata (none of which, as of this writing, appear to have been reported — assuming there are any). In addition, the authors have a Web site for the book, where they offer a sample chapter (Chapter 4, "Geocoding Addresses") in PDF format, links to raw data sources, and brief entries describing a variety of related topics, including geocoding services, Google Maps Mobile (GMM), Keyhole Markup Language (KML), and building your own geocoding using Perl.

The book's material is organized into 11 chapters, grouped into three parts. The fourth and final part contains the appendices. The three primary parts can roughly be thought of as presenting the beginning, intermediate, and advanced information. Part 1, "Your First Google Maps," whets the reader's appetite by showing how to easily create some simple maps (discussed below). In addition, it contains a chapter explaining how a Google Maps mashup interacts with the user as well as the server. The final chapter in this part discusses geocoding addresses. Part 2, "Beyond the Basics," explains how to work with third-party data, how to enhance the user interface, how to optimize and scale for large data sets, and finally what possible future directions Google may take with this API. Part 3, "Advanced Map Features and Methods," presents exactly that, covering such topics as creating custom controls and info windows, adding geometric shapes to maps, and getting the most out of geocoding, including how to work with postal codes.

The authors begin Part 1 ("Your First Google Maps") by introducing Google Maps with the two most simple examples possible: Keyhole Markup Language (KML) is an XML-like formatting language that allows one to specify the names, coordinates, and descriptions of one or more locations ("placemarks") in a single file. For anyone who wishes to avoid writing the code themselves, Wayfaring is a Web site that allows one to create and share custom Google Maps by point and click. Even though the introduction to KML is properly brief, instead of only stating that the sample coordinates were discovered manually, the authors should mention at least one simple way to find those coordinates (such as the "Link to this page" link in Satellite view in Google Maps). Nonetheless, it was wise of the authors to use simple examples to get the reader's feet wet as quickly as possible — especially for prospective readers who might skim through the rest of the book and become intimidated by the technical diagrams, JavaScript and PHP code, MySQL queries, XML markup, and mathematical formulas.

There is much to like about this book. The explanations are straightforward, the code is readable, the examples are relevant, and the writing style is approachable. The illustrations, all of which are in black and white, are well-chosen, and not overwhelming in number. In addition to showing the expected results of the sample code, they also provide enough visual incentive to encourage the reader to give the sample code a try, and perhaps develop it further into their own mapping applications.

The book is not too lengthy, clocking in at 384 pages according to the publisher (though, oddly, Amazon.com reports only 350 pages, even though the last page of the appendix reads "358"). The authors resisted the increasingly common temptation to pad the book with superfluous appendices. Instead there are only two. The first explains how and where to find location data, such as addresses and latitude/longitude points. The second appendix presents the details of all of the classes, methods, properties, constants and events defined within the Google Maps API. For some reason the authors mention "objects" instead of properties and events, but I was unable to find any pre-instantiated objects mentioned in that appendix., and I am not sure such are even possible in the API.

Fortunately, the weakest section of the book, its foreword, has the least impact upon the value of the book. It fails to perform the most basic functions of a foreword, such as explaining to prospective readers why they should become actual readers, as well as what the book covers, and how the authors are qualified to provide that coverage. Instead, its author mostly discusses his personal Google Maps Mania site, and even wedges in mention of his appearance on an NPR radio show, which has little to do with the book. He also lists his first five posts to his Mania site, the first of which contains a misspelling, which should have been caught by the book's editors, or at least indicated with a "[sic]." The best part of the foreword is the first few paragraphs, which provide a brief history of Google Maps and the hacking thereof.

Like most if not all of its titles, Apress helpfully starts this book with two versions of the table of contents — the first one serving as a high-level overview, and the second providing far more detail, listing not only sections but subsections. This is a nice touch, and should be employed by all technical publishers. On the other hand, this book does not have a lay-flat binding, which is a shame, as it makes it far more difficult to read the book with both hands free for keyboarding. With the introduction of lay-flat bindings years ago, it is inconceivable to me why it has not been universally adopted, particularly by technical publishers.

Overall, Beginning Google Maps Applications with PHP and Ajax is an excellent introduction to extending the power of Google Maps on the Web, and provides enough detail to both help and entice readers to build their own Google Maps mashups.

Michael J. Ross is a freelance writer, computer consultant, and the editor of the free newsletter of PristinePlanet.com."

You can purchase Beginning Google Maps Applications with PHP and Ajax: From Novice to Professional from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Rob Lanphier writes "I'm sure there are plenty of people like myself who do a fair amount of programming against MySQL databases, and consider it a feature of the product that it's pretty easy to do without having to fuss much with the actual database. Still, it's nice to look at what goes on under the hood, even if smoke isn't pouring out from beneath it. Pro MySQL by Michael Kruckenberg and Jay Pipes provides a broad well-organized exploration of intermediate and advanced MySQL topics that is a satisfying overview of the database management system." Read the rest of Rob's review. Pro MySQL author Michael Kruckenberg and Jay Pipes pages 734 publisher Apress rating 9 reviewer Rob Lanphier ISBN 1-59059-505-X summary MySQL overview for more advanced users

This book seems ideally suited for a couple of different audiences: Application developers with basic SQL knowledge hoping to gain a deeper understanding of the product and databases in general. The book provides a basic overview of the use of triggers, stored procedures, and cursors, among other things, before getting into the MySQL specifics. Experts in other database management systems (e.g. Oracle, Sybase) who want to apply their expertise to MySQL. The book provides a good tour of advanced MySQL functionality, and does a fair job of pointing out MySQL's shortcomings where they exist (which are much fewer in the 5.0 series). Such readers may be annoyed by the MySQL-centric views that surface from time-to-time, but all of the information should be there.

Pro MySQL is probably too advanced for someone just getting started with SQL databases in general. If you really haven't done much with SQL or relational databases at all, you should start elsewhere.

That said, there's a lot of information in here for beginners, and doesn't rush headlong into complicated discussions without at least a cursory explanation of the basics. For example, Chapter 2 has a nice review of many basic computer science concepts. Chapter 4 ("MySQL System Architecture") gives a light overview of the MySQL source code, highlighting a unique advantage of using open source. Though not the strongest chapter in the book, it includes an interesting section titled "A Typical Query Execution", which walks down the call stack explaining the source code for a typical SELECT statement. Readers might want to skip to this part of the chapter before reading the rest.

The real strengths of this book are in the chapters that deal with the database at a slightly higher level, which is most of the book. ACID compliance is covered in a thorough way, with many hands-on examples to ensure a solid understanding of the topic. The detailed discussion of the various storage engine types (focusing mostly on MyISAM and InnoDB, but touching on the others) is very useful in understanding MySQL's unique pluggable engine model, and how to leverage it. Chapters 9 through 13 provide great reference material for MySQL 5.0's advanced functionality, which includes information on stored procedures, functions, cursors, views and triggers. The final chapters (14 through 21) would stand alone as a separate book for administering a production MySQL database.

Chapter 8 ("SQL Scenarios") alone makes this book well worth the purchase price, providing recipes for solving some common problems with SQL. Some are rather simple, such as an optimization for using "OR" in "SELECT" statements in older versions of MySQL. Others are rather complicated and involved (but very useful), such as a nice way of storing hierarchical data in a table using the nested set model. The authors are careful to credit their source, Joe Celko's book Trees and Hierarchies in SQL for Smarties, for the latter. Hardcore SQL junkies may want to go straight to the source, but it's nice to see the material presented in a way that helps bring beginners up to an expert level.

The book's main shortcomings are in dealing with products that aren't downloaded off of mysql.com. MySQL's GUI tools get ample treatment (with copious screenshots, including a confirmation dialog) but the very popular phpMyAdmin tool is not mentioned anywhere. In discussing MySQL's lack of role-based access control, the authors write: "If you feel MySQL's normal user access and privilege verification system will not meet the needs of your organization, head over to [MySQL's MaxDB site] to check out how MaxDB implements its role-based system[...]", ignoring the elephant in the room, so to speak.

On a few occasions, the authors do veer into unsupported yet strongly worded assertions. For example, "This fact [that MyISAM is seemingly more efficient at storing data than InnoDB] should not be a factor in how you choose your storage engines..." (emphasis theirs). Without guidance on how much of a difference (10%? 500%? wildly unpredictable?) and a definition of the problem being solved, it's hard to say with such certainty whether or not this is a reasonable assertion. Also, "be conservative, especially when deciding on the length of character columns that will be frequently indexed", ignoring the tradeoffs that lead to the Y2K problem, for example. The advice given may be quite sound, but it's not presented in a way that convinces the reader that the authors have thought through all of the implications of their advice.

By and large, though, this is a very happy addition to my bookshelf. The organization is coherent and the chapters all have appropriate depth and have very useful information. I imagine I will refer back to this book often in building SQL applications, and I recommend it to anyone looking to boost their MySQL knowledge.

You can purchase Pro MySQL from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

danny writes "Modern network devices have to handle traffic in huge volumes at low latencies; achieving this requires ideas and approaches from all of computer science: hardware, algorithms, protocols, software engineering and their integration in a discipline which Varghese calls "network algorithmics". Read the rest of Danny's review. Network Algorithmics: An Interdisciplinary Approach to Designing Fast Networked Devices author George Varghese pages 465 publisher Morgan Kaufmann rating 9 reviewer Danny Yee ISBN 0120884771 summary pulling out all the stops to fix bottlenecks

After an introduction in chapter one to bottlenecks and techniques for avoiding them, Varghese provides a brief overview of protocols, hardware, network architectures, and operating systems, with examples, in chapter two. This is best suited as a refresher: Network Algorithmics assumes a general familiarity with networking protocols, operating systems and computer architecture, and if used as a text would be suitable for higher undergraduates. (The exercises at the end of each chapter are often open-ended.)

Chapter three introduces the fifteen implementation principles that are the core of Network Algorithmics: P1 Avoid obvious waste; P2 Shift computation in time (precompute, evaluate lazily, share expenses or batch); P3 Relax system requirements (trade certainty or accuracy for time, shift computation in space); P4 Leverage off system components (exploit locality, trade memory for speed, exploit existing hardware), P5 Add hardware (use memory interleaving and pipelining, use wide word parallelism, combine DRAM and SRAM effectively); P6 Create efficient specialized routines; P7 Avoid unnecessary generality; P8 Don't be tied to reference implementation; P9 Pass hints in layer interfaces, P10 Pass hints in protocol headers; P11 Optimize the expected case (use caches); P12 Add state for speed (compute incrementally); P13 Optimize degrees of freedom; P14 Use bucket sorting, bitmaps; and P15 Create efficient data structures. Chapter four presents fifteen problems that illustrate these principles in action, with hints to solutions.

Part II of Network Algorithmics is devoted to end-nodes. A chapter "Copying Data" takes a web server, delivering files from disk to network, as the prototype, and explores different approaches to reduce pressure on the memory and I/O bus by reducing the number of copies required: copy-on-write, fbufs, RDMA, IO-Lite, and more. It also touches on making cache use more effective and the tantalizing possibilities of "integrated layer processing".

"Transferring Control" looks at minimizing scheduling overhead and maximizing concurrency: at context-switches, processes, threads, and event-driven servers. It evaluates the existing Unix select() call and considers ways of speeding it up, with and without changing the API. And it touches on ways of avoiding system calls and reducing interrupt overhead.

There are three shorter chapters. "Maintaining Timers" explores hashed and hierarchical timing wheels, the BSD implementation, and fine granularity. "Demultiplexing" looks at the development of packet filters: CMU/Stanford, Berkeley, Pathfinder, hardware, and Dynamic (generating filter code in real time). And "Protocol Processing" looks at some miscellaneous tasks that can become bottlenecks: buffer management, CRC checks and checksums, TCP and UDP protocol processing, and packet reassembly.

So far I've only skimmed Part III, "Playing with Routers". This has chapters on "Exact-Match Lookups", "Prefix-Match Lookups", "Packet Classification", "Switching", "Scheduling Packets", and "Routers as Distributed Systems". And Part IV offers chapters on "Measuring Network Traffic" and "Network Security", along with a summary and overview.

Varghese gets right down into the details in some places, but he sets the material he covers into its broader context. He often takes a historical approach, looking at how implementations have been driven by changing requirements. And he stresses that only with a broad view can the overall costs and possible optimizations be seen: with web server performance, for example, it is necessary to consider "the whole system, from HTTP and its headers, to the file system, and down to the instruction caches". Where many computing disciplines emphasize the isolation of components, network algorithmics stresses links across layers and boundaries. (It's not overdone, but approaches and principles are often illustrated with analogies to ordinary life serving tables in a restaurant, for example or parallels with other areas of computing.)

Purists might find the practical approach of network algorithmics distressing Varghese admits that it "may seem drab and shallow" compared to "the beauty of theoretical techniques" but it has an attraction all of its own. I've often felt that "computer science" as commonly constructed lacks any coherence, spanning everything from nearly pure mathematics to hardware and engineering, but Network Algorithmics has made me rethink that.

Little in Network Algorithmics is relevant to my job as a system and network administrator I just plug switches in and configure them, and don't have to worry about their internals but I found it fascinating. Apart from curious general readers with a computer science background, or hackers who enjoy stretching their minds, the obvious audience is anyone building high-performance network devices or looking at optimization of networking code, say in the Linux kernel.

Danny Yee has written over 900 other book reviews."

You can purchase Network Algorithmics: An Interdisciplinary Approach to Designing Fast Networked Devices from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Graeme Williams writes "So many dimensions are folded into this compact book that it took me more than a few moments to see what I was looking at. In the space of 184 pages, SQL Pocket Guide, Second Edition documents, explains, illustrates and compares the most common SQL statements from Oracle (10g), DB2 (8.2), SQL Server (2005), MySQL (5.0) and PostgreSQL (8.1), with occasional notes on previous versions, and pointers to more material on the author's web site. The book bills itself as "A Guide to SQL Usage" and it has an ample amount of explanatory material in addition to syntax and examples." Read the rest of Graeme's review. SQL Pocket Guide, Second Edition author Jonathan Gennick pages viii + 184 publisher O'Reilly Media rating 10 reviewer Graeme Williams ISBN 0-596-52688-1 summary A clear and compact overview of SQL for five different databases

The second edition of SQL Pocket Guide has been updated for the latest versions of the four databases covered in the first edition, and PostgreSQL has been added. There are also new sections on datatypes and creating tables and indexes. O'Reilly has recently announced that all of their pocket guides and references will be available as PDFs. This review is based on the paper book.

In addition to the most common SQL statements, SQL Pocket Guide, Second Edition also describes many useful functions, including datatype conversions, date/time, math, trig and string functions, and handling nulls. The table of contents for the book provides an excellent idea of what is included. One note about the table of contents: sometimes differences in syntax between different databases are covered inline, and sometimes each database is covered in a separate subsection. The table of contents makes the two types of coverage clear, since a subsection for a particular database is indicated by the database name in parentheses, such as "Numeric Conversions (Oracle)".

Rather than give formal syntax specifications, Gennick gives examples for each statement and function that he explains. The neat thing is that all the examples run against a simple schema and data which you can download from the book's web page. And yes, the data comes in five flavors to match the five databases covered by the book. You shouldn't underestimate how much this buys you in maintaining the book's high information density. It means that the SQL examples can be presented, and make sense with, little or no lead in.

Gennick also includes some pointers to the material on his web site. If you regularly lose bar bets on the details of recursive queries, or you need more explanation than the book provides, this will be very useful.

SQL Pocket Guide is organized alphabetically by topic, such as "Selecting Data", "Subqueries" or "Tables, Creating". Each topic is divided into a number of sections, such as SELECT, FROM and WHERE and again into subsections, such as specifying a table alias in the FROM clause. I like the size of the book (4 1/4 in. by 7 in.). The fact that the pages are pretty small, however, means that two facing pages might only contain a few subsections without any indication of the section they belong to. This can make it hard to keep track of context while flipping through pages. It's needlessly hard to distinguish between topic, section and subsection headings because they're all in the same font, and only a point or two different in size. There ought to be some simple way to indicate the difference.

I don't mean to suggest that the book is impenetrable. The table of contents includes both topic and section headings, and it's easy to skim to find what you're looking for. The topic is given at the bottom of every right-hand page. It would be great if the section was given at the bottom of every left-hand page, which is presently wasted by repeating the book title.

SQL Pocket Guide is small and clear. If you're looking for a book that is small, clear and complete, I'm sorry, that book doesn't exist. I'm guessing that you can't even get clear and complete. As a comparison, I took a look at an Oracle 9i reference. The whole book is over 1200 pages – the reference section, the section that is comparable in style and content to SQL Pocket Guide, is over 350 pages. The syntax diagram for the SELECT statement is terrifying just on its own.

From this syntax diagram, I discovered that Oracle has a "flashback" feature, which under certain circumstances allows you to look at the database as it was at a time in the recent past: SELECT * from EMPLOYEES AS OF (some time in the past) The problem is that the chapter on flashback queries doesn't discuss this particular syntax – here, you're on your own. As you might expect, a 1200 page book isn't an ideal learning tool, but it's not a perfect reference either. On the other hand, SQL Pocket Guide doesn't cover flashback queries at all.

SQL Pocket Guide doesn't contain every single thing anyone will ever need to know about any of the five covered databases. Different people will find different gaps in what's included. The book doesn't include creating views, which I would have found useful. Also, I recently found myself with an SQL Server table so gnarly that I used two nested unpivot statements to unwind it, but unpivot, which is new in SQL Server 2005, isn't included in the book either. The book deserves its rating, however, because it's nearly perfect for its size.

In giving up completeness, Gennick hasn't just produced a book with fewer pages, he's produced a book that works either for learning or reference. Reading the book cover to cover is a rapid and effective way to get up to speed on a particular database. This is true if you are vaguely familiar with SQL and need specific details, or if you're intimately familiar with one database but moving to another. Unless or until you've committed the details of each SQL statement to memory, this book will be the best fifteen dollars you'll spend.

You can purchase SQL Pocket Guide, Second Edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

javathut writes "Perhaps an alternate title for this book could have been "understanding your audience." For any Sony PS3 execs out there wondering why their technological masterpiece is being ridiculed by customers months before it's even released, or what the long-term repercussions of their DRM policies will be, Convergence Culture is a must read. Drawing upon case examples of how a variety of user communities adopt digital technologies, sometimes in ways completely opposite from what the designers intended, Jenkins offers numerous insights on how technology and media professionals can forge better relationships with their customers." Read the rest of Ravi's review. Convergence Culture: Where Old and New Media Collide author Henry Jenkins pages 336 publisher New York University Press rating 10 reviewer Ravi Purushotma ISBN 0814742815 summary Convergence Culture offers numerous insights on how technology and media professionals can forge better relationships with their customers

In one example, he follows the progression of the Harry Potter franchise after Warner Brothers purchased the film rights. In the interest of protecting their trademark, the studio sent out cease-and-desist letters to an online network of pre/teen [largely] girls who had been writing and sharing stories about Harry Potter as a way of learning to improve their writing skills. Rather than desisting, they coordinated a global protest that became a major P.R. headache for Warner Brothers -- who ultimately had to back down. This is likened to the confused message LucasFilms sent its customers when its movie division attempted to litigate control of the Star Wars storyline away from fans, while at the same LucasArts was trying to encourage players of Star Wars Gallaxies to explore and expand the Star Wars universe.

By themselves, the case studies are perhaps not that dissimilar from the many other accounts of industry execs completely botching their community relations. However, as the director of the Comparative Media Studies program at MIT, Jenkins adds some insightful perspectives on thinking about technology and the structuring of new-media companies in response to internet communities. Contrasting the typical response of U.S. companies to technologies like filesharing, he looks at the attitudes of Japanese anime and manga producers -- outlining how their more open attitudes could have influenced the current popularity of Japanese-origin franchises within the United States. Similarly, he looks at the corporate structure behind the Matrix franchise (in particular the Enter The Matrix video game), demonstrating how elements of The Matrix design process could serve as a model for other industries.

The book also contains a second thread running through it looking at 'collective intelligence.' Basically, this can be thought of as a sort of Wisdom of Crowds view of what happens when customers become so tightly networked with one another that they can overpower media producers. One chapter looks at the tv series Survivor and how online spoiler teams shared satellite data, local knowledge and social networks to determine the show's conclusion before it aired. Rather than simply fighting efforts such as these as was done with Survivor, Jenkins outlines examples of how collective intelligence communities could be harnessed to advance products or causes. Using the extensive accomplishments of the 600,000 players in the popular Alternate Reality Game I Love Bees as a model for what is ultimately possible, he outlines how viral marketing, politics and other domains are changing in response to the increasing collaborative abilities of networked fans.

Having previously taken classes with Professor Jenkins, I had long been looking forward to the release of this book. Reading it, I was glad to find the same clear focus on real-world examples and practical applications that was emphasized in his classes. Overall, it reads far more similar to titles like Steven Johnson's Everything Bad is Good for You or Howard Rheingold's Smart Mobs than anything you'd expect from an academic professor.

As the subtitle "where old and new media collide" suggests, the book contains a pretty even split between traditional broadcast/cinematic media and web/video game/mobile media. Anyone interested only in a single media form probably won't find this book that different from any others on their topic. Rather, most of the more unique insights come from Jenkins's understanding of how these different media forms interact to re-enforce one another, and the ways in which consumers navigate between multiple media forms and online channels.

While most of the theories put forth in the book will likely remain relevant for years to come, a few of the case studies are already showing their age. For example, the Star Wars Gallaxies discussion appears to be written before the recent shakeup at Sony Online. This means readers will need to go beyond the book to remain fully up-to-date with some of the examples.

Overall, any reader should find Convergence Culture an extensively researched book using a conversational writing style that makes it truly engaging to read and clearly accessible. However, those in charge of managing community relations, online presence or designing media to cross multiple platforms would likely benefit from it the most.

Disclaimer Notice: The review author is a former MIT student who took classes taught by Henry Jenkins on this topic."

You can purchase Convergence Culture: Where Old and New Media Collide from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Graeme Williams writes "I really need something that will help me diagnose and fix problems with Windows PCs. I provide occasional support for more than a dozen PCs at my local church, as well as the systems at home, and those that arrive in the wake of my children. I don't do it regularly enough to have a clear model of how I should go about it. I really wanted It's Never Done That Before to provide that clear model, but unfortunately I was disappointed." Read the rest of Graeme's review. It's Never Done That Before / A Guide to Troubleshooting Windows XP author John Ross pages xix + 263 publisher No Starch Press rating 3 reviewer Graeme Williams ISBN 1-59327-139-5 summary Not organized well enough to help in a real crisis

After reading It's Never Done That Before, I've got a pretty good idea of what I'm looking for in a book about PC repairs. The first part of my ideal book would provide background information about how a PC works. For example, if you wanted to diagnose a problem that occurred during booting, it would help to know what was involved in the boot process, from the power and power supply to the BIOS and MBR and ultimately to Windows, the registry and the desktop.

The second part of my ideal book would explain basic techniques, such as how to change your BIOS settings. These techniques would form a library which could be referred to later in the book without further explanation. The third part of the book would explain things you could do before disaster strikes, such as backing up your data, and writing down your network configuration parameters, and most importantly, making sure you can actually follow the recovery procedures you'll need when disaster does strike. If you can't change BIOS settings when your machine is stable, you're certainly not going to be able to do it when you're terrified that a hard drive failure has lost Auntie Edna and Uncle Norman's pictures. My recommendation would be to permanently set your BIOS boot settings so that your system looks for a boot CD before booting from disk, but if the extra delay bothers you, you can always change it back. At least you'll know what to do.

Evaluating It's Never Done That Before against my ideal, the real book does better on content than it does on organization. For example, it has a useful chapter on what you can do before disaster strikes, and it has a pretty clear explanation of how to change BIOS settings, but they're not in the same place.

The fourth and final part of my ideal book would explain how to diagnose and repair problems. One of the reasons this isn't trivial is that a book should necessarily focus on the most common problems, but has to leave open the possibility that something unlikely is happening. One of the problems I have with my laptop at work is that when I eat lunch at my desk, the touchpad will interpret dropped crumbs as a continual touch, which immediately makes the cursor uncontrollable. Touchpads are not mentioned in It's Never Done That Before – but that's not necessarily an issue. Many more people will, say, have a hard drive failure than will have crumbs on the touchpad, and the book has plenty of material on hard drive failures. But too much of the book assumes you know what the problem is, instead of systematically going through possibilities – and leaving open the possibility that something odd or unlikely is happening.

One of my systems at home is an old hand-me-down desktop from my son. He had installed a firewire card, which remains, and a sound card, which he removed. I put in a new disk, which I partitioned as a dual-boot Linux and Windows XP system, and attached a external firewire drive. The first problem I noticed was that when Linux boots, it changes the BIOS to disable on-board sound. Perhaps this is some kind of "phantom limb syndrome" for the missing sound card? Some time ago, the firewire card became less reliable – at least, if the drive is on, Windows will black screen during boot. This can be avoided by leaving the drive off until Windows has settled down after booting. Lately, when Windows boots it has started to reset the network file sharing settings for the external drive. I fear that the Windows system on this machine is disintegrating, perhaps in anticipation of Vista.

It's not that It's Never Done That Before doesn't cover any of these areas. For example, it has a considerable amount of material on boot problems, including black screens. The problem is that it's not organized as a fault tree, where you start with no knowledge other than the immediate symptoms and proceed to collect data and rule out possibilities until you're left with the precise cause. One of the benefits of doing this carefully is that you won't prematurely decide whether the cause is hardware or software. Unfortunately, It's Never Done That Before just isn't organized this way.

The lack of organization also manifests itself as unnecessary and sometimes irritating repetition. For example, you get to the Windows Advanced Options menu by pressing F8 during startup. On page 46, the instructions are "When the results of the POST [power on self test] appear on the screen, press the F8 key until the Windows Advanced Options menu appears". On page 48, the instructions are to "immediately press F8 a few times" POST is not mentioned. On page 60, the instructions are to "press the F8 key several times".

The book just isn't clear about how a PC connects to the Internet and how that can fail. One indication is that the material is split between Chapter 13, "Internet Connection Problems" and Chapter 15, "Dealing with Hardware Problems", when there's no way you can know a priori whether a problem is hardware or software. Or for that matter whether the problem is yours or your ISP's.

Figure 13-3 on page 147 is the first of two diagrams related to Internet connectivity. The diagram shows something called a Wide Area Network which you connect to that is separate from the Internet Cloud. I suppose this might refer to the BGP AS you're connected to, but that hardly matters to most people. And having introduced the idea that you're connected to some equipment at your ISP, the diagram doesn't make clear that if you're directly connected to the Internet (without a router), your PC gets an IP address from the ISP's DHCP server, but if you're connected via a router, the PC gets its address from the router, and the router gets its address from the ISP. How do you recognize when your PC hasn't got an IP address from the appropriate DHCP server? This is needlessly hard in Windows XP, because the OS "helpfully" defaults to something plausible and wrong, but the book offers no help in digging you out of this one.

Figure 15-1 on page 169 includes a DSLAM (a piece of equipment at the local telephone company), which is a fascinating detail, but not really something you need to know even if you have a DSL connection. At least in the US, the key thing to know is that DSL wiring problems belong to one part of the telephone company (because it's the same wiring as your telephone) but Internet problems belong to a different part. If you live in the inner city, you're quite likely to have wiring problems (based on my experience with a sample of two and a failure rate approaching one per year), but if you have a problem with your line and you're talking to the wrong group within the telephone company you'll be rebooting your PC and checking network settings until you're blue in the face.

The popularity of wireless LANs has introduced a whole new set of problems. At home, my POSSLQ uses a laptop with a wireless PCMCIA card. As the the wireless router got older, the wireless connection on the laptop seemed to get less and less reliable. After avoiding the problem for a while, I stumbled across the length argument on the ping command, and discovered that the packet loss rate depended on the packet length. I adjusted the MTU and things immediately got a lot better. It's Never Done That Before ignores ping in favor of traceroute (which I find confusing for basic connectivity problems) and so would never solve this problem.

Even a simple LAN requires several systems to be up and communicating in order to connect to the Internet. A short time ago I upgraded the wireless router in my home from 802.11b to 802.11g. By systematically going though all the incorrect combinations first, I was able to verify that the procedure given in the router manual was both necessary and sufficient: power off the cable modem, router and PC, and power up the cable modem, router and PC in that order. I also support a local church with a local area network of about a dozen computers, which seems to have an endemic problem with IP address conflicts. In this case, I leave the PCs on and power cycle the router. These rules and especially the reasoning behind them aren't included in It's Never Done That Before.

I'm a little mystified why the author doesn't recommend making a live CD of your favorite Linux distro. If you have a problem that prevents Windows from booting, it's an easy way to connect to the Internet to look for resources. It's also an easy way to confirm more serious problems. I recently had a computer with a motherboard problem go into a reboot loop with a live CD, which was sort of terrifying, but immediately ruled out Windows as the source of the problem

I guess it's clear by now that I don't like It's Never Done That Before. There's a lot of information in the book which many people may find very useful in understanding more about how their PC works and how it fails. The book may very well help people with simple problems. However, the experience I've had fixing PC problems suggests to me that the book is not structured well enough to lead you through the process of diagnosing and repairing an unknown failure."

You can purchase It's Never Done That Before from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Ravi writes "When somebody talks about the Qt Framework, the first thing that comes to mind is KDE one of the most popular Desktops which is built using the Qt library. Qt is a C++ GUI framework created by the Norwegian firm Trolltech which can be used to build applications for a variety of OSes and platforms. The latest version of Qt (Ver 4.0) contains huge improvements over its earlier versions such as advanced modal/view functionality, easy to use template containers and better Unicode support just to name a few. I have been excited about the ease with which one can build GUI applications using Qt. Trolltech provides the library in two licences - the free licence which mandates that the applications developed be released under GPL and a commercial non-free licence which allows one to develop closed source applications using Qt." Read the rest of Ravi's review. C++ GUI Programming with Qt 4 author Jasmin Blanchette and Mark Summerfield pages 540 publisher Prentice Hall rating 9 reviewer Ravi ISBN 0-13-187249-4 summary A great book to learn the latest version of Qt (Ver 4.0) to create applications that run natively in Linux/Unix, Windows and Mac OS X

I found the latest book on Qt titled "C++ GUI Programming with Qt 4" authored by Jasmin Blanchette and Mark Summerfield and brought out by Prentice Hall to be a remarkable book in that it takes the readers through the basics of creating applications using the latest version of Qt and gradually shifts to explain the more advanced concepts of GUI programming using this C++ framework.

The book, all of 540 pages is divided into three parts - the first part containing 5 chapters dealing with Basic Qt, the second part titled Intermediate Qt which contains 11 chapters and the final part titled Advanced Qt containing an additional 5 chapters.

The major work in picking up skills in a new GUI framework revolves around getting to know all the classes and their member functions. And learning Qt is no different. In the first five chapters (Part I of the book), one gets to know the rudimentary concepts behind creating GUI applications using the Qt toolkit. And remarkably, instead of boring the readers with the different Qt classes, the authors take a hands on approach and introduce the concepts via examples.

In chapters 1 through 5, the readers are introduced to rapid dialog design using the Qt Designer, introduction to the main Qt classes such as QApplication, QObject, QWidget and its child classes as well as a good understanding of the concept of Signals and Slots which form the meat behind communication between different objects in Qt. Apart from that the 5th chapter also introduces to the reader the concept of Double buffering - one which is used popularly by the programmers in eliminating flicker in the GUI interface.

The sixth chapter titled "Layout Management" falls in the second part namely "Intermediate Qt". Here one gets to know and tryout the different layout classes that are available in Qt using which one can easily design sophisticated GUI applications. This chapter also gives the reader an introduction to Multiple Document Interface by way of an example.

Event Processing forms the basis of the seventh chapter where the authors explain how to catch events such as key presses and timers. Apart from that the authors also explain the five levels at which events can be processed and filtered in Qt.

Qt has an excellent collection of classes for creating 2D and 3D graphics. And from version 4, the classes are grouped into modules which need only be plugged in on a need to use basis. The primary class which deals with the 2D graphics engine in Qt is the QPainter class. The use of this class has been explained in detail in the eighth chapter titled "2D and 3D Graphics". Other than that, one also gets to know about the OpenGL module in Qt which makes it very easy to integrate OpenGL code into Qt applications as well as the classes which implement printing.

It is really interesting to see that the entire subject of Qt is apportioned into separate chapters with each chapter dealing with a particular topic. For example, if in the 9th chapter, the authors dwell on explaining the classes which implement drag and drop support, the succeeding chapter elaborates on the Model view controller architecture which forms the basis for most item view classes which implement tables, tree views and lists.

Another thing worth noting is that each chapter is explained with a complete stand alone example which makes it easy to try out what one has learned and also get a better idea of the concepts behind the classes that are explained. So while learning say about the container classes in Qt, the reader can actually try out an example and the code is accompanied by step-by-step explanations which makes it much more simpler to grasp the concepts.

All object oriented languages contain what are known as container classes - those which are responsible for creating sorted and unsorted data arrays, vectors and lists. And C++ has a couple of them in the Standard Template Library (STL). Qt has its own wide array of container classes which sport a number of improvements over STL in that they support implicit sharing (Copy on Write) which gives the applications a significant performance boost. In the 11th chapter titled Container Classes, the authors explain the concept of containers and the Qt classes that can be used for the same.

The next two chapters deal with writing and reading data from files as well as databases. And in each case, the concepts are explained with the aid of examples which makes the narration much more interesting to follow.

Qt has good support for Networking as well as XML which is evident from the 14th and 15th chapters which elaborate on the classes responsible for these. Even though these two short chapters do not cover all the networking or XMl concepts, I found them to impart a good idea of the use of a couple of important Qt classes related to networking and XML.

The 17th chapter titled "Internationalization" falls in the Advanced section of the book. I found this chapter to be an eye opener in that, with Qt's robust use of Unicode, it is possible to create applications which support a wide variety of non-english languages.

But one of the very important concept of multi-threading is explained in the next chapter titled what else "Multithreading" where the authors teach how to create threads easily in Qt.

If one looks at any KDE application, it will be evident how the parent application can be extended by use of plugins. A plugin is a dynamic library which implements a particular interface to provide extra functionality to the user. In the 19th chapter, one gets to know how to create dynamic libraries using Qt which can then be plugged into the parent application.

In the penultimate chapter, the authors explain all the platform specific features and tweaks such as using ActiveX in Windows and handling session management in X11. There are also four pages - which I believe to contain the shortest chapter I have ever come across and where a couple of classes which can be used in programming for embedded devices such as mobile phones are listed. By including this tiny chapter, perhaps, the authors were sending a signal to the developer community that Qt is fully ready for use in embedded development.

From start to finish, I found the book immensely enjoyable. The style of narration of the authors which interleaves the example code with the explanation is ideally suited to pick up skills in using any toolkit without getting bored, especially since the bulk of the learning involves acquiring a fine understanding of the classes the toolkit provides. As a bonus the book also provides an appendix which gives an introduction to C++ for programmers who use Java or C#.

The single CD accompanying the book contains Qt library in the source form for the Linux platform as well as for Windows and Mac platforms. I did not have any problems in compiling the source and installing the library in Linux using the instructions provided in the book. And within a little more than an hour (the time taken to compile the source code), I was able to start coding and compiling the examples given in the book. All in all, I find this book to be an invaluable guide in picking up skills in programming in the latest version of Qt (4.0).

Ravi Kumar likes to share his experiences in programming and in using Linux through his blog on Linux."

You can purchase C++ GUI Programming with Qt 4 from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Simon P. Chappell writes "Regular expressions (regex to their friends) are an incredibly powerful addition to most programmer's personal toolkit of techniques. Programming using a language that doesn't support them can be frustrating if you need to do any amount of non-trivial string handling. Java was just such a language until the release of the 1.4.x series. Sure, there were libraries like ORO that would provide regex support, but it wasn't built in and not many companies allow the use of 3rd party libraries. With version 1.4.x, the corporate Java developer in the trench, received the power of regular expression pattern matching." Read the rest of Simon's review. Java Regular Expressions author Mehran Habibi pages 255 (7 page index) publisher Apress rating 8/10 reviewer Simon P. Chappell ISBN 1590591070 summary A great starter for using regular expressions in Java

The book seems targeted towards those who have a solid level of Java programming skills, but who have not yet used the java.util.regex package. I see two types of Java programmers who might not have used the regex package, those who do not know about regular expressions and those who know them, but have not yet used them within Java. This book should satisfy both sets of users. The first group will be benefited by the general introduction to regular expressions and the gentle introduction to using them within Java. The later group will benefit from the more advanced material in the book.

The book is nicely structured and progresses easily through its subject matter. The first chapter is an introduction to regular expressions. While this is most obviously for the readers new to the subject, it will be useful for those more experienced, because not all regex engines are created equal and this chapter lays out the particular dialect of regular expressions used by the Java 1.4.x regex engine. The second chapter introduces the object model used by java.util.regex. This gives detailed explanations of the Pattern and Matcher objects as well as the new regular expression methods added to the standard String class.

The third chapter takes the reader into advanced Regular expressions. While there is much that can be done using just the Pattern and Matcher objects, the path to the full power of regex travels through an understanding of groups (and subgroups) and qualifiers. Regex groups are hard to explain until you've seen them in action, whereupon you may find yourself wondering how you'd ever managed without them before. Mr. Habibi does an excellent job, both explaining them and introducing us to the unusual noncapturing subgroups. (I'd never heard of these before.) Qualifiers are the other side of the same coin with groups. While it's one thing to define a group and whether it's expected and to be captured, it's equally important to be able to describe the expected occurrence of those groups using qualifiers.

Chapter four tackles the interesting challenges of using regex in an object-oriented language. Mr. Habibi describes the general principles of use of regex as similar to those used with SQL through the JDBC interface. These principles are the optimisimg of connections, batching reads and writes, storing patterns externally, Just In Time compilation of patterns and remembering that not every piece of String handling code needs to be written as a regex. All very useful advice.

Chapter five is the big examples chapter. All of the examples are intended to be practical; the kind of thing you might have to address at the day job. With examples covering Zip codes, telephone numbers, dates, searching text files and even validating an EDI document, he seems to have delivered on that assertion. There are further examples in Appendix C, if the afore-mentioned patterns aren't enough.

The writing and progression of material are good. The examples are very well thought out and explained. Many of the examples are built from first principles. Mr. Habibi seems to want to not only teach you how to use regular expressions, but also how to design them. He does this by working up from an understanding of the data until he has a working regex.

While it doesn't make any promises about being an encyclopedia of regex patterns, this book does contain enough of the normal business patterns to be a useful initial reference work, before turning to the Internet to search for patterns.

If you want an encyclopedic reference work on regex, then buy Jeffery Friedl's Mastering Regular Expressions which is published by O'Reilly. This is not that book, preferring to stick with the practical usage of regex.

This is a great starter book, for developers who are new to using regular expressions in Java."

You can purchase Java Regular Expressions from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.