It has been ten years since David Beazley wrote the first edition of Python Essential Reference. The book has proven itself as a valuable resource to Python developers and has been kept current over those ten years, with the fourth edition coming at an interesting time for Python. Python 3 was a major release that broke backwards compatibility. Python 3 has been around for a year now. That said, the current download page at the official Python site states, “If you don’t know which version to use, start with Python 2.6.4; more existing third party software is compatible with Python 2 than Python 3 right now.” Beazley in keeping with the pragmatic roots of a reference that sticks to what is ‘essential’ has removed the coverage on features from 2 that were removed from 3. At the same time, the primary focus for new features that came with 3 is limited to those that have been back-ported to 2. This approach, born out of a desire to keep the reference relevant, provides a blended approach that is above all else practical.

The end result of that choice is a reference document consisting of those parts of Python that are shared between versions 2 and 3. This is a significant portion of the language and I think this approach is really what will give this reference more traction than many of the other guides that focus purely on 3. I think that those are valuable and over time the balance will shift but as of right now, for a little while to come, this book takes the most realistic approach. That feels very fuzzy, but I have no idea how long it will be until Python 3 truly is the dominant version and Python 2 is truly put to bed.

If I had to guess how Beazley’s Python Essential Reference has held in there over the years, the key would be that there is a lot of what a developer needs and very little of what she doesn’t need. There is a twenty-four page tutorial introduction, but this is not a guide on how to program or how to use Python for beginners. An experienced programmer could probably use this reference to shift to Python as a new language, but someone completely new to writing code would probably not want to start here. A quick look at the table of contents shows that an explanation of the language itself is covered in under 200 pages. Extending and embedding Python also get their own section, but close to 400 pages is given to the Python library.

An inevitable question is what one will gain with this reference over the online documentation. A good example to see how things vary is to look at chapter nineteen, Operating System Services and the online documentation for Generic Operating System Services. The online documentation is very thorough, and covers each piece of the library starting with os and io, building from there. While every facet is documented much of it is rather brief. For example section 16.2.3. Raw File I/O is a very straightforward listing of the very low level functionality available via io.FileIO. In contrast, looking at the 3.1.1 Docs for Raw IO shows that parameters for FileIO changed with that version. Looking to the documentation for 2.7a1 Raw File I/O shows that these changes are being back-ported to Python 2.

In Python Essential Reference none of this hunting down changes and checking to see if they are coming to 2 are necessary. Beazley shows them in his documentation. This is the strength of his choice on how to handle these types of situations. On top of that, Beazley provides more than the online documents by including four paragraphs of additional information on Raw I/O and when its use is appropriate. This added content is probably available googling around for it, but then I have to take the time to check dates on posts to see if things are still current and in general just hope that things are accurate. I have never read a technical book that was completely error free, and there are probably at the very least some typos in Python Essential Reference, though I haven’t caught any of them on my read through or use of the book yet. But the important thing is that I don’t expect the book to be perfect, rather I value it for being a known quantity. I am aware of just when the material was compiled, who put it together and I have it all in one place.

It is pretty obvious to anyone paying attention that the growing prevalence of mobile technologies is something that cannot be ignored. A special report in the Economist on telecoms in emerging markets wrapped up with the prediction, “…at current rates of growth it seems likely that within five years, and certainly within ten, everyone in the world who wants a mobile phone will probably have one. 3G networks capable of broadband speeds will be widespread even in developing countries, and even faster 4G networks will be spreading rapidly in some places.” It does not appear that it will be long before Smart Phones are just normal phones and anyone who wants to be, will be connected to a world wide mobile network. Any business or developer that wants to reach groups of significant size really needs to be prepared via mobile platforms. Brian Fling has been helping others operate in this space for close to a decade and is very familiar with the lay of the land. He sees the opportunities and has experienced the pitfalls and frustrations as well. His new book, Mobile Design and Development brings some of that experience and knowledge to the mobile neophyte, looking for an overview of just how to get in the game.

Mobile Design and Development is not a long book and doesn’t delve deeply into the specifics of any one platform or technology. This is an overview that would be of value to anyone that will be managing a project being built for mobile, or for technical folks that are new to mobile. This will give the manager and leader an appreciation for the challenges and good guidance on realistic scope. For the person actually implementing the technology there is quite a bit of good information here that will be of value on the front end for making choices in direction and platform. There is also a section on building iPhone web apps ( applicable to any phone with similar capabilities running a WebKit based browser ). But this is not primarily a ‘how to code’ or reference book for any one mobile technology. This isn’t going to be the only resource a developer will want but could prove invaluable in saving time and effort wandering in what can be a rather complicated set of choices. The book even deals with making money on mobile platforms and so Fling very succinctly gives great coverage to most all that one would need to get up and running. I would think the audience that would get the most from Mobile Design and Development is the small team or individual that want to take a stab at the mobile market and have a high degree of flexibility and freedom. This book would be an invaluable resource in sorting through all the possibilities. Whereas someone working in a large corporation that wont give them the freedom to choose their platform, or someone who has already made all their platform choices would probably do well just to dig into something more specific to their chosen technology. That said, if the choice was arbitrary and if isn’t too late to change, working through the first half of this book may give one solid reason to reconsider.

In his preface Fling states that he has three principles that he would like to impart.

• You need to know the different facets of the mobile medium.
• You need to know how to leverage mobile technologies to address context.
• You need to know how to leverage the right mobile technology for the need.

The book is in two sections, the first being an overview of just all what falls under the “mobile” umbrella and provides a few ways of organizing those pieces. It works to provide information applicable to the first two principles. The second section of the book focuses on the third principle and goes mostly deeply into mobile web applications, which Fling sees as the answer to the platform and carrier fragmentation present in other solutions. The question of web apps vs Native apps has created some interesting discussion and Fling falls into the ‘leaning towards web apps’ camp, though he is pragmatic throughout this book.

That pragmatism is extremely attractive and a large part of what makes this book worthwhile. It is obvious while reading that Fling doesn’t just talk about how things should be done, but he follows his own advice in his writing and presents what he believes will make for the best solutions. If there is a place where idealism will lead to the quick and ugly death of an idea it would be the mobile space. Compromise isn’t just something that may make sense at times, it is often forced right into the platform by carriers or others. Fling doesn’t back away from this and acknowledges when there are multiple routes, none standing out as ideal. He is very up front in sections where his technical reviewers had other opinions and presenting other options that they felt might be better. Fling tries to give succinct coverage to what he sees as the better possible options and leaves the choices to the reader, now armed with enough information to dig deeper.

Fling’s clarity and up front appraisal of the considerations in the mobile space lead to him describing one of the most prominent limitations of his own book. Besides the obvious that it can’t go into great depth on every mobile technology there is the fact that this information has a limited shelf life. In the fifth chapter, Developing a Mobile Strategy, Fling gives a set of seven rules that he believes should be followed in the process of creating a strategy. The second rule is, Believe What You See, Not What You Read and the following chapter contains the admonition, “Don’t trust any report, fact, or figure that is more than a year or two old. It is most likely wrong. For example, the majority of assumptions about mobile development pre-iPhone are no longer applicable.” According to Fling, barring a revision this book has a shelf life of roughly a year or two. After that one should really be looking to more recent resources. On the other hand, anyone even thinking about jumping into the fray, should be reading this right now.

This limitation is the only thing that causes me to not rate the book as a ‘classic’ and it is not really the fault of the author. It is just a reflection of the rapid rate of change taking place in the world it describes. My only other problem with the book is small, though at times a bit annoying. The book is black and white, without any color illustrations. This in itself isn’t a problem but the shades chosen for pie charts in more than one place are not sufficiently different to tell where one edge stops and another starts. Fling describes the charts, they are never floating alone without text that addresses them, so the reader doesn’t lose information, just the opportunity to see it displayed in a visual format. I’m not a person with great visual design skills, so if I noticed I’m sure others involved in the production of the book have as well and hopefully later printings corrected this issue.

The first section, as I’ve described, is a high level overview of the mobile world. This covers what Fling thinks of as all the layers of the mobile ecosystem. This means everything from carriers to hardware manufacturers to operating systems and more. I’ve spent quite a bit of time over the last year reading up on much of what Fling covers here, but there were still pieces of new information that I found. Fling takes a global view and doesn’t lean towards the situation as it is presented in any single geographical area. He is also dealing with all types of phones and platforms. While he obviously spends a lot of time, especially in the second section, dealing with more capable smart phones, he is still dealing throughout the book with less capable devices and systems. This is where Fling’s experience really shines. He has navigated what it means to try and develop for less capable phones, the realistic challenges one faces trying to get onto more hardware and more networks. It is at times daunting, but I for one would rather walk into something knowing the reality rather than being uninformed.

Fling hits all the highlights from what is available to suggestions on the whole life cycle of a mobile product including prototyping, testing and adapting to various types of phones and platforms. The second section, dealing with more specifics on putting together a Web App will throw a bone to the developer that wants to see some code. While it is mostly mark-up Fling does spend time dealing with some specifics of implementing a WebKit compatible solution. He states that this will work on a few modern phones, though a few subsections do carry warnings that they are iPhone specific. Fling covers the use of XHTML, XHTML-MP, CSS, JavaScript, and other applicable web technology. This is probably where the management types will start to skim over things. I do think though it still serves the purpose of giving an idea of what is possible and when it is appropriate to choose a pure web application over a native application.

I think that Fling does an excellent job showing that it is important to create mobile applications that are designed purely with mobile users in mind. The last chapter is only a couple pages long and is the only place that Fling devotes purely to prognosticating. The rest of the book is practical and focused purely on what will work right now. In his closing thoughts, Fling essentially invites the reader to be a part of bringing about the future of mobile. I think this is very fitting as he has just given his readers what they need to set out on that path.

Title: Mobile Design and Development
Author: Brian Fling
Publisher: O’Reilly Media
Pages: 328
ISBN: 978-0-596-15544-5
Rating: 9/10
Tagline: Practical techniques for creating mobile sites and web apps.

Google’s mobile OS Android has received plenty of press. As with a lot of Google products, there was much anticipation before any devices were even available. Now a number of phones are available, with many more coming out world-wide in the near future. Part of the lure of Android is the openness of the platform and the freely available tools for development. The SDK and accompanying Eclipse plug-in give the would be creator of the next great Android application everything they need to make their idea reality. The bar to entry in the official Google Android Marketplace is very low and it doesn’t seem to be much of a stretch to predict that the number of developers working on Android is only going to grow. As with any hot technology the number of books will grow as well and O’Reilly’s Android Application Development has jumped into the fray, promising to help budding Android developers what they need to get started.

The book begins with a brief introduction to Android followed by detailed instructions on procuring and installing the Android SDK. Space is given to Windows, Linux and Mac. The install is relatively simple on all three platforms, extra information is provided for Ubuntu users but no others distributions. Extra care is taken to help Windows users with items they may not use regularly, such as environmental variables. This is all pretty basic and gives the book very much of a ‘for beginners’ feel. Before I had the book I had already installed the SDK and Eclipse plug-in on Windows, Ubuntu and Fedora without any issues beyond getting a current version of Eclipse for the Ubuntu machine. The version I already had from the Ubuntu repositories was not able to run the plug-in. It’s a short chapter and if someone really struggles with it, they probably should shift their focus from learning to code to learning how to use their platform of choice. This does set the tone though, that this is a book for those who are very new to development.

Chapter two steps the reader through the ever present “Hello World” and gives an overview of the structure of Android applications. Chapter three introduces the example application that will be used for the rest of the book. There is a lot of repetition here on just what directories and files make up the guts of an Android program. I was quickly worried ( the first four chapters are only fifty-six pages in ) that maybe four authors had been too many. The repetition made it feel as if separate work had been combined without enough editing to remove what was redundant. Fortunately this got better, though there was still a strange proclivity to list files while referring to earlier chapters that explained their purpose. This would be helpful to anyone jumping right into the middle of the book, but the index also serves the same purpose and saves space for more valuable content, as opposed to explaining the purpose of AndroidManifest.xml repeatedly.

Once I moved into the fifth chapter, Debugging Android Applications and the following chapters, things got better. The pace picked up and the repetition dropped off for the most part. The book did not become incredibly difficult, trying to be everything to everyone, but did maintain an introductory style. At the same time the example application makes use of many Android features that are likely to be used by developers. How to set up and use tools was covered step by step. This is very nice but did cause some issues for the authors due to the rapid pace of development on Android. A visit to the book’s errata page will show that many readers struggled with changes to the SKD tool set that came out very shortly after the book. The authors say that future editions will fix these issues, but this creates a dilemma for that reader needing introductory level materials. They are more dependent upon the book than a more advanced user and so these issues can be very trying. Based on the responses to the errata posts it became trying for the authors as well. This isn’t a knock on the book itself but rather a limitation of the delivery method.

Once the reader is digging down into the example application the team approach to writing the book does become an asset. The authors bring a number of skills to the table that closely resemble the players that would be necessary to a team developing a real-world application. The reader is now being pulled into an example that benefits from the knowledge of each and does a good job of exploring the range of options an Android developer has available. This includes core functionality, UI options and how to best take advantage of the platform while at the same time taking performance and user expectations into account. I felt like I was getting something beyond the excellent documentation provided by Google. This is where I felt the book stood strongest.

Working with a single, large example application was a move that probably helped move things along on writing the book and I think it’s an interesting approach. The problem is of course, that means that this example must be right. Right for the task and technically correct. Small issues in the code are inevitable but now their impact is book wide. The changes to the platform just made it just that much more difficult to sort out. On the whole I still found this to be a better approach primarily due to the fact that it gives the features highlighted a better sense of context. Stand-alone examples are often good at highlighting technical features but completely ignore the issues necessary to using the feature in a larger piece of code.

I’m a fan of O’Reilly books. Interestingly enough this doesn’t mean that I’ll gloss over issues with what they produce. The result is actually the inverse, in that I go into all their titles with a high level of expectation with regards to quality on every level. This may mean that though I strive to be neutral when I look at a book, I’m probably a little tougher on O’Reilly titles. This made my rough start with Android Application Development a bit jarring. The repetition and what felt like sloppy editing are not what I expect. I was quickly given a sense that this book may have been rushed to publication a little sooner than it should have been. As I moved deeper into the book, things improved and while I think there were still editorial issues, things did seem to smooth out to some degree.

There is an interesting tension that exists purely do to the nature of print books. I don’t like to bring up print versus electronic in reviews as I don’t think it is on topic, but here it is unavoidable. The book is aimed at people that need a little more hand holding and help getting going. It does a good job of providing step by step instructions, the problem is that some of those steps have changed. I don’t think anything in the code itself needs to be different, but the tools have changed enough that getting the code to run in a development environment against the new SDK is different. That means that portion of the book is no longer of as much value without going to other sources to find the new steps.

That said, warts and all I found this to be a helpful way to get my feet wet with Android. I really look forward to future versions as I think just a little more time and work will move this from my ‘good’ list to my ‘great’ list. Making things a little tighter and cleaning up the few typos and errors would certainly make this an 8 instead of an 7, which is really substantial in my mind. I’m no super developer and I need stuff like this, that can take things a little more slowly and make it all clear. I think this guide is great for those of us in that category as long as the reader is o.k. with hopping to external sources for the information they’ll need to get the newer tool set working.

Title: Android Application Development
Author: Rick Rogers, John Lombardo, Zigurd Mednieks, Blake Meike
Publisher: O’Reilly Media Inc.
Pages: 332
ISBN: 978-0-596-52147-9
Rating: 7/10
Tagline: Programming with the Google SDK.

Rich Internet Applications (RIA) have often been associated with some type of sandbox or virtual machine environment to make desktop features available via the web. Many applications though, have left behind the restrictions and demands of those technologies, implementing RIAs as pure web interfaces. One key technology in this area is JavaScript. It’s been well documented that working with JavaScript can be problematic across various browsers. In response a number of JavaScript libraries have been created to alleviate the issues in dealing with different browsers, allowing developers to focus on application logic rather than platform concerns. One such library, focused on providing tools for building RIAs is Ext JS. For the aspiring developer looking to use Ext JS, Packt provides a guide to the library in the form of Learning Ext JS

The book is written for people with experience in doing web development. The authors state that a working knowledge of HTML and CSS are important, but experience with JavaScript is not essential. I think that a reader that has not used JavaScript may want to supplement this guide with something that covers the basics of JS. Experienced developers that haven’t worked specifically with web programming should have no trouble keeping up. Anyone completely new to the idea of programming, scripting, markup, etc. really will need to take some time to get familiar with those concepts before they dive into this book. The authors do not spend time teaching programming, they are focused purely on realistic applications of Ext JS.

The authors begin by stating that, “Ext is not just another JavaScript library…” and it is understandable that they would feel this way. I am unsure why one wouldn’t think so other than a personal preference for the product. That said Ext JS can be used alongside other JS libraries and does provide a lot of features ‘out of the box’ that make it an attractive choice. The emphasis on RIA widgets and building strong applications is nice as Ext JS is not working to be all things to all developers.

The book is heavy on code and examples but not so much so that it falls into the cook-book style of writing. Learning Ext JS is more of an extended tutorial with ample explanation to help the reader not only understand the code but why certain choices are made. Frederick, Ramsay and Blades have done a good job of working through the examples in a concise manner. While the book is the result of group work, it does not have the feeling of being written by a community. I did not run into an abundance of repetition and topics flowed well. Learning Ext JS also covers installation and integration of the library as well as a very quick survey of tools for development. While short these sections would be extremely important to anyone coming into web development with little experience.

It’s a quick read, and doesn’t delve extremely deeply into more advanced topics. Rather, a reader new to Ext JS will get a launch that should make the library usable in a practical way and also give them the framework to push deeper. The book was written and published just as Ext JS moved between versions. The new version is backwards compatible with the material in this book and a number of the changes in version three would not have fallen within the scope of this book, so it is still a good place to get started with Ext JS. Those who want to dig deeper will need to look elsewhere.

The brevity of the book wont work for those folks who want to really dig down deep into Ext JS. I on the other hand, wasn’t looking for a massive tome to lug around and grind through. I was happy to have a very accessible tool that would get me started quickly and that is what I got. On the other hand I do like to be able to find what I need quickly and nothing is more important to me when learning than a solid index. Unfortunately the only really large ding I have for the book is that the index is weak. It would be a lot worse if the book were larger, so the brevity helps here a bit, but it’s still unfortunate. This does make the ebook version a little more attractive. Packt will bundle them at a cost that makes the addition of the electronic copy very attractive. That said, the easy flow does it make it easy to read this book front to back while working the examples. Learning Ext JS just wont be my first choice when I need to quickly check a reference.

I’ve discussed the shallow coverage, but this does not mean that the book is not useful. The Ext JS library bundles enough functionality into the stock widgets, that decent applications could be written with nothing more. Creating custom widgets is covered and extending existing code as well, but this is later in the book. The material prior to that covers not only the use of the provided widgets but how to tie them together, theme an app and then handling data. This means the reader pretty much has everything in hand to build a stock application. The focus is on dealing with these issues on the client side. The examples do include a small amount of back end code when necessary for the execution of examples. All the examples are available to download from the Packt site and come packaged with all necessary scripts, images, etc.

I’ve always worked primarily with desktop applications. I’ve done some work with web applications, but it seems to me that increasingly the tools that I use the most are web based. With technology like Google Gears making those applications available whether I’m connected or not they have become much more attractive. Tools like Ext JS make it much easier for me to transition over to this new way of developing applications. I’ve found that Learning Ext JS has been a valuable resource in taking what is a great resource and allowing me to get the most out of it more rapidly than I would have otherwise.

Title: Learning Ext JS
Author: Shea Frederick, Colin Ramsay, Steve ‘Cutter’ Blades
Publisher: Packt Publishing
Pages: 309
ISBN: 978-1-847195-14-2

Rating: 8/10
Tagline: Build dynamic, desktop-style user interfaces for your data-driven web applications.

The Pragmatic Bookshelf, the innovative publisher of award-winning books by programmers for programmers, has launched a new magazine: PragPub.

PragPub editor Michael Swaine served for years as editor-in-chief and editor-at-large for the venerable Dr. Dobb’s Journal and coauthored the seminal personal computer history book, Fire in the Valley.

Michael says, “There is a huge demand for timely information on current programming issues, but conventional magazine publishing can’t keep up with the pace of change in software development. There are some wonderful blogs and wikis that address particular technologies or projects, but they tend to come and go, or serve an extremely niche audience. We’re hoping to strike a balance between a conventional magazine and a topical blog or wiki, capturing the benefits of professional editing and a regular publishing schedule of a magazine, and the responsiveness and sense of community of the blogs and wikis–the growing, worldwide Pragmatic community.”

The July issue is now available from the Pragmatic Programmers site. PragPub is published monthly and is free of charge.

Hitting middle age has been an interesting time. I catch myself thinking about how well kids have it today and sounding a lot like my father. One difference is while my dad was happy to teach me about sports or cars, we never spent any time knocking out code together. I think he did realize that home computers were important and I will always be grateful for the Commodore Vic-20 be brought home one day. It was a substantial purchase for our household. I spent many days copying lines of basic from magazines and saving the results to cassette tapes. In my home today we have a considerably better situation, computing wise. There are usually a couple laptops running as well as the desktop machine upstairs. My kids take for granted what I found to be amazing and new. Still, that’s all pretty normal and I’d like to give them an opportunity to go deeper if they are so inclined, just like we give them opportunities to explore other skills and pursuits. With that in mind I brought a copy of Hello World! home a few weeks ago, and the response from my oldest has been surprisingly enthusiastic.

Warren Sande wanted to teach his son Carter about programming but had difficulty finding what he thought was a suitable book to guide the process. At the encouragement of Warren’s wife, he and Carter decided to write their own while Carter learned to code. Warren chose Python as the language they would work in and then the two together outlined the book and created the sample applications. As the book moves into more complex territory the sample applications are the kind kids like best. They are games. As soon as my daughter saw that she would get to make her own computer games she immediately asked me if we could start working through the book together. When it has been a while since we’ve had a chance to crack it open, she reminds me by asking when we will get back to it. I would say that on her end it has been a complete success. It has been a great time for us as father and daughter and educational for us both.

Language choice can be quite a hot topic amongst us geeks. In the preface Warren defends his choice of Python with a bullet list I’ll summarize here.

• Python was created from the start to be easy to learn.
• Python is free.
• Python is open source software.
• Python is not just a ‘toy’ language.
• Python is multi-platform.
• Warren likes Python and thinks others will like it too.

I think the list is pretty solid. The only one I think may not be directly applicable to the case it hand is the FOSS angle. Warren explains that being open means that more can be done with the software and that there is a large set of corresponding code out there freely available. A case could be made that this is also true of more closed languages. The one thing I think that could make this important is if the teacher of the material is interested in not just teaching the technical side of programming but is also interested in communicating the philosophical values of freedom. In light of the amount of closed source software and ignorance in regards to FOSS options I’ve seen in the public school system where I live, I think this may be more important than some think.

The rest of the reasons though I think make Python an incredibly solid choice, and above all else is the simplicity. My daughter has been able to have fun typing code into IDLE without having to get hung up with a complicated environment. The syntax is clean and simple, there is no compiling, it’s very easy to just jump in and start making things happen. I think this is important, the younger the student. I was concerned that nine might be just a touch too young for this undertaking. The book itself does not make any recommendations concerning age. The more I’ve thought about it, the more I agree with that choice. Children vary so greatly and any number chosen would be rather arbitrary. My nine your old has done well so far, but she is already quite a book worm and leans towards more academic pursuits. An older child may struggle and there may be some that are even younger that would be fine with the material in Hello World! So rather than focus on age I think a parent needs to come at this from a perspective of ability, proclivity and experience.

In the ability area, a child is going to know how to read, work with a mouse, and type things via the keyboard. Of course the mouse is optional strictly speaking but most will probably want to use it. Some math skill would be good as well as the ability to understand the use of variables. The book tackles the necessary material in a kid friendly way but it is not dumbed down. In fact the learning potential here is huge, as one may imagine. The book is formatted with lots of visuals and fly-outs that give information on how computers operate and how programming languages deal with information processing. My daughter and I have already had interesting discussions on subjects like integers and floats. An example that draws a sine wave lead to a great teachable moment about amplitude and wave length. Then there is the constant need for approaching problem solving in a structured manner using logic. I think that taking on programming brings a wide number of benefits.

One of the features, is a little caricature of Carter that is placed throughout the book with observations that the real Carter made as he learned with his dad. These are things that a real kid noticed, and so they are likely to stand out to a child working through this book. For instance in the chapter on “Print Formatting and Strings” Carter says, “I thought the % sign was used for the modulus operator!” The book explains that Python uses context to choose how the % sign is used. There are other little cartoon characters that appear throughout the book drawing attention to important points that need to be remembered. Learning is reinforced through quizzes at the end of the chapters. The chapters are not too long but I’ve found that my daughter and I have to break them into sections because of her typing speed. I’ve been tempted at times to move things along by typing for her but I know that she will not get the same benefit from the exercise if we do it that way. I will also let errors slide by at times to allow her the opportunity to look at error messages and find the problems.

As I mentioned the book is billed as being for kids and “other beginners.” I’m going to say that the primary focus is rightly on kids, and probably kids who are in grade school or maybe junior high. This is not to say that the examples and information wouldn’t be great for anyone brand new to programming. There are even some nuggets for someone who has written some code but is new to Python. I am going to guess though that the average high school student will not be as taken with the cartoons and puns. I’d have loved to have written my own lunar lander game at that age though, so maybe I’m selling this short, or maybe it would be something a teen would be happy to work on away from the eyes of others, so as not to appear childish. (I may take heat for this but even as a teenage geek I was immensely worried about the perceptions of my peer group.) I think an adult that was serious about learning to program, even if they had no prior experience, would do better with heavier material. All that said, I think for children they’ve really hit the sweet spot and as much as marketers would like it to be so, no book can be everything to everyone.

Things start simple with print statements and loops that took me back to good old days of watching messages scroll endlessly by on display computers at Sears when I was a kid. The move towards games starts even then with text and quickly moves on to leveraging Pygame for games that utilize graphics. I think this is important as it keeps things entertaining while teaching important concepts at the same time. I have to say it is quite a bit fun to sit with my child discussing nested loops and decision trees. By the end of the book examples will have included a simple virtual pet, a downhill skiing game and a lunar lander simulation.

I’ve discussed a child’s ability a bit but I think the last two things I mentioned must be taken into account as well. They are proclivity and experience. I’ve let my daughter drive the time we spend working on this. Just like the parents who project their sports dreams on their kids, I think there is a possibility to do the same with my love for all things digital. It may even be easier to do so as I view the ability to do some amount of programming to be an important life skill. The thing is I don’t want to push her too hard and have her back away from it completely. This fits in with the experience part. We take it as it goes, and if things stop being fun, we will back off. I don’t do this with her core disciplines from school like reading and math, but for something that is extra right now I’m not going to push. It would transition from being a joy to being work. That brings up a last and unexpected benefit from Hello World! I’m rediscovering a lot of the fun and excitement that drew me into this industry in the first place.

Title: Hello World!
Author: Warren and Carter Sande
Publisher: Manning
Pages: 430
ISBN: 978-1933988498
Rating: 9/10
Tagline: Computer programming for kids and other beginners.

Microblogging service Twitter has undeniably been a hit, with growth rates that were at times in excess of 1400%. The growth was rapid enough that the site became well know for its periodic and at times extensive downtime. Even with these issues, the service continued to grow rapidly, and with celebrities getting into the mix Twitter was quickly on the radar of mainstream media. The ubiquity of twitter and ever increasing coverage of ‘tweets’ has also brought the inevitable backlash. As with anything that gains high profile popularity there are plenty of Twitter haters out there, though the role that Twitter has played in the recent Iranian elections seems to have brought more legitimacy to Twitter in the eyes of many. With popularity come books and quite a few are already out there about and for twitter, but my favorite so far is The Twitter Book by Tim O’Reilly and Sarah Milstein.

What makes The Twitter Book work so well is that it functions in a manner very similar to the service it describes. The book itself is small, 8×5.9×0.7 inches, and the font is a bit larger than most tech books. This means the most text dense pages probably contain the same content as one third of a page in a traditional O’Reilly book. Most pages aren’t text though, there is a liberal use of color, bold text and graphics. When a page is relatively heavy on text, the facing page will be equally focused on graphics with pictures, graphs or large colored bubbles around text.

All this combines to make The Twitter Book contain many of the same elements that create such a passionate response, positive or negative, to Twitter itself. This means if someone absolutely hates twitter, can’t think of a single reason it should exist and wishes it would go away; they are probably not going to like this book. On the other hand anyone that loves Twitter and wants to learn all the ins and outs of the service, there is a high likelihood they are really going to take to this guide. It’s format is one of those genius moves that seems incredibly obvious in hind sight. When I’ve shown it to other fans of Twitter, the usual initial response has been, “A twitter book, really?” and they are not all that enthusiastic. But once I start flipping through it and letting them see the way it is formatted, the reception becomes much warmer and quite a few have quickly flipped from skepticism to a desire to take my copy.

O’Reilly and Milstein both have been using the Twitter platform extensively and speak from experience and data that backs up their assertions. The format may make the whole thing look rather simple, but there is a lot going on here and one can very easily find a lot of bad advice out there on how to get the most out of Twitter. The Twitter Book leaves the reader in good hands that have already tread the paths they lead one down.

Of course this does raise and important question, is a guide to microblogging really necessary? All one does with twitter after all, is post 140 word updates. If kids can text vociferously, who needs how to do the equivalent to a web site? Well, there are two things in play that I think make this worth having. The first, and I think possibly the more important, is that Twitter is a social service. Beyond the simple technical aspects of the various clients, and technologies supported for the sending and receiving of tweets, there are the mores and customs of what has already become an established community. O’Reilly and Milstein aren’t just guiding the reader through a simple how to, they are giving an introduction to a massive community that can save the reader from making more than a few mistakes that could really make getting going with microblogging a rough start.

The second reason is that while basic twitter functionality is drop dead easy, some of the more powerful or useful features are not built into twitter itself. They are methods and tools that have come up from the user base itself. Some of them require a little thinking outside the box as it were and are not immediately obvious. Others do seem incredibly simple once they’ve been implemented but their simplicity belies their usefulness. The book gives solid information on third party clients and tools. Tips on use are backed up with statistics on existing use within twitter.

As this is The Twitter Book, I have been talking about Twitter quite a bit. I’m sure the name is going to help the book sell but much of the information is just as valuable in the context of microblogging in general as opposed to just Twitter. The only real exception may be the clients and tools mentioned previously. Some of them have been slow to support other platforms. I think this book is just as useful still, to anyone microblogging with another service such as idenit.ca. Identi.ca is built on the free and open Laconica software. I personally base all my microblogging from identi.ca and forward things over to twitter. I still interact on twitter because at this point is where the majority of the players are at. But the social guidelines and strategies laid out in The Twitter Book carry over directly to identi.ca.

I don’t really have any issues with the book. The scope is purposefully narrow and within the defined limits the authors have covered everything very well. I’d have loved to see something on identi.ca or Laconica but that would have widened the scope quite a bit and I think we can all relate to hating scope creep in a project. SlideShare has a nice preview of the book. Of course this format is not suited to every purpose. Any in depth study of just what makes twitter so popular and the impact it is or is not having on society will need to take place in a manner more suited to such topics. This is simply a case of using the right tool for the job. But dismissing this format as useless would be a mistake it is uniquely appropriate to the job at hand. I think this book is a lot like a screw driver. When used in the manner intended, no tool is better at the job. The only way to break a screw driver is to use it in an unintended way. In that case it isn’t the tool’s fault. Looking for a meaty discourse on the pros and cons of twitter? Do not look here. But if getting the most out of the service is the goal this may just be the best tool available.

Title: The Twitter Book
Author: Tim O’Reilly and Sarah Milstein
Publisher: O’Reilly Media, Inc.
Pages: 234
ISBN: 978-0-598-80281-3
Rating: 9/10
Tagline: If you want to learn how to use Twitter like a pro, The Twitter Book will quickly get you up to speed.

The end of last year I made a move from an IT shop focused on supporting the U.S. side of our business to a department that provides support to our operations outside the U.S. This was the first time I’ve worked in an international context and found myself running into long time assumptions that were no longer true on a regular basis. My first project was implementing a third party, web based HR system for medium sized offices. I found myself constantly missing important issues because I had such a narrow approach to the problem space. Sure I’ve built applications and databases that supported Unicode, but I’ve never actually implemented anything with them but the same types of systems I’d built in the past with ASCII. But a large portion of the worlds population is in Asia, and ASCII is certainly not going to cut it there. Fortunately a new edition of Ken Lunde’s classic CJKV Information Processing has become available and it has really opened my eyes.

CJKV Information Processing has a long history that actually goes back into the 1980s. It began as a simple text document JAPAN.INF, available via FTP on a number of servers. This document was excerpted and refined and published as Lunde’s first book in 1993, Understanding Japanese Information Processing. Shortly after JAPAN.INF became CJK.INF and the foundation for the first edition of CJKV Information Processing was born. The first edition was published in 1999, and it is safe to say that a number of important things have changed over the last 10 years. Lunde states four major developments that prompted this second edition in the preface. They are the emergence of Unicode, OpenType and the Portable Document Format (PDF) as preferred tools and lastly the maturity of the web in general to use Unicode and deal with a wider range of languages and their character sets.

Lunde sets out not to create an exhaustive reference on the languages themselves, but rather an exhaustive guide to the considerations that come into play when processing CJKV information. As Lunde states, “..this book focuses heavily on how CJKV text is handled on computer systems in a very platform-independent way…” Taking into account the complexity of the topic, the breadth of the work and the degree to which it is independent of any specific technology, outside a heavy bias for Unicode, is extremely impressive. A glance over the table of contents show just how true this is. Chapter 9, Information Processing Techniques has sections touching on C/C++, Java, Perl, Python, Ruby, Tcl and others. These are brief, with most examples in Java but that they are all directly addressed shows a great awareness of the options out there. The sections that deal with operating system issues have the same breadth. Chapter 10, OSes, Text Editors, and Word Processors doesn’t just hit the top Mac and Windows items. It looks at FreeBSD, Linux, Mac OS X, MS Vista, MS-DOS, Plan 9, OpenSolaris, Unix and more. There are also sections for what Lunde calls hybrid environments such as Boot Camp, CrossOver Mac, Gnome, KDE, VMware Fusion, Wine and the X Window System. Interestingly the Word Processor system covers AbiWord and KWord but not OpenOffice.org The point stands that anyone looking to support CJKV, this book will probably cover your platform and give you at the very least a starting point with your chosen tool set.

That said, an extremely specific implementation is not what Lunde is out to offer up. This is the very opposite of a ‘cook book’ approach. This also makes the book extremely useful to anyone dealing with internationalization, globalization or localization issues regardless of character set or language. Lunde teaches the underlying principles of how writing systems and scripts work. He then moves to how computer systems deal with these various writing systems and scripts. The focus is always on CJKV but the principles will hold true in any setting. This continues to be the case as Lunde talks about character sets, encoding, code conversion and a host of other issues that surround handling characters. Typography is included, as well as input and output methods. In each case Lunde covers the basics as well as pointing out areas of concern and where exceptions may cause issues. The author is nothing if not thorough in this regard. His knowledge of the problem space is at times down right staggering. Lunde also touches on dictionaries as well as publishing in print and on the web.

The first three chapters set the table for the rest of the book with an overview of the issues that will be addressed, information on the history and usage of the writing systems and scripts covered and the character set standards that exist. This was a fascinating glimpse, once again into CJKV languages and how other languages are dealt with as well. I think there is even a lot here that would be extremely informative to a person who wants to learn more about CJKV, even if they are not a developer that will be working with one of the languages. That’s only the first quarter of the book, so I don’t know that it would be worth it from just that perspective, but it is definitely a nice benefit of Lunde’s approach.

The style is very readable, but I wouldn’t just hand this to someone who didn’t have some familiarity with text processing issues on computer systems. While there is no requirement to know or understand one of the CJKV languages, understanding how computer systems process data and information is important. I did not know anything about CJKV languages prior to reading the book and have learned quite a bit. What I learned was not limited to the CJKV arena. The experience I had was very similar to when I studied ancient Greek in school. Learning Greek I learned much more about English grammar than I had ever picked up prior. Reading CJKV Information Processing I learned quite a bit more about the issues involved in things like character encoding and typography for every language, not just these four. But in dealing with CJKV specifically I’ve found that Lunde’s work is indispensable. It is not just my go to reference, it’s essentially my only reference. If any other works do come my way, this is the standard against which they will be judged.

There are thirteen indexes including a nice glossary. Nine of them are character sets, which were printed out in the longer first edition. In this second edition, there is a note on each, with a url pointing to a PDF with the information. It seemed odd, but each URL gets it’s own page. This means there are nine pages with nothing but the title of the index and a url. Fortunately they are all in the same directory, which can be reached directly from the books page at the O’Reilly site. It seems it would have made sense to just list them all on a single page, but maybe it was necessary for some reason. It’s a minute flaw in what is a great book.

Title: CJKV Information Processing 2nd ed.
Author: Ken Lunde
Publisher: O’Reilly Media, Inc.
Pages: 898
ISBN: 978-0-596-51447-1
Rating: 10/10
Tagline: Chinese, Japanese, Korean & Vietnamese computing.

One thing I love about Linux is the rapid development and frequent updates that allow me to run the latest versions of all my favorite software packages. My favorite distributions make it simple to always have the latest and greatest. In fact the distros themselves roll out new version regularly and I am always excited to see what new packages and features will be included. For book publishers this must be a little less exciting. Anything tied to a specific product that is under active development is going to quickly be behind the times. Mark Sobell’s A Practical Guide to Ubuntu Linux managed to avoid the worst of this by providing a lot of information that is useful for any Linux user running any distro. But still things move forward and almost exactly a year later we have A Practical Guide to Ubuntu Linux 2nd ed.. I was very pleased with the first edition and I think they’ve managed to really improve what was already a solid resource.

Let’s kick things off with a rough diff on the two editions. There have been improvements made in content and some added tools to rapidly get at what one needs. With the size of the book and the amount covered, these rapid access improvements are significant. The inside of the cover on the second edition has a utility index, so that a reader searching for help with any specific utility can find it quickly. This is followed up with two tables of contents, one a brief summary and the second much more detailed and taking up twenty-two pages. The new edition is about sixty pages longer than the first, but is slightly thinner and shorter. It is still a beefy book, but this is a nice direction to move.

After the tables of contents there is a list of JumpStarts. These are new to the second edition. They are short guides to getting started with key clients and servers. They come at the beginning of sections that will deal with the topic in more detail, but up front the focus is just on getting things up and running. The JumpStarts cover APT, CUPS, OpenSSH, FTP, exim4, NFS, Samba, DNS, firestarter and Apache. These are nice, as often just getting things going is the biggest hurdle and fine tuning is rather easy once that is past.

Like the first edition a DVD is included. As I mentioned Linux is a quick moving target and the dvd contains Ubuntu 8.1. It can be used as a live dvd or to do an install. Last time I checked the Canonical store, this was still the most recent version available on DVD. Ubuntu and Kubuntu 9.04 are available online and on CD. I did an install from the book’s dvd and the upgrade to 9.04 was completely painless. I don’t really see the DVD as a necessary addition but it could be a nice plus for anyone that wants to get Ubuntu up and running but can’t get the bandwidth to download it.

The section Programming the Bourne Again Shell has been removed from the Digging Into Ubuntu Linux section and placed in its own section, Programming Tools which also includes a new chapter on Perl. The chapters on Linux utilitie and the Linux file system have also been extended. Coverage of ufw was added to the firewall chapter. The appendices remain the same but three new indices have been added to cover JumpStarts, the file tree and utilities. The main index is huge, offering excellent access to everything in the book. This book shows excellent forethought from start to finish aimed at making it a natural choice to grab from the shelf whenever an Ubuntu user has a question.

This did leave me wondering though, why no database server is included in the coverage. It seemed odd to cover Apache but not the rest of the LAMP stack. Installing MySQL and PHP are simple with Ubuntus package manager, but knowing the basics of caring for them is just as important as it is with Apache, which is also easy to install. I realize that the book is already large, but I’d have liked to see this included. That said, configuring services is covered and indexed in mulitple places. This means if one did install MySQL, PostgreSQL or some other database and were looking for how to go about starting, stopping, etc. the information is there.

As before, this is still a nice guide to Linux in general. While it is most applicable to Ubuntu, much of the information is accurate regardless of the distro in question. The style is understandable and there are many examples with code or illustrations as appropriate. This entire book is a real boon to any neophyte that does not have a solid handle on getting their own answers. That group is the one that I think will benefit the most from A Practical Guide to Ubuntu Linux. Random access is easy, but reading cover to cover would also give one a nice foundational understanding of getting the most out of their machine and even enough guidance to get their feet wet in the sysadmin world. Anyone thrown into owning an Ubuntu server may find this to be a handy lifeline. More experienced users, even if they are moving from another distro may find that there is just too much material that they don’t need and already know. This really is a basic Linux guide first and an Ubuntu book second.

I thought the first edition was a solid value and the second edition offers welcome improvements with no real missteps. That they managed to put more in, not take a lot out and get it into a smaller package is quite a plus. I don’t think anyone will be throwing this in a bag and carrying it with them any time soon, but it’s a great office shelf resource for a quick refresher or getting launched. This is the kind of guide that can make the difference between frustrated failure and passion for anyone just starting out with Linux.

Title: A Practical Guide to Ubuntu 2nd ed.
Author: Mark G. Sobell
Publisher: Prentice Hall
Pages: 1244
ISBN: 978-0-13-700388-4
Rating: 9/10