Writing: Becoming a Better Programmer

It's finally here!

My new book, Becoming a Better Programmer, is fully edited, laid out, and is now available as a final product for your reading pleasure, published by O'Reilly. You can purchase it in printed form or as a digital version for your e-reader of choice.

Find out more about the book from the O'Reilly product page. You can view the full table of contents there. Or head over to Amazon to purchase. If you are a Safari subscriber, you can read it here. Grab your iBook here.

The cover image is a flying fish. I'll leave it to your imagination to work out the significance.

It's great to finally see this labour of love come to fruition, and I do hope that stands as a useful resource for programmers today.

One of my favourite parts of the book is a family in-joke in the "advance praise" at the front. Nestled amongst the luminaries and expert programmers who graciously contributed their honest thoughts on the book is another very honest opinion:

Writing: Testing Times

My latest Becoming a Better Programmer column is published in the September issue of C Vu magazine (26.4). It called Testing Times and surveys the world of developer testing, covering the what, why, and how of programmer-driven testing. We look at feedback loops, TDD, unit testing, integration testing, system testing and more.

C Vu is a magazine produced by the ACCU - an excellent organisation for programmers. It has a great community, great publications, and an awesome conference. Check it out.

Meanwhile, my book: Becoming a Better Programmer, is nearing print. It's gone through tech review, copy edit, and layout is almost complete. You can still access the early release at http://shop.oreilly.com/product/0636920033929.do.

Writing: Becoming a Better Programmer

I am delighted to announce that I have signed a contract to publish my latest book, Becoming a Better Programmer with the excellent folks at O'Reilly.

You can find out more about the book from it's catalogue page at http://shop.oreilly.com/product/0636920033929.do.

We have now made an early access version available with a number of the chapters. It's already looking excellent, and I can't wait to get the final version out.

New Book: Becoming a Better Programmer

After many years of gestation my latest book is available for purchase as an early-access pre-release.

Called Becoming a Better Programmer, it is a handbook for people who are about code.

This early access edition already contains 14 chapters, and there are many more coming. There is a free "sample" version available so you get a taster of what you'll be purchasing.

As a pre-release, it's available at an introductory price. The price will go steadily upwards as the book nears completion. Buy now to enjoy the best value! (That's the sales pitch - I suck at that kind of thing.)

Get it from gum.co/becomingbetter. Join the book discussion here: moot.it/becomingbetter.

It would genuinely love to hear any feedback, praise or criticism that will help improve the book. Suggestions for topics to cover are also of real interest.

My honest hope is that this book does just what it says on the cover: helps many developers improve their skills, to become more productive programmers.

Buy it now!

Book review: iPhone User Interface Design Projects

Name: iPhone User Interface Design Projects

Author: Various

Publisher: APress

Price: $39.99

Pages: 252

Reviewed by: Pete Goodliffe

Book homepage: here

Verdict: OK

This is another book in APress' iPhone development series. Like all the later books in the series, it's produced in black and white, which is a shame given that the book focuses on user interfaces.

It is a collection of essays from ten different authors. Each chapter stands alone. Some of the authors are clearly programmers, and their descriptions of interface design come from a techie viewpoint. Others authors are domain experts or people who hired in programmers to get their job done. These discussions are far less technical in nature.

I've read quite a few of the APress iPhone books now, and although they are good, I'm starting to get tired of each chapter starting with a gushing "the iPhone is great" section before getting into the meat of the topic. I'd like to see a little heavier editorial control if this series continues. The chapters are personal in nature, and that is part of the charm of these books. However some of the lengthy intros add nothing of value to their chapters.

The material in this book is not as strong as others in this series. This opinion does reflect my bias as a coder rather than an UI designer, but experienced UI designers won't find much essential or new information in this book. In general, good iPhone UI design requires an understanding the native iPhone idioms and of how to create compelling touch-based interfaces for small screen sizes. Some chapters go a way towards describing this; but sadly the book is by no means a compelling or thorough discourse on the subject.

I will admit my favourite chapter was a very interesting one on the Font catalogue application FontShuffle. The UI material here was somewhat thin, but it was a really interesting insight into the world of typography.

If you're starting off on some iPhone UI design work, know nothing about the topic, and fancy a chatty, but brief, introduction to subject this book is OK. If you are a UI designer then you'll probably not find much of value here.

Book: 97 Things Every Programmer Should Know

The latest book in O'Reilly's 97 Things series is out now: 97 Things Every Programmer should know. I have three items in this book, and have just received my paper copy (photographic proof attached for the non-believers!).

Despite the somewhat underwhelming cover (it's now the series ident, apparently), it's actually a very well produced book. Thanks to everyone involved.

Details from the publisher's website here.

My contributions are:

Chapter 26 Don't Ignore That Error!

Chapter 39 Improve Code by Removing It

Chapter 96 You Gotta Care About the Code

Book review: iPhone Advanced Projects

Name: iPhone Advanced Projects

Author: Various

Publisher: APress

Price: $39.99

Pages: 374

Reviewed by: Pete Goodliffe

Verdict: OK

Book homepage: here

This is another book in the APress iPhone "projects" series. It follows the form of its predecessors; it is a series of 11 essays by different authors on a particular topic which that they have some familiarity (I'm not sure I can always say "expertise") in.

Production

First, the book production bears discussion. Unlike previous books, this one is printed in plain black and white rather than the accustomed luxurious full-colour. The book still costs the same amount, so this appears to be a ploy by publisher to increase profit rather than a way to position book at lower price point to gain more readers.

Unfortunately, the book suffers because of this. Not only is it less visually appealing, it is less practical and easy to follow. Some visual modification should have been applied to the format to make it work in B&W. Without colour, the sans-serif body text is harder to read and is less distinct from headings, subtitles, and illustrations.

In particular, many screen shots suffer. Often an author refers to details that are completely lost in a sea of black ink. These images should have been edited to improve contrast, or the text reworked to explain the point without an illustration.

Editing

On the whole this book has been well edited and proofed, probably better than some of the other books in the series. There are only a few typos. It hangs together as well as the other books, which is fine - it's a series of unconnected essays on different topics.

As another "grab bag" book, you'll either want to make a purchase if you care about a specific topic included (see below), or you just want a general overview of a number of topics.

Topics

The book covers the expected iPhone topics: Graphics/UI (creating particle systems, OpenGL ES reflections, and making responsive UIs), networking (writing an app backend server to integrate with iphone app, using push notifications, yet another socket-based UDP example, and sending an email from your app), audio, debugging, and data handling (both in SQLite, and Core Data).

Most chapters are sufficiently detailed. The audio chapter, I felt, was a chatty overview, but didn't provide as good a grounding as just reading the iPhone audio docs.

As ever, the detail in each chapter cannot replace the iPhone SDK docs which are complete and detailed. However, there are often little information gems that will help your development and save you a little time working with that technology.

Conclusion

If you're new to iPhone programming, this might be an interesting book. Also consider the other Apress titles in the series, and chose the book with the topics you are most interested in.

Book Review: iPhone Games Projects

Name: iPhone Games Projects
Author: Dave Mark PJ Cabera
Publisher: APress
Price: $39.99
Pages: 258
Reviewed by: Pete Goodliffe
Verdict: OK

This is the second book I've reviewed in this Apress iPhone series (the first being "iPhone Cool Projects"). The book has many of the characteristics of the first: it is full-colour throughout, contains clear writing, beautiful presentation, and relatively good copy editing. It hangs together about as well as the other book, too, which is "mostly".

It is a series of 8 distinct essays by different "expert" (a relative term on such a new platform) iPhone game developers. The tone and approach of each chapter is therefore different.

The collection of topics covered is OK, but doesn't spread over the entire broad spectrum of game topics: there are TWO essays on networking, TWO essays on optimisation, one on multi-platform development (interesting in an "iPhone" book), one on writing a design document, and a walkthough of a simple board game.

There are many more topics that might have been interesting chapters to have in this type of book: a 3D graphics primer, when/how to select a third party games engine, considerations for getting your game noticed in the app store, and more.

There are some recurring themes: a few authors suggest prefering C over Objective-C (for obvious reasons). There is some discussion of why C is "better" than C++ which is (to a C++ programmer) unbalanced, and misleading.

As ever, the source code to each project is available from the Apress website. The quality of some of the code is quite variable.

If you want to write an iPhone game this book might be an interesting read, but I wouldn't suggest that every iPhone game programmer HAS to buy it. Some sections of it have far more value than others. In fact, I think overall you'd get more milage from the "iPhone Cool Projects" book since it covers a broader range of topics. I'm left feeling that the two books rolled into one would probably have been a better product. And I'm still not convinced that the title is even gramatically correct.

Book Review: Pro Git

Name: Pro Git

Author: Scott Chacon

Publisher: APress

Price: $34.99

Pages: 265

Reviewed by: Pete Goodliffe

Verdict: Highly Recommended

It's not often I start a book review with glowing praise. This time, I will: if you use the git (http://git-scm.com/) version control system, or are thinking of using git in the future, get this book. It's excellent.

Pro Git available online from http://progit.org (or git clone the book's source from http://github.com/progit). This means that you can read it for free before considering a purchase. Indeed, that's where I started. However, I highly recommend the dead tree version. Apress' production quality is excellent and the paper copy is defintely a valuable thing to have.

The book is an excellent introduction to using git; it's perfect for newbies, and a good reference for existing users. It starts from first priniciples. That is, it describes what git is, and what a distributed version control system is. It briefly introduces version control in general, but that is really prerequiste information.

The text is well paced, and very clearly written. The examples are well chosen and the coverage of git's facilities is broad.

The author starts with installing/configuring git and outlines the basic git principles. He covers basic operations (check in, clone, viewing logs, tagging). Then he moves onto git's crowning glory: branching and merging. This potentially tricky topic is covered very well.

The book also covers running a git server, sensible workflows to tame distributed collaboration, useful/advanced git facilities (stashing, amending history, binary searches, subtree merging, client- and server-side hooks), and using git with other version control systems. In particular, there is good coverage of using git as a more advanced subversion client.

The final chapter is particularly useful: a great overview of git internals. This sounds relatively pointless when you've covered most git usage already. However, this is a great chapter - the author explains what's going on under the covers in such a way that you gain a much better insight into how all the high-level git operations work.

Book Review: iPhone Cool Projects

Name: iPhone Cool Projects

Author: Gary Bennet et al

Publisher: APress

Price: $39.99

Pages: 209

Reviewed by: Pete Goodliffe

Verdict: Recommended

Link: Publisher's website

iPhone programming is one of the current "hot topics" and we're seeing an increasing number of books published on this topic. This one is a bit of a mixed bag.

This is not an introductory tome; it requires significant prior understanding of the iPhone toolset and development environment. Instead, the book presents a number of complete fully-working iPhone applications covering various core iPhone technologies. It fits into a series of other Apress iPhone titles. Not having seem the other books, I can't say how well it complements the other titles in the series.

The book is effectively a collection essays by many authors, one per chapter, all "experts" at various aspects of iPhone development. Some of them have produced very successful iPhone applications.

The topics covered are: simple game programming, peer-to-peer networking, multi threaded applications, creating multi-touch interfaces, physics and 2D animation libraries, audio streaming, and creating a location-aware application with navigation-based UI. There are no topics covered that you can't fathom relatively easily from the free Apple documentation and a bit of careful thought. However the useful piece of the jigsaw is seeing how other developers have already learnt iPhone OS and solved the common problems.

The production quality of the book is high. It has been very well presented, in full colour throughout, with many iPhone and Xcode screen shots. On the whole, the writing is good. Some chapters appear to have been better proof read than others.

Perhaps the most useful part of the book is the availability of the source code for all the sample applications (from the publisher's website), so you can run and take apart the projects at your leisure. There is no bundled CD, and I'm more than happy with that.

As with many such multi-authored books, some chapters are better than others. Each chapter is relatively short, and they all basically provide an overview of their topic - enough to pique your interest, but not enough to answer any serious questions. For some topics this works better than others.

Highlights are the first game-writing chapter, the multi-touch interface chapters, and the location-based application chapter. These present useful information about how to write a "real" iPhone application. I felt let down by the threading chapter which presents a fairly glib and un-thorough overview of the perils of writing threaded apps. The networking chapter is a very simplistic introduction; nothing it says is wrong, but to write your own serious networked application you'd really need to know a lot more about network technologies.

If you're an experienced programmer who wants a casual introduction to some more meaty iPhone projects than you've seen in the introductory tests, this book may be interesting for you. It's easy to read, fast paced, and pretty.

Code Craft: Now available in Russian

I've just been sent the new Russian translation of my software development book, Code Craft. Interesting reading, indeed. If you understand Russian, that is. I have no idea how good this translation is; maybe any eager Russian readers could tell me?

As you can see, it's an interesting choice of cover for this translation. I wonder what it says about the Russian market? The Japanese and Chinese translations had bright and interesting covers, this is a rather somber affair.

Code Craft has been out for about two years now and has proved very popular. Nevertheless, it's frustrating that Amazon is not capable of showing the correct cover image in their listing.

Now perhaps it's about time I got to writing my second tome?

Book: Beautiful Architecture

O'Reilly have just released Beautiful Architecture, a follow up to their hugely successful Beautiful Code book.

I have contributed a chapter to this book, entitled A Tale of Two Systems: A Modern-Day Software Fable. Based on my experiences with two contrasting development projects, it illustrates how software architecture affects many things, from the quality of the software, through to the morale and dynamics of a team, through to the very success of a company.

It looks like a great book, and all proceeds from its sale go to Medecins Sans Frontieres.

Grab it on Amazon here.

Book review: Extended STL

Details
Title: Extended STL Volume 1
Author: Matthew Wilson
Publisher: Addison-Wesley 2007
Pages: 572
ISBN: 978-0-321-30550-3
Links amazon | publisher

The prologue

This is an unusual book review for me. Normally, I digest a technical book in a matter of a week or two and then write a review. I don't like writing a review without having fully read the entire contents of a book; it's not a fair and representative review. Consequently this review is remarkably delayed as Extended STL has taken me literally months to read.

Why is this? The information in this book is dense and not easily digested. There's a lot of complex stuff in here that - especially in order to review fully - you really have to pay attention to. I'm not sure I can entirely blame this on the book, though. It's a natural consequence of the subject material.

What's it about?

Extended C++ is the first volume in Wilson's projected two part series. This tome covers collections and iterators. That is, it describes how to create STL-compliant containers and iterators from scratch or how to wrap existing pieces of code with STL-interfacable proxies. This is a non-trivial area, with many subtle problems. The meat of the book is an in-depth description of problems and solutions in the implementation of STL-like code.

Volume 2 of the series will cover (amongst other things) STL-like functions, algorithms, adaptors and allocators. No doubt that, too, will be a dense book covering complex subject matter.

Extended C++ is a fairly unusual book in the current marketplace, and so has little competition. There are many books on learning or using C++, on good C++ style, and on C++ programming idioms. There are many books describing particular C++ libraries. But there are few specifically about writing STL-like extensions, and interfacing existing code with the STL. So there's little competition for Extended C++. If you are doing this kind of stuff then the book looks like a sound investment.

So is it any good?

This book is not an easy read. It took me an incredibly long time to complete; it's not easy to read in small chunks, or when you brain is full of other stuff. You really have to study a chapter in depth from start to finish to follow the flow.

Extended C++ opens with a set of chapters on foundational concepts and terminology. These are a refresher in some important C++ STL-related techniques, and I suspect that the majority readers will take away the most useful stuff from these chapters alone!

The chapters in the subsequent two parts (collections first, then iterators) usually cover a single example of the implementation of a STL-like component: explaining the reason for writing the component, the problems discovered during implementation, and the ultimate solution. An included CD contains all the numerous code examples in the book.

Sometimes this example-driven approach makes it hard to determine the most important information presented in chapter. It also makes Extended C++ less than ideal as a reference-work to look techniques up in.

The book contains a scattering of "tips" in callout boxes. These appear to be a rather inconsistently applied narrative conceit. They should either have been scrapped or rationalised significantly.

As you read the text, it's clear that you are getting information from someone who really knows what he's talking about, and who has done a lot of this kind of legwork many times over. Wilson's writing style is clear although sometimes I wonder whether the information could have been presented better in a different structure.

Extended C++ is a testament to the incredible power and to the incredible complexity of the language. Many of C++'s detractors could cite it as a counter-example for use of the language!

I found very few technical problems or mistakes in the text. If I was being picky, I'd criticise the author's propensity for somewhat flowery language which will leave non-native (and some native) English speakers confused (or reaching for the dictionary).

Summary

Pros

• Fairly unique coverage of this aspect of C++ coding
• Clear writing style
• The voice of an expert

Cons

• Dense information, often hard to digest
• Not ideal as a reference work

Recommended if you are writing STL-like C++ code, or want to interface legacy code with STL-style C++. Make sure you have plenty of time to sit down and digest the material, though.

Book review: Beginning Xcode

Details
Book: Beginning Xcode
Author: James Bucanek
Publisher: Wrox 2006
ISBN: 978-0-471-75479-4
Pages: 590
Links: Amazon | Publisher

This book is way old now. It covers Xcode version 2.2, which is so far behind the cutting edge it's practically blunt. It's two years old, which is about 100 years in the tech book world. So why am I bothering to post a review of such a book? Simply, because I found it useful, and it's worth doing it justice here.

Previously, I reviewed Xcode Unleashed (published by SAMS) and found it good but not perfect. I obtained this book at the same time, and it turned out to be a great compliment. Whereas Xcode Unleashed was a rapid trip through Xcode, this book walks at a more lesuirely and detailed pace. It filled in holes in my understanding left from Xcode Unleashed.

Sometimes, it was a little too lesuirely (I didn't really need 55 pages on the basic operation of the code editor, for example). But you can't fault the detail.

The author writes clearly, and the layout is not fussy, contributing well to the book. Bucanek describes the basic operation of Xcode, its projects and group/target principles, describes editing and managing items within Xcode, and the processes you'd expect: developing code, interfaces, building, debugging, profiling, and unit testing.

Although Xcode has matured considerably since version 2.2, very little of the information in this tome is stale or factually incorrect. Some of the newer profiling and analysis tools will inevitably not be covered, but all the basics are there. I wonder whether the author is working on a revision for 2009?

Summary

Pros:

• Comprehensive and detailed
  
• Clear writing

Cons:

• Old; it covers a rather old version of Xcode

A good, thorough, if old, book on Xcode developement. Suitable for complete novices to Apple development.

Recommended if you don't pay too much for it.

Book review: Xcode 3 Unleashed

Details
Book: Xcode 3 Unleashed
Author: Fritz Anderson
Publisher: SAMS 2008
ISBN: 978-0321552631
Pages: 534
Links: Amazon | Safari | Publisher

This is a fairly well-paced introduction to the world of Xcode 3. It's suitably up-to-date (relevant for Leopard development using Xcode 3.0 , it works fine with Xcode 3.1; very little has changed). This means that it will probably have dated within a year, though.

It's well a produced book, printed in full colour with a large number of screenshots and an accessible writing style. The layout has been carefully prepared, with clear and useful warning and tip callouts. This makes it easy to follow.

Anderson begins with a whirlwind tour of the development of an application in Xcode. It is an interesting tutorial. However, it only serves to give you an idea of the available features without really explaining how to use them. You get a cursory look at: developing in C, using the debugger, making libraries, using Cocoa (a frankly too-fast romp through Objective C coding and making apps for the mac, this is too much for the book really - it's such a big and complex topic), using version control (Subversion in this case), plists, bundles, unit tests, documentation and more.

Phew! After that's over you have an idea what's going on, but no great understanding of how to put it into practice in your own Xcode projects.

The second part is a far-too-brief "detailed" description of the IDE. This covers just simple project navigation, the build system (for make veterans), debugging, and some of Apple's cool profiling instrumentation mojo. I'd've hoped that this second part would be about twice the size of the tutorial section. However, it's about half the size.

This book is a good introduction to using Xcode, but ultimately leaves you with as many questions as the answers it provides.

Summary

Pros:

• Full colour, many screenshots
  
• Good writing style
• Good broad overview of development with Xcode
  

Cons:

• Not in-depth on any topic
• Fairly unless index
  

I'd recommend this as a fast-paced introductory text for an experienced programmer who knows nothing about Xcode. But it will only whet your appetite. You'll probably need another more in-depth tutorial afterwards to really get under the hood of Xcode.

Recommended with reservations