4 comments about Linux Appliance Design: A Hands-On Guide to Building Linux Appliances.

1. First of all, you know that when you see the word "appliance" in this context, you should think more like a router or alarm system (the book uses this as a development framework), not a refrigerator, say. [Although (shudder!) the latter could be a sweet example in the near future.] And, before I write another word I should state upfront: I was a technical reviewer of this book.
   
   I found lots and lots of interest in my "required" reading:
   
   - the authors have developed an API for appliance configuration and control, which they term RTA (Run Time Access). Briefly, a Postgresql library is developed to allow a pseudo-database to store configuration values or issue control commands;
   
   - there's a intriguing chapter on using an infrared remote control as a device to conrol an appliance. It has neat stuff like the observation that one's digital camera can "see" the pulses from a remote control. (Try it at home!);
   
   - the authors cover the ins and outs of the Linux framebuffer device, which is very nice to know;
   
   - the information about SNMP in several chapters is probably the clearest and most succinct I've ever read on this somewhat complicated (dare I say, miserable?) protocol.
   
   It's a fact, there's lot of stuff here you ain't gonna see anywhere else, and with embedded devices you need all the ideas and techniques you can scrape together anywhere you can find 'em!



2. Linux continues to increase in popularity and utility among computer enthusiasts. The combined effort of Linux experts Bob Smith, John Hardin, Graham Phillips, and Bill Pierce, "Linux Appliance Design: A Hands-On Guide To Building Linux Appliances" teaches Linux users how to build better appliances for the Linux systems thereby providing them with more types of interfaces, more dynamic interfaces, and better debugged interfaces. Linux users will learn how to build backend daemons, handle asynchronous events, connect various user interfaces, and so much more. Now even the most novice Linux user can add professional network management capabilities to their applications, build a web-based appliance and a command line interface, build a framebuffer interface using infrared controls as input, as well as manage logs and alarms on appliance. If you have a Linux system, then "Linux Appliance Design" will prove an invaluable, indispensable, thoroughly 'user friendly' instruction and reference manual for getting the most out of your do-it-yourself designer software.



3. It's not just easy to read... it's addictive. Great, thorough examples with wonderful twists will get you started on Linux appliances in no time.
   
   There's really not much to say besides that if you are even remotely interested or curious about the topic, it's a must-have.



4. Bob Smith et al., Linux Appliance Design: A Hands-On Guide to Building Linux Appliances (No Starch, 2007)
   
   Linux Appliance Design is not, for the most part, a bad little book, but it is structurally unsound in one major way. I realize this is a quirk of mine more than anything, and most people who want to read about this sort of thing probably won't mind it, but it bugs me in a major way whenever I encounter it: instead of getting into the nuts and bolts of some parts of the software, the authors chose to go with a ready-made API, and so much of the book's software instruction involves programming that API rather than building something from scratch. If that doesn't bother you, then go right ahead and grab a copy of this. If you'd rather not use someone else's software, on the other hand, the hardware parts of this will be useful, but for the software parts, you'll have to look somewhere else. Not nearly as good-- or comprehensive-- as it could have been. ***

5 comments about Power User's Guide to Windows Development (Programming Series).

1. This book walks you thru the technical side of using Multimedia Fusion in a very easy to follow method. After you follow along this book you will quickly understand how to use Multimedia Fusion to create an application or game.
   
   One of the exciting projects is the complete chat system. Its amazing such a powerful and complex project in VB or C++ can be done so amazingly fast.



2. So you have an idea for a new computer game, eh...
   Now you want to get it off the ground...
   Where do you start...
   
   Well, you could spend a small fortune on a commcercial programming language, pick up a few back-breaking books, study till your brain melts from your ears and then, just then, sit down to program the game engine, not the game, just the engine...
   
   Well, wipe that tear from your eye because there's no need to cry. With Clickteam's The Games Factory 2 and MultiMedia Fusion 2, you can create computer games and application software with a click of the mouse button! Shoot em ups, action adventures, racing, puzzles... File management, website creators, chat programs... Multimedia presentations, multimedia applications... It would take you months, if not longer, to program these from scratch in C++, VB, etc. With Clickteam software, you can do it all with your mouse!
   
   And this book, "The Power User's Guide to Windows Development" by Jason Darby, will show you how. This is the second of two books by Jason, both focusing on MMF. This book delves into more advanced content. CD ROM based menus, chat programs, screen savers, to name but a few topics covered in detail in this book. Jason takes you through all the tasks needed to bring these projects to life and the fact that it's all created with the mouse (well, there is some keyboard use but there no need to learn a single line of programming!!), is just amazing.
   
   If you're a creative person, like me, and you want to create your own software but have always been daunted by the task of learning C++ or the likes, MMF from Clickteam, and this book, are all you need to bring your visions to life!



3. I find that this book spends alot of time repeating over & over each and every mouse click to realize the demo projects and not enough time explaining the concepts and structures applied in these projects. I was a little disappointed in that it didn't really teach me anything I didn't already know about MMF2dev. It would be a good choice for anyone who never used MMF2dev before and has no concept of programming.



4. Multimedia Fusion II can be a little confusing for the first time user, especially if they have no programming background. This book is excellent for such a person. It walks you through step by step many of the common functions of MMF II and how they are used giving you a firm foundation to getting started making your games or other applications.
   
   I would highly recommend starting with this book then going to the second book 'Make Amazing Games in Minutes' by Jason Darby.
   
   Make no mistake just because it is a click programming environment does not mean it cannot produce some amazing programs. MMF II and Developer can make pretty much whatever you want with the time, energy and thought.



5. I thought this book would teach me a lot of advanced programming techniques with Multimedia Fusion 2, but all that it has is an introduction to every tool included in MMF2.
   
   Maybe 3 or 4 of them may result interesting for advanced users, but the other ones are more fitting for newbies.
   
   Not a bad book, anyway, just a bit simple.

4 comments about Regular Expression Recipes for Windows Developers: A Problem-Solution Approach.

1. When I saw the title of this book, I was excited at the prospect of a book filled with detailed regular expression examples. Unfortunately, it didn't pan out that way.
   
   Spread over a whopping 359 pages, the book lists exactly 100 tasks that you can accomplish with a regular expression. As the solution, the author not only gives a regular expression, but also a complete source code snippet in C#, VB.NET, JavaScript and VBScript. Not all solutions have snippets in all languages. Some solutions also have a snippet for ASP.NET.
   
   Obviously, the examples have a heavy bias towards Windows and .NET. If you're using open source languages, you may want to look at this book's precursor "Regular Expression Recipies" instead. It's essentially the same book, with almost the same list of recipes, but with examples in Perl, PHP and Python.
   
   Each recipe also has a "how it works" section, essentially transcribing the regular expression in English, similar in approach to RegexBuddy's plain English regex trees, though the book uses a flat description rather than a tree. The descriptions are brief though. While all the source code snippets easily take up two or more pages per recipe, the explanation is often barely half a page long.
   
   The book does suffer from some sloppy editing. The regular expression in the source code snippets isn't always identical to the one in the description. E.g. in recipe 6-21, the JavaScript snippet uses named capture, and the explanation then proceeds to explain a regex without named capture (which isn't supported by JavaScript). Most of these issues are trivial, but it isn't good for a book that's obviously aimed at beginners.
   
   Most of the recipes solve rather basic problems, organized in six chapters. The first, "Words and Text", deals with finding blank lines, repeated words, words at the start or end of a line, etc. The "URLs and Paths" chapter has examples for finding URLs and file paths, and extracting bits from them. The "CSV and tab-delimited files" has a few recipes for converting between the two and extracting fields.
   
   The "Formatting and Validating" chapter shows how to validate numbers, currency, dates, phone numbers, addresses, etc. The "XML and HTML" chapter has recipes for matching and replacing tags and attributes. Finally, the "Source Code" chapter has a bunch of recipes for manipulating software source code and related files. Most of these tasks are odd jobs that .NET programmers may want to do sometimes.
   
   The book would have been a better deal if it had focused on regular expressions, and left out the many lines of source code, not to mention the redundant copies in several languages. Without the source code, a book of the same size could easily contain 300 examples. That would have made it far more useful for programmers who know how to program, but aren't well-versed in regular expressions.
   
   As it is, I can only recommend this book to people who are not only new to regular expressions, but also relatively new to programming. The book does contain many recipes that solve basic problems you're likely to encounter when writing .NET applications or scripts for a web site. If you happen to use C#, VB.NET, JavaScript or VBScript, and are looking for a cookbook approach, you'll certainly find the book useful.
   
   But don't expect to really learn how regular expressions work from this book. If you develop software for a living, you're better of with a good regular expression tutorial such as the one at www.regular-expressions.info or a book like "Mastering Regular Expressions".



2. The Syntax Overview at the beginning of the book is worth the price alone. Nathan outlines the basic parts of regular expressions and gives you a clear idea of what they are without getting pedantic. This overview isn't even included in the main chapters but rather as an introductory supplement perhaps underestimating its usefulness. Do yourself a favor especially if you are new to regular expressions and read this section first.
   
   After introducing you to the basics the book moves right into real-world examples. Again, no fooling around with fancy scenarios that distract from the purpose of the book. You get a paragraph or two to describe the task at hand and inform you of any assumptions made about the target data and then right into the code. Example code is included for ASP.NET validators, C#, Visual Basic.NET, VBScript and JavaScript for EVERY SINGLE TASK. No fighting with language syntax differences which again would distract you from the expressions.
   
   Following the code examples is a step-by-step description of how it works. Nathan again shows restraint in describing how the expression evaluates using little more than a single line for each part of the expression.
   
   This is a very well-written work that makes an excellent addition to any programmer's bookshelf.



3. Regular expressions are one of the most abstract topics for the average developer to master. Nathan does a real good job of producing something that any developer should be able to start and build their own base library of core expressions.
   The approach he takes by presenting some introduction to Regular Expressions, then presenting usable code in three languages is so useful. Regular Expressions are so abstract, but yet so simple the best way to learn them is by example. For me this was the best book on using Regular Expressions in .NET.



4. I was searching to a book to give some pratical information about regular expressions. Very cool.

No comments about Developing Facebook Platform Applications with Rails.

5 comments about Visual Basic Game Programming For Teens.

1. Helloooo! VB 6 is dead! <--------- You are in denial.
   First off VB will never leave you in the dry.
   1. VB is owned by Microsoft and will never be ported to Linux or Mac.
   2. VB has continued to have new releases.
   3. C++ uses directx just like the rest of programming languages for games.
   4. VB dominates in database programming. [MMO] Game DataBase!
   5. It is possible to code in VB, that can run faster than C++.
   6. Most people who bash VB do not know how to code in it and claim it to be for beginners when they only seen the dev. Fact is VB can do anything C++ can if you know how to code it.
   7. So i say read and know what you are talking about before shooting off at the lips about something you have no clue about. Try looking at the development and then retract your comment.



2. Just started programming and VB seems like a good place.
   Johnathan rambles on a bit to much about maps but I learned alot. Rich D



3. Don't believe those that tell you VB is dead, vb is still alive and well! Just look at Microsoft Access 2003(A database program)when you build advance coding in it you are using vb language,even in the latest Access edition, VB is still there. Just visit your local book store, you will still see VB books out there. Another proof that VB is still alive, look at many E-commerce shopping carts, many of them are build in VB, and they are functioning with great precision.
   The book is intended for the teenager that wants to explore programming in a fun, and easy method, and Vb can deliver that without advance codes that will make a teenage kid left in the dark. It will give them the opportunity to learn to write simple executable codes, once they do that, then they can move on to Vb.net or C++. And with that, the author would accomplish his/her mission, and that is teaching a young mind.
   Go ahead buy the book, play with the codes, and have fun!



4. Overall I find this book good at what it advertises to be, a tour through the process of making a DirectX game in VB that would be very interesting and appealing to a novice programmer (teen). The game is a simplified 2d rpg/adventure game, called `Celtic Crusader'. While functional, in the interest of simplicity and time by the author's own words it isn't a fully featured game, it lacks features such as character inventory or network play.
   
   If you are looking for detailed information on DirectX, this is not the book. This book does not explain the DirectX methods used, or even display their signatures, it just tells you what the routine you are coding does as a whole, and gives you the code.
   
   I currently work in VB.Net, but I am experienced in the last few incarnations of VB, so the conversion of the provided code examples into VB.Net is not much of a problem. I would say someone familiar with VB.Net but without experience in VB6 will not have much problem; in fact the DirectX method calls in VB.Net are more logical than in VB6.
   
   For example
   d3ddev.Present(ByVal 0, ByVal 0, 0, ByVal 0)
   becomes
   d3ddev.Present(Handle.zero,Handle.zero, 0, Handle.zero)
   
   If you pay attention to the intellisense balloons then the DirectX method calls are fairly easy to figure out.
   
   The author doesn't fully qualify all his references, so be aware and supply the appropriate qualifacation for the constants. Be sure to Imports DxVBLibA
   
   For example
   d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD
   becomes
   d3dpp.SwapEffect = CONST_D3DSWAPEFFECT.D3DSWAPEFFECT_DISCARD
   
   The VB side of the code is the same (an If-Then is still If-Then) except that you will need to recognize form events as such by their names instead of their handles keyword.
   
   The DirectX8 for Visual Basic type library reference is still available with DirectX9.0c in VB.Net (just look under the Com tab when adding the reference) and seems to work fine in XP (I have tried it on 3 different machines.) I have not worked through the entire book yet, but so far I have not had any problems with compatibility.
   
   This book is thinner than the typical programming book (tome) you normally find. It leads the reader directly through the creation of this adventure game, cutting out many side details as mentioned earlier. However, I find it delivers enough to create a decent working game, and a nice resource for a programmer looking for straightforward code examples.



5. Ok, yes, 2005? VB6??? Are you aware that Microsoft has discontinued selling and supporting this software?? This software was first published in 1999!!! Find a book that is using a little bit more of state of the art technology. This one is a waste of time and money.

1 comments about Domain-Specific Modeling: Enabling Full Code Generation.

1. This book is excellent. It deals with why we need domain specific modeling (DSM), starting off with business value- then defines DSM and provides an architecture for it - the language, the models, code generation, a framework and the process that connects all of these. It follows this with 5 detailed case studies and then towards the end talks about uses and tools.
   
   I enjoyed reading it and am planning to implement in my projects. The authors are associated with a tool that does DSM - Metaedit+ found at metacase dot com and which has a trial download.

No comments about Ubuntu Kung Fu: Tips, Tricks, Hints and Hacks.

4 comments about Information Technology Outsourcing Transactions: Process, Strategies, and Contracts.

1. This book seems to have been thrown together in no time at all by taking a few things about outsourcing out of the authors' files. Some of the stuff is good, but it's all very uneven.



2. I was looking for a single and concise resource that would provide provide me with a solid foundation for working in the IT Outsourcing field - especially legal aspects. I found it in this book. No other resource was as helpful. As I've gained experience, the book continues to be extremely useful. It is written in easy to understand language and, importantly, in a practical manner. The disk and forms included provide the practitioner with a significant portion of what is needed to "do the deal"



3. Invaluable resource if your company is interested in outsourcing. I particularly valued the forms which I found to be cutting edge. I am a customer of outsourcing and I would recommend this book to any IT professional thinking about outsourcing. This book would also help vendors by providing insight to issues that are critical to customers.



4. I had no problems with this company. The book was here within one week. I would buy from them again.

2 comments about Software Engineering Software Engineering: A Practitioner's Approach 6th edition.

1. Very good book. I am enjoying reading it (not complete yet, it is really very big book). The topics are covered at length. Very good coverage of important concepts with amazing knack of not making the subject boring or dull. Very nice suggestions / references / advices for further study. A A very good read for software engineering professionals.



2. When your interest fall in software engineering, there are *lots* of books on the subject but only a few of them cover the principles in an almost exhaustive way. One of the main errors that authors do is having the claim that all about software engineering can be covered in a single book. And this book is no exception. When you're reading a textbook, this isn't always bad: one of the main purposes of a textbook is introducing the concepts gradually, without much details and in the clearest way possible. A student doesn't need to know all. He/she just need to understand the fundamentals of the discipline. So, while this book is intended for a professional audience, it is structured like a textbook. The problem here is that it gives probably too much informations for students and too few informations for professionals. It gives a nice introduction on the subject, explaining why the software is a product, its features, its lacks and its myths (very interesting). Problems start with chapter 2: the process. While something is covered about some development models like waterfall, win-win model, RAD, concurrent, etc., it lacks any detail needed to really understand these development models and bring them in practice. One of the things I hate the most about this book are repetitions: the author repeat the same concepts many times during the exposition and this can be irritating. It covers many subjects, like user interface construction, project planning, temporal planning, quality assurance in software development, software architectures, component based engineering, conceptual modeling, etc. Each chapter is a small introduction to these subjects but the book gives small or no details at all on how to use these concepts in practice. You won't find code here. You won't find design patterns, UML diagrams, state charts, refactoring methods. While this is not necessarily bad, it makes clear this book is better used as a textbook and not as a practical (for practitioners) manual to learn software engineering methodologies directly on the field. So, if you're interested in software engineering and you want a solid introduction to it, buy this book. If you're a professional who want a practical exposition of the discipline to apply concepts on real projects, skip this book. I give it 3 stars because explanations are good and the book is well written but the title is a bit misleading: professionals generally needs other kinds of books.

5 comments about Data Crunching: Solve Everyday Problems Using Java, Python, and more..

1. Gregory Wilson likes Python and bash but doesn't particularly care for XSLT (or Perl, and possibly Java as well, either), doesn't express a preference in the great Emacs vs. Vi(m) holy war, and divides programming languages into two camps - agile, like Python and Ruby, and "sturdy", like Java. He's an adjunct CS professor at the University of Toronto, a contributing editor with Dr. Dobb's Journal, and is developing "Software Carpentry", which is either a basic course on software development aimed at scientists and engineers for the Python Software Foundation or a project to develop a newer, easier-to-use set of software development tools.
   
   In the book, "Data Crunching: Solve Everyday Problems Using Java, Python, and More", data crunching is explored through a series of examples. The closest that Wilson comes to giving a definition is when, at the start of the first chapter, he refers to data crunching/munging as the "other 10%" of a programming task that takes up the "other 90% of the time". The first example that he gives is his experience helping a high school science teacher convert PDB (Protein Data Bank) files containing the coordinates of atoms in various molecules into a format that a Fortran sphere-drawing program could process.
   
   From the introduction, he moves on to the manipulation of text and text files using Unix command-line tools and Python, with Java work-alikes following most of the Python scripts. Although the book's subtitle, "Solve Everyday Problems Using Java, Python, and More", gives Java first billing (possibly for marketing reasons?), Wilson's preference for Python over Java is never in doubt. After presenting the Java equivalent of a Python script that counts the number of times every email address appears in a list of email addresses, he writes:
   
   All right. It's two-and-a-half times longer than the equivalent Python program, it isn't as fast on small files, and we have to compile it before we can run it, but other than that, it's almost as easy...
   
   With a table of useful commands, explanation of redirection and piping, and some guidelines on how to make sure that your command-line tools follow convention, the text chapter could actually be viewed as a pretty passable introduction to the philosophy of Unix.
   
   The chapter on Regular Expressions is great. So good, in fact, that I wish I could go back in time and give myself a photocopy of those thirty-odd pages at the point that I was struggling to get a handle on RE's some years back. Also included in this chapter is a brief, but very lucid, discussion of character encoding and a bit on using grep.
   
   Although the Text and RE chapters were my favorite, Wilson's clear and concise writing style makes th eentire book, including the coverage of XML, binary data processing, and relational databases, a joy to read. With segues like "But wait a second. Wait just one pattern-matching second.", lists of email addresses to munge that include entries for Alan Turning, John von Neumann, and Grace Hopper, and the like, he also manages to inject some pleasant, if a bit groan-worthy, humor here and there into what could otherwise be a rather dry book.
   
   He uses the last chapter, titled "Horshoe Nails" to quickly address a number topics, like encoding, the pitfalls of floating point arithmatic, and unit testing, which (not a surprise in a title coming from the Pragmatic Bookshelf) he likes, going so far as to say that the spread of test-driven development has been the "real revolution in programming in the last decade"). Diff is introduced and he brings the venerable make to the table as a tool for automating test running.
   
   He doesn't say it in so many words, though his retooling the old saying that "two years of hard work can save you an hour in the library" as "an hour of hard work can often save you sixty seconds on Google" comes close, but the message is to work smarter rather than harder. Use industrial-strength tools and processes when industrial-strength solutions are called for and agile, simplest-things-that-work solutions whenever possible.



2. Data Crunching by Greg Wilson.
   
   The book opens with a statement of purpose: transmuting data from one form into another. The focus is on problems where the hardest part is extracting the data, not problems where the hard part is processing it. Simple transformations and data grazing, rather than data mining, as the ideal problem for these techniques is small, separable, and useful in a variety of contexts.
   
   Major book sections include: Text, Regular Expressions, XML, Binary Data, Relational Databases, and a twenty page miscellaneous section. As usual for Pragmatic Programmer's books, the text is short, coming out at 187 pages, with source code on the web site. That regular expressions come up pretty much immediately tells us that the text will be unix-heavy. Not a bad thing, really, as a few simple unix tools can often save hours of anguish.
   
   Introduction:
   
   The introduction is clear on the intended audience. Read the nine pages, and you have a darn good idea whether the book is worth reading for your tasks. Among other things, the tools he strongly suggests installing - Python, Java, a command line xslt processor, a relational database, and unix command line tools - make it clear the level of this effort. No GUIs, no complicated database reverse engineering tools. Note also, no Perl. (For me, a bonus, but a deal killer for some.)
   
   Text:
   
   Early in the text chapter, the author spends some time examining a data file, then writing out the result. He makes a point of looking up a spec, then ignoring most of it. The YAGNI (You Will Not Need It, for grammarians) says that detailed interpretation of the spec is not as important as carefully making sure it reads the files you actually have to process. After all, your files may be misformatted, or may only use a small fraction of the specification. His example showed that three iterations through some samples got him just about everything he needed, in a very short time. He looked at the input file spec to see if there were corner cases he would need to solve, then focussed on the actual conversion he wanted to make. This theme recurs often - simple data cruncher programs need to be correct, but they do not have the same needs as a general data parsing tool. Do not try to solve every conceivable problem, try to solve the one you actually have.
   
   Interestingly, the author lumps Python, Ruby, and Java on one side, and Perl/C++ on another as far as 'thought collisions' go. Examples thus far include both Python and Java, with more Python than anything else. The Java examples are 1.2+ - using Java 1.5's autoboxing would have simplified several examples to roughly the Python complexity.
   
   The author is not sloppy, but he does take judicious shortcuts. Trimming a file extension in python, he uses a hardcoded three character extension, rather than the more correct .splitExt(). He then mentions that the more correct function required an extra library include, which would have cluttered the text. (The text does mention the more correct function in a sidebar.) A page later, he points out the perils of repeating yourself, and the kinds of errors it can produce. In other words, a bad file extension is likely to cause a visible failure early, while repeated code can lead to subtle bugs. This kind of tradeoff comes up a lot when coding; I was glad to see him make a point of it.
   
   Regular expressions:
   
   Regular expressions are, to my mind, one of the more convoluted topics that programmers encounter on a regular basis. Getting a deep understanding is worthy of a book in itself, and using Perl or Ruby properly _requires_ that understanding. Java now has regex support, though python's is easier to use. He references the standard book on the topic.
   
   The author tries to cover the 10% of the topic that you will regularly use. This will not turn you into an RE-master ready to tackle any Perl you happen to see, but it will be enough for the tasks he is describing. He spent quite some time describing character encoding, Unicode, ISO Latin-1, and the like, which was a welcome surprise.
   
   I note further that not a single Perl example showed up in the RE chapter. Many Python excerpts, some Java excerpts, a lonely-looking Ruby script, but no Perl. Made me happy, but this might infuriate a Perl aficionado.
   
   XML:
   
   The XML chapter goes into a great deal of detail on SAX. The author compares SAX responders to GUI event responders, which felt a bit strained. Most GUI responders do not hove quite the order dependency that SAX responders do. That said, the introduction was clear, and the limitations were explicit. While he did discuss the need to keep state, the discussion came later than I liked.
   
   The DOM section wisely uses language-specific APIs, like Java's JDOM and Python's minidom. I find tree-based APIs more useful than stream APIs in general, and this was a good, if brief, introduction to my most commonly used XML API.
   
   The XPath section is also brief, but clear. Much like the DOM section, the author mentions language-specific APIs. Since many DOM-like APIs have an XPath module, even programmers not planning on doing much with XML will still find it useful. The author draws a paralell to regular expressions - a rich, dense language that can select small pieces out of a large mass of data.
   
   Since I find XSLT a Martian space language, despite having used it heavily for several projects, I was pleased that the author's impression of it matched my own: "I don't really like XSLT that much". The introduction is clearly written, but unlike the other technologies, an introduction does not provide enough meat to accomplish a real problem.
   
   Binary Data:
   
   My rules of binary data: do not use it if you can use text, and if you must, try to find a library. This chapter mentions that on the second page.
   
   The 19 pages of this section cover binary integer representations, string representations, bit shifting, designing self-contained comprehensible binary data formats, and packing as much data per byte as you can. The author did not mention recognizing and parsing gzipped textual data, but other that that, this chapter had a good collection of useful ideas. I have found text, xml, and databases to be more important in my work, but binary files do come up. This chapter reminded my why I always get a sinking feeling when they do.
   
   Relational databases:
   
   This 30 page section gives a good introduction to the practice of SQL databases, using sqlite as the engine. Simple joins and normalizing tables showed up by the fifth page of the chapter. Between aliases, nesting, and negation, the author claims that you should be able to do perhaps 90% of the queries you will need. I rather agree - with the caveat that you do need to understand left and right, inner and outer joins, which are not covered. (They are footnoted to a reference, so expect to snag a good SQL book.)
   
   After joins, the chapter covers aggregation functions, views, and nulls. I give the author credit for bringing up the "Does NULL mean not present, or does it mean unknown" war. Most books take one side or another as gospel, or do not bring it up at all.
   
   A section on creating tables, inserting/updating data, deleting data and tables, and transactions follows. The examples are typical, and appropriate for simple CRUD apps, like many web apps. The author points out that data crunching is far more likely to involve selection than complicated create/update/delete logic.
   
   Finally, the author covers using SQL from python and from Java/JDBC. He also described the impedance mismatch between object oriented programming and the relational model. Wisely, he suggests well tested packages to handle that. I note that the vast majority of my sql has either been in scripts to set up test data or when I was writing an Object-Relational Mapping tool. The vast majority of my code that accesses databases uses well tested ORM packages like Hibernate. (I might have brought Hibernate up earlier in the chapter. Then again, for this book's target audience, perhaps not.)
   
   Odds and Ends:
   
   The final chapter has 19 pages on a variety of tools. The unit testing section discusses JUnit, Make, diff, and TDD. The encoding section discusses HTML escapes, base 64, and others. The section on floating point arithmetic answers the basic questions seen daily on Java discussion lists. Date parsing is discussed in sufficient detail, though I might have added an extra sidebar on just how bad Java's date handling can be. I have little to say about this section, save that it is worth the read.
   
   Final Thoughts:
   
   All in all, this book was well written, well proofed, and well designed. Like all Pragmatic books, it is available as both a downloadable PDF and a bound book. Errata and updates live on the Pragmatic web site. This is an extremely keen system - dead tree form for reading on a plane, PDF form for early access and up to date information.



3. The book presents the topics in conjunction with showing some practical data mining examples that any person might encounter. This book is recommended to people who are interested in basic parsing of data (text, XML, binary, etc) using python.
   
   I got the impression that the author was trying to cover too much in too little space. The title, for example, mentions Java, Python, and more. This is deceiving since the book uses python for about 99% of its examples. And while the book does present Java, it only does so to show that it would be easier to use python. Almost no other languages are covered, although there are some examples in Ruby and Bash.



4. This book is mainly concerned with scripting as a 'glue' between applications: processing various input and output formats. The book is divided into 5 main categories of data handling: plain text, regular expressions, XML, binary data and SQL. There is a final chapter on various miscellaneous topics. Most of the examples are given in Python. Some of the code is demonstrated in Java, although, disappointingly for a book published in 2005, none of the Java 5.0 features are leveraged. However, if nothing else, it demonstrates why Java is not anyone's first choice for such activities.
   
   If you've read any of the O'Reilly cookbook series, you will know what to expect, although the chapters are more cohesive and less episodic. Beginning programmers will get the most out of this book, although intermediate programmers should find at least some material here that's new to them.
   
   The XML chapter is a pretty good introduction the use and advantages/disadvantages of SAX and DOM, and XSLT is also described, although the discussion is not so clear. Those without experience with databases will welcome the chapter on SQL. The discussion on dealing with plain text files in chapter 1 was highlight for me, a subject not often covered in much depth in cookbooks; if, like me, you still regularly need to convert between various plain text formats, this chapter will help formalise approaches that you may already be carrying out in a less than rigorous fashion.
   
   Additionally, the paragraphs on floating point arithmetic were intriguing but all too brief. The chapter on dealing with binary is fairly good, although rather dry. Peter Seibel's discussion of binary data in the context of writing a Shoutcast server in Practical Common Lisp shows that the subject can be dealt with in a more compelling fashion. That said, for the most part, author Greg Wilson is a genial companion; the writing style is chatty, but doesn't overdo it.
   
   Overall, if you own any cookbook-style books, there is little here that you don't already know. Even for a beginner, it's hard to see how anyone who decides they need this book hasn't already been exposed to some of the material here. In particular, does anyone really need yet another introduction to regular expressions? The treatment here isn't bad, it's just that this material is already covered in many introductory programming books (especially those that cover scripting languages like Perl and Python). As this takes up nearly 20% of the book, and there's less than 200 pages, it's a bit of a waste. Personally, I would have preferred more discussion of the less well-treated subjects, some of which are too sparsely described, but this would have detracted from the book's main aim.
   
   This would be suitable for a beginner Pythonista, who for some reason didn't want the bulk of the likes of Python Cookbook. Otherwise, if you feel that some Pragmatic Programmers books can be rather lightweight and somewhat overpriced, this will not change your mind.



5. Some of the best technical books are short, clear, easy to understand, and practical. Greg's book falls into this description. This a great book for exploring algorithms in the python language. The book assumes the reader has at least a basic understanding of the python programming language or some programming experience. I was delighted that topics were presented in a concise and unambigous way and that the book was short. There should be more short books published!