Slashdot Mirror

Craig Maloney writes "Throughout the years, there have been many clones and re-implementations of the venerable vi editor. One variant of vi that emerged and stayed with us is VIM. Since its introduction, VIM has proven itself a worthy successor to the traditional vi editor. VIM has rightfully taken the place of standard vi implementations as the spiritual successor to vi, completely replacing the vi editor on many, if not all of the current Linux distributions. Many improvements have been made to VIM such as tabs, spell checking, folding, and many, many more. However many of these new enhancements may still remain hidden to anyone who isn't keeping up on the cutting edge of VIM development. Hacking VIM is a good resource for becoming more familiar with the new features of VIM and how to make them work best for you." Read below for the rest of Craig's review. Hacking VIM author Kim Schultz pages 210 publisher Packt Publishing rating 7/10 reviewer Craig Maloney ISBN 978-1-847190-93-2 summary A good way to wring more productivity out of an already excellent editor Hacking VIM is a short book, weighing in at a scant 210 pages. The book contains six chapters, and two appendices. The first chapter covers the history of VIM, and the lineage of vi clones that preceded it. Chapter 2 covers personalizing VIM. This chapter covers how to really take VIM and customize it for your own needs, from changing the fonts and colors for GVIM to personalizing the status bar, and using tabs. Chapter 3 deals with navigating better in VIM, whether it's in a singular file, or a group of files (which is especially important for several programming environments). Chapter 4 discusses the many productivity enhancements of VIM, such as templates, auto-completion, code folding, sessions, and the built in diff mode. Advanced formatting is covered in chapter 5, which has a few interesting tips on making code look better. Rounding out the book (and weighing in as the largest chapter of the book) is scripting VIM. VIM has excellent scripting capabilities, and this chapter covers them in great detail, from finding scripts to writing your own. Lastly, the Appendix covers some of the neat scripts available for VIM, such as a minesweeper game, and the obligatory Towers of Hanoi puzzle and mail client (because no software is considered done until it reads mail and news. :) )

Hacking VIM prefaces each tip with which version of VIM will work with each function. There were only a few instances where I noticed that a particular function was mis-marked as requiring a later version of VIM that actually worked with earlier versions. The book also contains good images which help demonstrate some of the more visual components of VIM, like tabs, folding, and the spell checker.

It is full of useful tips for getting the most out of VIM. The book is aimed at those who have already gained some familiarity with the VIM editor, and is by no means a tutorial for the novice user. There is clearly a bias in this book to the intermediate and advanced VIM users. Unfortunately, this is at odds with the first chapter, which starts with a history of the VIM editor. This wastes some of the space of the book, and would have been best used with more unique and different tips. Also, having some experience with VIM, I found certain tips weren't worth the trouble, and others quite confusing. The section on signs was a bit confusing, and I'm still unclear on why they're worth the trouble. There were several instances where I wondered what the productive benefit of a tip would be. On the other hand, I did find several tips invaluable. It's easy to overlook new functions in the CHANGELOGs, so I missed that newer versions of VIM had integrated spell-checking. Overall, Hacking VIM had enough good tips in it that I hadn't discovered on my own to make it worth the read.

Like most editors, VIM can induce editor fiddling sessions that result in little work being done, and Hacking VIM contains lots of fodder to make even the most ardent tweaker happy. Unless you carefully follow the mailing lists for VIM, and try every new feature as it is released, you might miss some really helpful productivity enhancers. My only wish for this book would be more focus on really productive tips, and less history about the other versions of vi that didn't survive. The book may have lots of "of course" items for the truly seasoned VIM user, but for those of us who don't keep up-to-date with the latest features, it is an excellent way to get more familiar with some of the truly great features that have been introduced in later VIM versions.

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

Craig Maloney writes "Over the long history of Linux, there have been many different distributions. One of the most famous distributions, love it or hate it, is the Ubuntu distribution. Ubuntu has come quickly from being the new kid on the block with the Warty Warthog release (4.10) to the most recent release Gutsy Gibbon (7.10). In that three year span, Ubuntu has grown from a handful of enthusiasts and developers to a thriving worldwide community. The Official Ubuntu Book is the official book from Canonical, which describes not only the Ubuntu distributions, but also the community from which Ubuntu is derived." Read below for the rest of Craig's review. The Official Ubuntu Book author Benjamin Mako Hill, Jono Bacon, et. al pages 463 publisher Prentice Hall rating 9 reviewer Craig Maloney ISBN 0-13-235413-6 summary An excellent way to get introduced to the Ubuntu distribution and community The Official Ubuntu Book is comprised of 10 main chapters covering various aspects of the Ubuntu project. The first chapter discusses a bit of the history of the Ubuntu project, as well as the relationship of Canonical to the project. Chapter 2 dives into installing Ubuntu from either the Live CD or the Alternative installation CD. Chapter 3 shows how to use the applications that ship with Ubuntu with some detail. Some of the more in-depth programs get more attention, like The GIMP and Firefox. Also covered are the basics of the GNOME interface, such as adding items to the panels, or logging off of the system. Chapter 4 covers basic system administration (printers, upgrades, file sharing), and package management. Chapter 5 introduces the Ubuntu Server variant, covering RAID, LVM, and more package management techniques. Chapter 6 deals with support issues in a question / answer format, and is a great place for readers to get some of their more common questions answered. Chapter 7 covers the Kubuntu variant of Ubuntu in more depth. Chapter 8 and 9 introduce the Ubuntu Community, and the tools that keep the Ubuntu project running. These chapters alone should be required reading for anyone with more than a passing interest in the Ubuntu project. Lastly, Chapter 10 covers the Edbuntu project, and demonstrates how to set up a LTSP network. The appendices include the Ubuntu related documents, a quick tutorial on the command line, and a great Windows / Ubuntu equivalent section for those who are looking for the best alternatives for certain Windows programs. All-in-all, The Official Ubuntu Book covers the main aspects of the Ubuntu project in a very thorough manner.

Included with the book is the Ubuntu 7.04 release (Feisty Fawn) on DVD. This is a solid release, and was current at the time the book was published. It still has 12 months active support even in light of the recent 7.10 (Gutsy Gibbon) release, and should give those looking to try Ubuntu an excellent starting point.

The biggest issue facing a book like The Official Ubuntu Book is determining a target audience. Ubuntu appeals to a wide range of people; from the newest newbie to the hardened UNIX aficionado. Making a book that speaks to both is no easy task. Fortunately, The Book does an admirable job of providing enough to keep both parties interested. New Ubuntu users will find lots of information about how to get things accomplished in Ubuntu, while seasoned UNIX user will find enough information to see what th differences are between Ubuntu and other Linux distributions. Both will find a great introduction to participating with the rest of the Ubuntu community in the later chapters of the book. Any user of Ubuntu would be well served in reviewing those chapters fora sense of what opportunities exist, and how best to participate in the community given their talents and skills. True, the chapters describing specific applications lack much depth, but the omission can be forgiven in light of the shear amount of material covered. Just learning how to navigate what is provided on the live CD could fill a tome the size of this book, leaving no room to discuss the more about the community. The Official Ubuntu Book balances between both extremes, and provides plenty of information about both the Ubuntu distribution, and the community.

The success of the Ubuntu project is due in no small part to the people who spend their time participating with other Ubuntu users. Reading the book not only gives a sense of what Ubuntu is about, but also shows how open and inviting these users are. It may not be the best tutorial for the new Linux user, but it is an excellent book for those who want to take the next step and be a part of putting together and supporting a large Linux distribution. The Official Ubuntu Book captures the spirit of the Ubuntu community well, and brings the excitement in a palpable form to the reader. I can recommend this book to new users of Ubuntu with only the caution that they may need to find other resources to learn the many new programs that ship with Ubuntu. However, I can also highly recommend this book to anyone who has even a passing interest in getting involved with the Ubuntu project, both new and experienced. The Official Ubuntu Book, much like the Ubuntu project, is an ambitious undertaking, and similarly we all benefit from their hard work.

You can purchase The Official Ubuntu Book from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Craig Maloney writes "Growing up, I found myself more than once in an arcade, be it in the mall, Meijer, or a free-standing building. The atmosphere was unmistakable: loud, with lots of activity, and people getting fully immersed and "in the zone" between them and their pixellated avatar. While playing an arcade game at home has been possible for many years now, the true arcade experience has been a little more elusive. There's something about having an upright video game cabinet, and playing on arcade hardware that gives the game that extra sense of being right in the arcades of my youth. There are many sites out there that have different plans for building a MAME arcade cabinet from scratch, but most read like a post-mortem for how the author pieced together their particular setup. What if you just want to convert an old (non-working, I hope) cabinet into a MAME arcade cabinet? Lots of information is out there, but where do you start? Project Arcade is an excellent introduction for building your own MAME arcade cabinet from scratch, and compiles lots of material into one comprehensive book." Read below for the rest of Craig's review. Project Arcade author John St. Clair pages 476 publisher Wiley rating 8/10 reviewer Craig Maloney ISBN 0-7645-5616-9 summary An excellent primer for anyone who is looking to create their own MAME arcade cabinet.

Project Arcade is split up in to five parts. The first part describes the planning process, and comprises complete plans for building an arcade cabinet from scratch. The second, third, and fourth parts are a list of parts and design decisions for the hardware for your MAME arcade cabinet, from the control panel and computer, to the speakers and monitor. The fifth part is a summary of various "off-the-shelf" solutions for purchasing a complete MAME-ready arcade cabinet, as well as links to other "inspirational" projects. Obviously, if you're building the MAME arcade cabinet from the wood up, and outfitting it with your own hardware, then most of the book will be applicable to you. I found all sections to be very valuable, and regardless of which direction I take (build or buy) I'll be more informed when I finally devise my plans and make my purchases.

One thing that stood out in Project Arcade was the thoroughness of the book. Unlike some "build your own arcade books", Project Arcade contains complete plans for an arcade cabinet, from start to finish, including lists of all of the materials. I unfortunately didn't build the cabinet, and am not an expert on woodworking, but the plans looked complete and well thought out. At the very least, it left me with the impression that this was something that I could likely handle with some help. The part I am a little more familiar with (the electronics) was quite fascinating. The book catalogs a great deal of hardware available to the arcade-cabinet builder, and there were parts that I didn't know were available, such as screw-terminal keyboard adapters (no more taking apart cheap keyboards for me). The author details many different joysticks, trackballs, and button choices available, with thoughtful discussion on the pros and cons of each choice. I felt through most of the book like I was being guided by someone who was passionate about building excellent MAME arcade cabinets, and had a lot of knowledge to share. Even the section on pre-made cabinets was carefully put together, with the benefits of each cabinet design explained thoroughly. There are also copious amounts of photos, so you'll know exactly what it is you're looking at. Also, where applicable, there are diagrams and charts to aid and assist.

Unfortunately, the strengths of Project Arcade are also part of its weaknesses. There are a LOT of parts described in the book. After a few pages of the same type of part, my mind started to wander. While the descriptions are comprehensive and insightful, I found myself after a while thinking "I get it already". Detailed descriptions of taking apart keyboards and soldering to them to me seemed obvious, but I can see why the author decided to take the time to explain the process more thoroughly for those who may not be as comfortable taking apart something electronic. Also, the book focused mostly on the hardware for building a MAME arcade cabinet. I would have appreciated the same depth of discussion on the software available to complete the project, mostly because I think the author could have brought some very insightful recommendations on what software to use with the MAME arcade cabinet.

When I build my MAME cabinet, be it a conversion of an old (non-working) cabinet, or from scratch, Project Arcade will definitely be the book I use on that project. While the descriptions can be a bit verbose, the book delivers a very thorough and insightful perspective on what I should be looking for when envisioning what my completed MAME cabinet should be. Much like a do-it-yourself book for remodeling your bathroom, the book can only provide you guidance; the finished project is up to your creativity and imagination. Project Arcade is that guide to building yourself the perfect MAME arcade cabinet.

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

Craig Maloney writes "It's hard to imagine that over 35 years ago, video games were relegated to large computer rooms with a small dedicated computer following. With the explosion of the video game industry, characters like Pac Man, Donkey Kong, and Mario have achieved a cultural celebrity status. There has been a lot of interest lately in Classic Games and the Classic Gaming era. From the efforts of books like Supercade and Leonard Herman's "Rolenta Press" offerings, to sites such as Digital Press, AtariAge, and Good Deal Games, classic games are once again capturing the hearts and minds of those who experienced classic games first hand, and those experiencing classic games for the first time. Retro Gaming Hacks is a treat for both retro gaming enthusiasts and the retro-curious wondering what all the fuss was about." Read the rest of Craig's review. Retro Gaming Hacks author Chris Kohler pages 472 publisher O'Reilly rating 10/10 reviewer Craig Maloney ISBN 0-596-00917-8 summary An excellent guide to all forms of Retro Gaming

Retro Gaming Hacks is another entry in O' Reilly's "Hacks" Series, The "Hacks" Series is an ever-growing set of books with focused attention on a particular topic, like Astronomy, Mental Improvement, or even Halo 2. Each book contains article-length "hacks" of varying difficulty. Some of these hacks may even involve taking the cover off of some electronic device and voiding the warranty on the device. The format allows for quick reference to a particular topic, and the authors present a casual, expert discussion about the topic.

Retro Gaming Hacks begins with a chapter on acquiring actual classic gaming hardware. No matter how good emulators get, there is no experience like playing a classic game on the hardware it was designed to be played on. The author describes the places one can go to pick up hardware, and gives good advice for potential consumers on what to look for and what to avoid when making the final purchase. Next the book discusses a few classic console systems in detail, starting with the grand-daddy of them all: the Magnavox Odyssey, and continuing with the myriad of Pong clones available. After the Odyssey, the book features the game system that defined classic gaming for a generation: the Atari 2600. The author is a bit critical of the system and the games, preferring the Colecovision instead, but the overview of the Atari 2600 is a good introduction to the hardware and some notable games for the system (although I would have omitted mentioning Coleco's dreadful port of Donkey Kong in favor of Pitfall or the incredible Solaris). Other "Golden Era" systems are briefly mentioned, including the Mattel Intellivision, Coleco's Colecovision, the Atari 5200 and 7800, and GCE's Vectrex. The author continues the hardware discussion with several pages on the Nintendo Entertainment System, with several pages on the NES and it's Japanese counterpart: the Famicom. Hack #6 describes the process for repairing the "toaster" NES systems, while the latter part of Hack #5 includes a description of the interesting Neo-Fami adapter for the Game Boy Advance. Also included in the chapter are tips for buying full arcade games as well as JAMMA cabinets. The chapter rounds out with a description of the Holy Grails of classic gaming. (If you find any of these, please send them my way. Thanks!)

The next chapter describes the cheaper way of playing lots of classic games in one location. Many manufacturers have introduced "X in one" TV game systems, which contain one or more controllers, that hooks up to a standard television. The author provides a very comprehensive list of the currently available "X in one" game collections, pointing out the pluses and minuses of each in great detail. Similarly, the synopsis of the classic gaming collections for modern consoles is very thorough (although I'm uncertain if the issue the author raises about the Pac Man patterns relates to a conscious reprogramming of the games, or the differences between the Midway released versions of Pac Man versus the original Namco versions). Ending the chapter is a series of tips for finding hidden classics in current console games (easter eggs), like the arcade Star Wars games in Rebel Assault III, or the hidden NES titles in Animal Crossing. There were several games I wasn't unaware were hidden, and the author helps the search by providing details of how to find each one.

The mid-section of Retro Gaming Hacks darts back and forth between classic game and computer emulation on modern hardware, and restoring classic computers to functioning status. Chapter 3 discusses MAME, and the various interfaces for running MAME. Installing MAME under Windows, Macintosh, and Linux is covered in depth, as are several graphical interfaces for using MAME under each platform. There are also pointers for running MAME on the x box, as well as creating a self-booting MAME CD. There's even mention of the rather odd project known as LASER-MAME (think vector-based games like Asteroids played using LASERs). Lest we think of MAME as just a way to play semi-legal arcade games, the book has pointers to several legal arcade ROMs, such as Gridlee, Robby Roto, Poly Play, and several homebrew arcade games. There are also tips for purchasing legal ROMs, as well as tips for caring for your ROM collection. No section on MAME could be complete without discussing arcade controllers, and Retro Gaming Hacks includes pointers to the Hot Rod, X-Arcade and Slik Stik, as well as a how-to for creating your own controllers from scratch. Chapter four continues with emulations for many classic console game systems using MESS. Also covered in this chapter are several methods for copying games to actual hardware, as well as several emulators for PDAs and Smart Phones. Chapter five continues with classic computers, both in getting the actual hardware running optimally, and in emulating the hardware on modern machines. (There's even a section on getting the Atari 8bit computers running on a Dreamcast). Chapter 6 tackles text adventures, with a healthy section on the INFORM engine from Infocom (with a hack on how to write your own INFORM games. Too cool!) Chapter 7 deals with everyone's favorite gaming operating system DOS, from getting FreeDOS running on actual hardware, to using the "why waste a whole system on DOS" alternative, DOSBox. (And just in case you wanted to develop some games in DOS, there's several hacks for doing just that, too). There's an incredible amount of information in these chapters, with just about every game system imaginable covered. (Yes, even the incredibly crappy RCA Studio II).

Rounding out the book are sections covering creating your own games. There's a brief bit of information on creating retro-style games in Flash and SDL, as well as sections for developing on the Atari 2600 and the Game boy Advance. While this section could easily be covered in separate books, the authors do an admirable job of creating a good introduction to the tools required to start developing your own games.

Lest a book on retro gaming concludes without some game hints, Retro Gaming Hacks finishes off with the pattern from Pac Man, the minus world from Super Mario, and some tricks for Leisure Suit Larry. The Pac Man pattern is only for the first half of the first level, but it does work. (All in the name of research. :) )

Retro Gaming Hacks is a book that I can't say enough about. I'm one of the co-organizers for CinciClassic, and am relatively active in the classic gaming community. I can heartily recommend this book for anyone from the casual newbie to the classic gaming junkie. The resources mentioned in the book are the same resources I would recommend to anyone to satiate their classic gaming curiosity. While some may scoff and say there's plenty of gaming resources available online, Retro Gaming Hacks provides a great resource for finding things you weren't even looking for. (I know I would never have thought to emulate an Atari 800 on my Dreamcast, nor would I have ever thought that I didn't need to gut a keyboard in order to make my own MAME controller). There's something for every gamer, whether you were weaned on the Coleco Telstar arcade, or began your journey with Ultima IV. Retro Gaming Hacks is a fun book and I highly recommend to anyone who has even a remote interest in classic gaming.

(This review was written before CinciClassic 2006 occurred. I was so impressed with the book that I asked O' Reilly if they'd send a few copies for CinciClassic 2006. Their sponsorship of CinciClassic in no way swayed the reviewer or the review.)"

You can purchase Retro Gaming 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.

Craig Maloney writes "You've no doubt heard about Ajax. Practically every new and exciting application on the web uses some form of Ajax. Google's suite of applications (GMail, Google Maps, etc.), Amazon's A9 search engine, and Netflix use Ajax interfaces to give the user a better browsing experience. By using some pretty basic innovations to current technology, browsers can now deliver content in ways unimaginable only a few short years ago. Foundations of Ajax provides developers who haven't taken the time to look into Ajax a hands-on guide for quickly leveraging these technologies in their own applications." Read on for Craig's review. Foundations of Ajax author Ryan Asleson and Nathaniel T. Schutta pages 273 publisher Apress rating 8/10 reviewer Craig Maloney ISBN summary A good first-look at Ajax and client-side development using JavaScript, HTML, and CSS.

Foundations of Ajax starts with a brief history of interactive web-applications, starting from the crudest CGI and Java Applets, and chronicling various interactive technologies (Javascript, Servelets, ASP, PHP, Flash, DHTML, and the various XML browser languages like XUL, XAMJ, etc.). Ajax seems like another acronym in a sea of acronyms, but the authors quickly point out why Ajax can help with the development cycle. Ajax allows the server to validate the user's input, without creating ugly and messy JavaScript validation rules, and it allows the server to use the same rules for input validation on both the client and the server. Unfortunately, Ajax does break some of the conventions users have grown accustomed to in using traditional web applications. XMLHTTPRequest requests aren't stored in the browser history, and it can be confusing to the user to determine what changed on the page after refresh. Issues aside, the book is very encouraging on the prospects of using Ajax in web applications, and invites the reader to use Ajax where it makes sense.

Chapter 2 talks about the request method that makes Ajax possible: XMLHTTPRequest (XHR). The XHR methods are explained with several examples that detail the fundamentals occurring with the request. The examples are very clear, and the entire process is laid out in careful detail, although the Dynamic Object Model (DOM) is mentioned, but not explained until the end of the chapter.

Chapter 3 delves into server communication. It's interesting to note that the authors haven't instantiated a server yet for their Ajax communication, and for the balance of chapter 3, the server is replaced by text files. It's not until the GET/POST examples that the authors start using Servelets. While it may seem strange for the authors to be talking about client/server programming without instantiating a server, it does allow the developer to get their proverbial feet wet without battling server configuration issues. The chapter starts by introducing innerHTML, but then moves to using XML DOM for data transfer from the client. From there, the authors demonstrate a few examples of the server sending XML to the client, and the client sending XML to the server. Happily, the authors weren't content to leave us parsing XML using JavaScript, instead they finish up the chapter by introducing the JSON framework with a few examples.

Chapter 4 is really where the book starts doing very interesting examples with Ajax. It's also, coincidentally, the largest chapter in the book, and the chapter readers will find the most useful reference examples. The book steps through the creation of examples of Simple date validation, Reading response headers for a simple ping application, Dynamically Loading List Boxes, Automatically Refreshing Pages, Progress bar (a personal favorite), Tool tips, Accessing Web Services using REST, and Auto complete. Each example is introduced with a real-world working application as an example (such as the auto complete feature of the Google search engine), and could easily be implemented in a developer's application. I found myself thinking of ways to enhance my code using these techniques.

Following chapter 4's examples, the chapters on creating a developer toolbox, testing scripts using JsUnit, and debugging Javascript seem a bit of a let-down. Chapter 5 outlines various packages for helping JavaScript coders to better spot errors in their code, and create documentation using the JavaDoc-like application JSDoc. There is also a mention of an application for crunching and compressing JavaScript code, as well as the excellent Web Developer Extension. Rounding out the chapter is a brief history of JavaScript, and some advanced JavaScript techniques. Chapter 6 introduces JsUnit and Unit Testing. Chapter 7 talks about JavaScript debuggers, such as Microsoft's Script Debugger, and the very powerful Venkman. The Venkman tutorial is very good, and would be a great starting point for anyone wanting more information on how to use this great tool.

Chapter 8 rounds out the book with the typical "for more information" sites to visit. However, in true Steve Jobs "One more thing" fashion, the authors not only plug their Ajax Framework, but also create a browser-based, Macintosh-like Dashboard application with four widgets. I was all set to finish the book, but the authors quietly slipped the best for last in the final pages of the book, bringing out a complete Mac OSX-like "Dashboard" windowed-environment in a browser complete with the drag-and-drop elements I've most associated with Ajax sites. This is by far the most complicated project in the book, and it make for an excellent ending to an already fine book.

Foundations of Ajax is a great starting point for developers wondering how they can incorporate Ajax into their own web-based projects. One minor gripe I had with this book was the examples looked pale in comparison with their real-world models, but design is hardly the focus of the book. Where Foundations of Ajax shines is it's no-nonsense introduction, implementation, and expansion of the basics of Ajax programming, leaving the reader confidently ready to utilize the concepts within. The authors have seen the potential of Ajax, and competently convey their expertise and enthusiasm for this technology."

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

Craig Maloney writes "By now most readers have probably heard about Firefox, the Open Source browser that poses a serious challenge to Internet Explorer. They've probably even installed it on a few machines, and no doubt have customized it pretty much to their liking. They're pretty comfortable with how it works in their day-to-day browsing activities. Plus, Firefox is pretty open, and about:config, extensions, and themes have many pages dedicated to their use. What more could there be to Firefox? Firefox Secrets is a collection of tips and tricks to help wring out that last kernel of performance from Firefox, with specific ways to increase users productivity with Firefox. It also contains plenty of tips for new Firefox users to guide them to learning what Firefox is, and how it can improve their browsing experience." Read on for Craig's review. Firefox Secrets author Chean Chu Yeow pages 297 publisher Sitepoint rating 8/10 reviewer Craig Maloney ISBN 0-9752402-4-2 summary Firefox tips and techniques for new and experienced users.

Firefox Secrets presents the material in a well thought out manner. Each chapter starts with a specific task in mind, with helpful tips in performing that task listed throughout the rest of the chapter. In the chapter entitled "Revisiting Web Pages" (something we are all bound to do at some time in our lives), Firefox Secrets starts the chapter with sections on importing bookmarks from other programs, creating new bookmarks, and using the bookmark manager. (Pretty basic stuff which most Slashdot readers have no doubt mastered). The power, though, lies in the rest of the chapter, where the book lists out how to add a bookmark for a group of tabs, how to create several types of keyword bookmark, how to use the bookmarks tool bar, and how to use the bookmark manager and sidebar. It then talks about Firefox's RSS and Live bookmarks, and how to create them using the RSS icon, and create them manually. Finally the chapter finishes off with the cookie and history managers, as well as the password manager. Each section is described in detail with clear directions on how to use the feature, and clear explanations on why readers would want to use the feature.

Expert users need not worry, though, as this book has plenty for them too. One of the more powerful features of Firefox are the Extensions, which allow incredible recognizability in Firefox. The chapter on Extensions starts with an introduction to what Extensions are, and why they're so important. Next the author describes installing an extension, and uses the miniT extension (an extension that allows drag-and-drop tab placement) as a sample extension to install. The author begins by directing the browser to the extensions site, installing the extension, and configuring the extension once the browser has recognized it. From there the author discusses installing from sites other than the Mozilla Extensions site, installing from a local file, and using the extensions manager to track and configure extensions. As someone who has installed many extensions that proved less than useful, or prevented Firefox from even starting properly, the next section on uninstalling and entering Firefox's safe-mode could prove profile-saving. (I have had several occasions where knowing about safe-mode would have saved me a half-hour's work in rebuilding my profile). The author moves from this introductory material to a list of his personal favorite extensions. Unless the reader has an RSS feed tuned to the Mozilla Extensions site, there's bound to be several extensions that the reader will find useful. (I downloaded the Spellbound Spell Check, and Download Status bar extensions during the course of this review).

Of course no book on the secrets of Firefox would be complete without mentioning about:config. about:config holds a treasure-trove of configurable options for Firefox, many of which are not self-evident without a guide of some form. Firefox secrets does not provide a comprehensive look at about:config, but instead shows what about:config is, shows how to use it, and presents a few neat tips that can be set by about:config. Other somewhat hidden preference features include the .css and .js files under the user profile. Firefox Secrets quickly glosses over some key tips, such as CSS examples for marking unread tabs, and shifting the sidebar to the right. Also included are tips for customizing the user interface, and incorporating web development features which developers will no doubt find extremely handy in their daily development rituals. The book finishes off with best practices for downloading and using the Firefox nightly builds, and what sorts of issues to expect.

Some people out there may feel that Firefox Secrets doesn't offer any tips that can't be found on the web. It's a fair assessment that some of the ideas presented in the book should be pretty routine for expert Firefox users. However, unless you have RSS feeds to every Mozilla development site, and maintain an encyclopedic knowledge of every configurable doo-dad and Extension, you'll likely find many good tips and best practices for enhancing your browsing experience. I'll admit I was skeptical this book would provide me anything of value, and I've been pleasantly surprised at how insightful this book is. Firefox Secrets balances between beginning users who have yet to install their first extension, and experts who want to take their browsing to the next level."

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

Craig Maloney writes "Artificial Intelligence (AI) is a very hot topic today in computer circles because of the interest in modeling behaviors on machines that we find in nature. Many books have been dedicated to studying and expanding the field of AI, but generally fall into two categories: those that concentrate on AI as a research topic, and those that concentrate on AI in the field of game development. Artificial Intelligence for Computer Games (AI for Computer Games) is unique in how it takes classical AI and merges that knowledge into AI for game development. It's an approach that will be fascinating to those currently studying AI, but the approach limits the usefulness of this book to a select audience of AI researchers interested in game development." Read on for the rest of Maloney's review. Artificial Intelligence for Computer Games author John David Funge pages 127 publisher A K Peters, td. rating 6 reviewer Craig Maloney ISBN 1568812086 summary An introduction to Gaming Artifical Intelligence

AI for Computer Games begins with a brief introduction to the historic roles that AI has played in games such as Pac Man and Mario, and how these Non-Playable Characters (NPCs) achieved fame through their roles as NPCs. The NPCs play important roles in games, and their behavior can ultimately determine if the game is entertaining or frustrating. The author then describes the differences between the field of Artificial Intelligence as compared with Gaming Artificial Intelligence. Later he shows how these two fields can intertwine with each other, and how Gaming Artificial Intelligence can be useful to AI researchers via game-playing robots and other similar experiments. The author also introduces the architecture of the components of a game. They are:

• Game State: The current state of the world
• Simulator: Encodes the rules for how the game state changes, and the rules for the game (physics, etc.)
• Renderer: The display of the game
• Controllers: The player and NPC methods for interacting with the game.

The book then focuses on simulating a gaming environment for the NPCs and player to operate in. The author uses a game of Tag as the game framework for the rest of the book, with the player and the NPCs playing the classic game of chasing and hiding. The roles of the game state, simulator, renderer and controllers are explored in depth in this section.

Next, AI for Computer Games discusses NPC perception. Players in a gaming environment are hindered by what the renderer will display to them, so likewise, the NPCs should not have omniscience in the game. The author recommends a strategy for handling this for NPCs: use the render engine for determining the perception of the NPCs as well. This allows the players and NPCs to work from the same rules. The author also describes how NPCs can handle partial observability, as well as prediction.

The rest of the book deals with the NPCs' abilities to react, remember, search, and learn to the game environment. This is the heart of the book, and provides a good analysis of the various methods available to the developer to model complex behaviors. The section on learning is especially interesting, as the idea of rewarding the algorithm when it performs correctly seems both strange and obvious at the same time (although the author points out that sometimes the algorithm can do undesirable things in order to obtain that reward). There are many ideas in these sections for perfecting the AI of the game, and the author expertly describes each one and where each would best be used.

AI for Computer Games was both enlightening and frustrating at the same time. The author obviously possesses a lot of knowledge in the AI field; the frustration is in his telling of that knowledge. The book reads much like an academic paper on AI applications in games, and could put off many potential readers with its rather dense descriptions of complicated material. The book also suffers from being rather short. The book is 127 pages in total length with code snippets, diagrams, and other page artwork. The brevity makes the book easy to pick up and read for a bit, but the density ensures you'll be re-reading several chapters in order to catch what the author is trying to convey. The code snippets also suffer from brevity. The code snippets are in C++, but are primarily constructors, with precious few methods defined. The author has excellent ideas; using an environment where the player and the NPCs are equals removes much of the complexity for the example AI to handle. Unfortunately the execution in this book leaves me wanting more.

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

Craig Maloney writes "Just about everyone out there who has ever typed #!/usr/bin/perl has encountered Learning Perl (otherwise known as "The Llama Book") in one form or another. You may have learned some of the intricacies of the language from this tome, or you've seen someone recommend this book to potential Perl programmers on-line. Learning Perl is generally in the top three recommended books for new Perl programmers, next to Programming Perl ("The Camel Book"). Now in its fourth edition, Learning Perl returns with updates covering the stable 5.8 series of Perl. The changes are subtle, but the improvements make for a clearer and more readable book." Read on for the rest of Maloney's review. Learning Perl, Fourth Edition author Randal L. Schwartz, Tom Phoenix and brian d foy pages 304 publisher O'Reilly rating 9 reviewer Craig Maloney ISBN 0596101058 summary The fourth edition of the classic text for learning the Perl language.

When I was initially introduced to Perl, I was one of those who was recommended to read Learning Perl. I picked up the initial edition (with the mauve binding), and began my journey into Perl. What I found was a dense, hard-to-follow introduction to the language, with the experienced Perl programmer in mind. I realized that the tutelage of this experienced programmer/author might be useful, but I opted for other books instead. As others looked to me for book recommendations, I recommended other works for people looking to immerse themselves in Perl, and relegated Learning Perl to the section of my library where live books with a steep learning curve (similar to the learning curve experienced by many with Kernighan and Ritchie's classic The C Programming Language). Like The C Programming Language, however, a full grasp of the language is not achievable from texts where the central focus is to avoid using the lingo and customs of those who are more familiar with the language. Only by full immersion in the culture of the language can one become fully proficient in that language. What's new? Learning Perl 4th edition has been updated in several ways from the previous edition. The text has been updated to reflect Perl 5.8, although this book doesn't introduce any 5.8 specific concepts. The new edition was reorganized from the previous version. The chapter on Regular Expressions is enhanced, and file handles are introduced in the I/O Basics chapter. CPAN is introduced in Learning Perl, since it has become much more important to beginners. The chapter on flat-file databases (DBM/DBM Hashes) didn't make the cut for this edition, but a good portion of the chapter made its way into Chapter 9 (Processing Text with Regular Expressions). The book has a cleaner feel to it, and flows without the erratic feel of the previous editions. What's good Learning Perl could rightly be called A Tourist's Guide to the Perl Culture. The material is immersive, and teaches Perl using the verbal language of a Perl programmer. No attempt is made to dumb down the material. This leads to sentences in the book like the following: Alas, these aren't words as you and I are likely to think of them; they're those \w-type words made up of ordinary letters, digits, and underscores. The \b anchor matches at the start or end of a group of \w characters. The previous sentence makes perfect sense for those who have already grasped the fundamentals of regular expressions, but for those who aren't quite up to speed, the previous sentence warrants further study. This can be a blessing or a curse for some. Ultimately, it forces the reader to understand the Perl culture which can only improve the reader's understanding of Perl. Also of note are the footnotes. Almost every page in the book contains footnotes commenting (sometimes sarcastically) about the topic at hand. Sometimes the footnotes can be distracting, as your eyes will busily look for the next humorous footnote, such as this little gem: And /,{5}chameleon/ matches "comma comma comma comma comma chameleon". By George, that is nice. What's Bad The only complaint I can level at Learning Perl is that there could be more explanation for some of the concepts in the book. In the section called "More Regular Expressions," the book presents the following example:

Here's the text:

I'm talking about the cartoon with Fred and Wilma!

And here's a substitution to remove those tags. But what's wrong with it?

s#(.*)#$1#g;

The problem is that the star is greedy. What if the text had said this instead?

I thought you said Fred and Velma, not Wilma

In that case, the pattern would match from the first to the last , leaving intact the ones in the middle of the line. Oops! Instead, we want a non-greedy quantifier. The non-greedy form of star is *?, so the substitution now looks like this:

s#(.*?)#$1#g;

And it does the right thing.

Unfortunately the less astute reader may not understand what exactly happened here. One line of output with the end result would help clarify what this regular expression did.

What's in it for me? Learning Perl would rightly be regarded as one of the classic texts for Perl programmers to read through at least once in their Perl careers. The book is chock-full of useful information, and even experienced Perl coders would do well to at least leaf through the pages of this book for paradigms to help their coding. Absolute beginner programmers would likely find this text a little over their heads, but intermediate programmers will find Learning Perl a valuable resource in their road to proficiency with Perl. You can purchase Learning Perl, 4th 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.

Craig Maloney writes "Anyone who codes in Perl can relate to working on other people's code. Sometimes the code will thankfully include "use warnings" and be a joy to maintain. More likely, though, the code will have so many warnings that the useful output is long gone in the stratosphere of your scroll buffer. Even good code written for earlier versions of Perl can become aged and decrepit, requiring elderly modules that may or may not work with newer versions of Perl. Maintaining this code can be a hassle, but fortunately Perl Medic: Transforming Legacy Code (referred to for the duration of the review as Perl Medic) provides some very useful tips for getting through these migrations, and will help the next person maintaining your code." Read on for the rest of Maloney's review. Perl Medic author Peter J. Scott pages 312 publisher Addison Wesley rating 8 reviewer Craig Maloney ISBN 0201795264 summary A great collection of Perl wisdom and tips for experts and other patient Perl acolytes.

One of the goals of Perl Medic is to transform code from stylistically poor and unmaintainable into stylistically sound, maintainable and testable code. The format of Perl Medic is very similar to books like The Pragmatic Programmer or The Practice of Programming. Perl Medic shows the reader best practices by example. Some of the chapters are checklists of practices that will help improve your ability to manage and wrangle the code, while others are lists of patterns and practices you should avoid, and should replace with the examples provided. This format very readable, and provides an excellent forum for gleaning what ways to improve the code.

Perl Medic is designed with experienced coders in mind. Topics are presented as if the reader may be using these ideas already in their code, whether good or not. While the advice is good, the presentation may be confusing for beginner and intermediate programmers who aren't intimately familiar with the concepts. I found myself re-reading several topics to try and grasp what the author was trying to convey. After several readings of the section on test harnesses, I still needed help, and ran to the Perl documentation to better understand what the author was saying. Certain advice is also presented, only to have it countered in the next section. Most Perl programmers are familiar with the '-w' switch, which turns on warnings in a Perl program. The pragma 'use warnings' is introduced as a way to turn on warnings for just the code being worked on without displaying the warnings of the modules included in the program. In the next section, the author points out that it might be a good idea to put '-w' in there to see if there are any issues in the modules you may be including. While this advice may be intuitive for experienced Perl coders, the beginner may be confused. "Should I use '-w', or should I use 'use warnings'" she may ask herself.

The book also suffers from a case of being too brief in some sections. In section 2.3.1 (Gobbledygook) the reader is directed for help on how to turn a partially obfuscated program into more intelligible code; a very useful skill indeed. The author redirects the reader to section 4.5 where the utility perltidy is discussed with further detail, but before ending the section, the author also introduces the module 'B::Deobfuscate' along with a URL. No mention of how to use it is provided. In section 6.4 (Debugging Strategies) the author gives advice on how to debug a program. His advice: "Divide and Conquer". While there is debugging advice throughout the book, it's a little frustrating to see a section specifically designated "Debugging", with only one subheading under it. The organization of some of the topics feels artificial, and perhaps should be reorganized in future editions.

Underneath these faults, though, Perl Medic is a great book. Chapter 11 (A Case Study) should be required reading for coders inheriting Perl projects. This chapter is a blow-by-blow account of the author's work in transforming a simple LDAP application from Perl 4 into a robust Perl 5.8 application. The author is very candid about what decisions were made in the code transformation, and why certain elements were addressed in the way they were addressed. One particular element is an elderly module used for the LDAP lookups themselves. The author details the process used to determine a better module to replace this module, and guides the reader through each of the steps required to change the code to use this new module. The decisions the author uses to make this code work under the new environment are enlightening for anyone planning a migration of Perl code into a newer environment. Chapter 7 contains the versions of Perl from Perl 4 up until 5.8.3, and elaborates on what changed between the versions (very helpful for those who are planning an upgrade from 5.003 to a more recent version of Perl). Chapter 9 (Analysis) has very useful tips for not only debugging you program, but for using the Perl Debugger and getting the most out of your debugging session.

Perl Medic is recommended for anyone who is tasked with maintaining or writing Perl Code. While the examples are written with experienced coders in mind, beginners will do well to use this book for areas to focus on while they learn the language. Inheriting code can be a daunting task, but with a book like Perl Medic, you'll have the tools at hand to help ease the work ahead into a more manageable task. And you'll make it easier for "the next guy".

You can purchase Perl Medic: Transforming Legacy Code from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

Craig Maloney writes "Growing up, I was immersed in the science fiction tales of my time. Space travel and laser guns were fascinating, but even more fascinating to me were the science fiction movies that involved robots; the complicated machines that performed great feats of impossible skill, dexterity, and amazing computation. When Tomy and Heathkit released their personal robots, I tried in vain to con my parents into believing that a personal robot might improve our quality of life in some way (mine more than theirs because I would obviously have been the skillful programmer of these robotic devices). While Robot Building for Beginners won't have you creating anything as complicated as C3PO or even a HERO Jr., it will show you how to build a simple robot from the ground up, and will help those who don't have the rudimentary electronics experience required to master these skills." Read on for the rest of Maloney's review. Robot Building for Beginners author David Cook pages 568 publisher Apress rating 10 reviewer Craig Maloney ISBN 1893115445 summary A complete "back-to-basics" guide to designing and building a simple robot

Beginner means beginner I didn't actually build the robot presented in the book, but after reading it, I feel confident that I wouldn't have any problems building it.

Robot Building for Beginners is not a misnomer. If you have an area set aside in your home that you call your electronics lab, and know how to use breadboards, multimeters, and soldering irons, you may not get as much out of this book. If, however, you have to clear off your project area in order to eat and don't know the first thing about where to begin to build a robot, then this book will be a roadmap on your journey to proficiency. Loads of pictures and very frank discussion make this book a pleasure to read, and a real learning tool.

The book begins with a brief introduction to the robot hobby and some interesting robot pieces and projects. Next is an informative chapter on where to purchase the parts for the robot, with an emphasis on getting parts cheaply. The author also gives some hints on how to order parts cheaply through quantity discounts as well as part substitution. The book then takes a brief detour onto the subject of safety, with such sage advice as using items safe for the reader (lead-free solder, safety goggles, and dust masks) and items safe for the electronics (circuit breakers, grounded plugs, and following instructions). The author also briefly cautions against making dangerous robots (like the ones on BattleBots) because they can not only be very dangerous, but can also be hazardous to test (sorry, guys. :) ).

From there the author dedicates two chapters to selecting and using one of the more important pieces of equipment for electronics projects: the multimeter. The author presents some sage advice for selecting an appropriate, accurate mutimeter within your budget. I used this knowledge to pick out a very nice, affordable multimeter of my own (a Triplett 9025, for anyone who is interested).

Next, a brief discussion on numbers and units, followed by a chapter on robot line-following rounds out the basics section of the book. The sandwich robot (so named because the author uses a sandwich container for the body) is introduced in the chapter on line-following, and forms the basis for the project that is built through the rest of the book.

Parts is parts

The next few chapters form an excellent introduction to the electronic components that make up the sandwich robot. From an informative discussion on batteries (the results may surprise you. It certainly changed how I look at batteries) to components like breadboard, transistors, variable resistors, and IC chips. Each chapter introduces a particular component, describes what it does, and give some very useful tips for using the component effectively. The components are introduced by demonstrating how they fit together in simple circuits. I found myself learning a great deal about each of the components and how they fit together. Next the book tackles the more mechanical aspects of the robot (motors, tires and couplers) and how to select, work, and assemble them into the final project. Two chapters follow, dealing with everyone's favorite topic: soldering. The first chapter handles the equipment needed for soldering, while the next chapter handles how to solder properly. Even the most nervous soldering neophyte will feel right at home with a soldering iron after these chapters.

Putting it all together Time to put the knowledge together! The next chapter tackles the motherboard of the robot. A schematic and lots of pictures with layouts and hints help make what could be a difficult process into something less frightening. Cleaning and testing the motherboard rounds out the last part of the chapter. Then it's on to the body construction and the launching of the robot! The last chapter talks about other goodies such as LCD screens, real microprocessors, and other components worth checking out. There's also a quick mention of robotics clubs and projects the author would like to take on. The author is a robotics enthusiast, and it shows with his candid writing. What's in it for me?

Robot Building for Beginners is a great resource for those who may not have a background with electronics. I found myself learning all sorts of useful information from this book. Those who may not be interested in building a robot will still find this book useful for a good primer in electronics and electronic circuits. They may also be convinced by the author's sheer love for robot tinkering to explore the world of robotics. People with an electronics background may not be interested in this book as much as a rank beginner, but don't let that dissuade you from checking out this excellent book. I can easily recommend this book to anyone with a passing interest in electronic circuits and robotics. The robots you build from this book may not be able to serve drinks, or repair a damaged X-Wing fighter, but you'll definitely have fun building them.

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

Craig Maloney writes "Many Slashdot readers know how to secure a network, and many know how to determine if a security breach has taken place. Fewer readers, though, would know how to handle a security breach if corporate assets were involved. How would you cooperate with law enforcement when a crime has been committed on a computer?" For more questions, and the rest of Maloney's review of Warren G. Kruse II and Jay G. Heiser's Computer Forensics, read on below. Computer Forensics author Warren G. Kruse II and Jay G. Heiser pages 392 publisher Addison Wesley rating 8/10 reviewer Craig Maloney ISBN 0201707195 summary A good reference for what to do when computer crime happens

How do you get the evidence off of a computer, ensuring that it's capable of withstanding a defense lawyer's scrutiny? Maybe you would just unplug the machine and put it in storage awaiting a detective's arrival, but is that what we should do? What if the evidence is on a production server that can't be simply unplugged and put into storage? What if that evidence is slowly being erased as files are created and deleted on that server? How do you help build the case against a computer criminal? Hopefully you'll never have to worry about computer crime in your home or workplace but if you do have to worry, Computer Forensics will be an asset to your part of the investigation.

Who is this book for? Computer crime isn't simple -- it can range from damage done by simple script kiddies to corporate espionage by disgruntled employees, as well as sophisticated, multi-homed attacks by skilled crackers. Computer Forensics tries hard to cover a lot of these areas. The book includes a chapter dealing with laptop hardware, as well as ones on data hiding and encryption, and further chapters on putting evidence together and dealing with law enforcement. While these topics may be of interest to the Slashdot crowd, Computer Forensics focuses more on broad topics of interest to computer detectives faced with getting up to speed quickly with computer crimes and computer evidence gathering.

Several chapters are downright boring for anyone who has a modicum of computer experience. Finding out where e-mail is stored on Windows and Linux machines, or understanding what a root-kit is and what it does will be pedestrian for many readers. Nestled away between the necessary-but-pedestrian topics, though, are some very useful tools. The authors use netcat with tar to copy files between machines without disturbing the modification times (something I would never have thought to use). Novice users will find a wealth of tools and examples in these chapters. The tools used in the book tend toward open source and free tools, and rely heavily on Linux as the Swiss Army knife for handling file systems and files without disturbing them. Any reader should be able to put together a decent set of tools from this book.

Making it all work

Putting together a good forensic kit is all fine and good, but making sure your evidence holds up to the scrutiny of some high-powered, high-priced defense lawyer is much more important. The last chapter of Computer Forensics gives a brief introduction to the criminal justice system. The authors touch on notifying law enforcement agencies, search warrants, probable cause, interviews, subpoenas, dollar loss guidelines, and testifying as an expert witness, among other legal topics. The appendices of the book have checklists, flowcharts, and an incident report form to aid investigation and evidence gathering. These are invaluable resources for the system administrator of any public machine who needs to deal with law enforcement.

Conclusion Thinking about dealing with courts and law enforcement may not be at the forefront of any administrator's job, but it is a reality any administrator needs to think of and be aware of. Computer Forensics will at least make administrators more aware of what their legal options are, and of the form in which gathered forensic data needs to be presented as evidence. Computer detectives will find a good, if not rudimentary example of what to look for when investigating a computer crime scene. This may not be the most comprehensive book on the subject of computer crime, but it will point you in the right direction to help investigate it should it ever happen to you.

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

Craig Maloney writes "I'm skeptical whenever a publisher uses the words 'Definitive,' or 'Complete,' or (especially) 'Ultimate' in the title of a computer book. Sadly, the typical book so labeled is a jumble of incomplete ideas crammed together with very little depth. Worse, some books do little more than re-print the various command-line switches for the application. Michael Kofler's The Definitive Guide to MySQL (2nd ed.) is just the opposite. There're still lots of ideas crammed inside of the book, but they're carefully explained and expanded. The book weighs in at a hefty 802 pages, with very little fluff. " Read on for the rest of Maloney's review. The Definitive Guide to MySQL author Michael Kofler pages 802 publisher Apress rating 10/10 reviewer Craig Maloney ISBN 1590591445 summary A useful and complete reference to using and programming with MySQL

The book has four sections: Introduction, Fundamentals, Programming and Reference. The Introduction begins with a brief introduction to databases, relational databases, ANSI 92, and how MySQL fits in to each of these. It also touches on the licensing for MySQL (commercial vs. non-commercial usage) and a version roadmap for past and future releases of MySQL. The roadmap is very helpful to know what features are present in the version of MySQL you may be using (or are planned for an upcoming release).

Next, Kofler sets up a rudimentary testing environment which is used through the rest of the book. He does an excellent job of outlining a decent development environment under both Unix and Linux without getting too bogged down in trying to describe every single user interface for accessing MySQL (those are described later in the book). It steps through setting up MySQL, Apache, Perl (with DBD and DBI), and PHP, and also adds phpMyAdmin as a graphical tool to administer the databases. The unit ends with a simple PHP script to handle an opinion poll. This all happens in the first 80 pages of the book.

Fundamentals

The next section expands on the basics learned in the first chapter. First is a chapter on the user interfaces available for using MySQL, starting with the MySQL command-line client, followed by an introduction to several graphical clients (including phpMyAdmin and MySQLCC). Database design is covered in the next chapter, starting with a brief overview of the theory in designing a relational database. First, second and third normal forms are introduced with examples, as are relations (1:1, 1-n, and n-n), data types, and indexes. Once the reader is armed with the theory, the book continues with how to create the tables in SQL, and covers using SQL to examine and manipulate data in "Introduction to SQL." "SQL Recipes" contains lots of useful scripts for handling interesting cases of SQL (like selecting data at random, pivot tables, creating a new table by copying, etc). A special section is devoted to the new InnoDB format, which brings transactions and integrity rules (foreign key constraints) to MySQL. "Security and Administration" complete the Fundamentals unit with topics on user-level security, backing up the data, and replication between two MySQL instances.

Programming

Unlike most books, the programming languages introduced in The Definitive Guide to MySQL aren't introduced with examples as though you have never programmed a computer before. (So beware, if you haven't; this is probably not the right book for you.) The examples start with useful code that assumes familiarity with the language. The examples are excellent, demonstrating how to efficiently get your code connecting to the database. The author covers PHP, Perl, Java, C and C++, and Visual Basic, C# and ODBC. PHP is the real star of the book, though, garnering a second chapter to expand on the earlier examples presented in the book, but the other languages (and ODBC) are given excellent treatment. Fans of these languages will be able to get their programs running with MySQL using the examples from the book.

Reference

The last 100 pages (not including the appendix, glossary and index) contain several references for MySQL. "The SQL Reference" covers the SQL commands that MySQL understands (along with what versions they are valid for), as well as system and session variables and data types. Coverage of the utilities that MySQL uses is in the "MySQL Tools" section. Lastly, the API reference rounds off the book with the functions and variables for each language in an easy-to-use reference. Whew!

Programmers will find excellent examples for linking their programs with MySQL, and developers will find the reference and examples extremely useful for taking their data from creation to deployment. I found this book easy to read and exceptionally useful. The author did the hard work of taking the documentation and sifting through it to bring the useful parts together clearly and concisely. Definitive indeed.

You can purchase The Definitive Guide to 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.