Independent developer book reviews by and for practitioners

With the phenomenal success of jQuery it should be no surprise that introductory books are two a penny these days. Some of these are truly dire and not to be recommended under any circumstances. That's not the case with Jack Franklin's 'Beginning jQuery' (Apress). This is by far the best of the introductory titles that have passed this way recently.

The book is pitched at the developer with little previous experience in the way of JavaScript, so the book opens with a fast introduction to the language. If you're au fait with JavaScript you can safely skip this opening, but if you've only ever dabbled briefly in the past then it's a good reminder of the basic syntax, how scripts are linked to a web page and a fly-past of console debugging. From there it's straight into the proper introduction to jQuery and the document object model (DOM), a topic that is covered in more detail in the next two chapters.

Events are covered in chapters five and six, including event delegation, propagation and the binding/unbinding of events. This is followed by a chapter on Animation and another on Ajax, before moving into the last three chapters of the book which are all about building jQuery plug-ins. While the range of topics is pretty much what you'd expect from an introduction, and therefore doesn't really differ from most other books pitched to the same readership, it's the writing, the examples and the code that really make the difference.

What comes across really clearly is the author's obvious enthusiasm and belief in jQuery as a great platform. And he wants to convince you, the reader, by showing you how to get decent results while picking up some best practices and experience in working with jQuery and JavaScript. [Continued]

VBA provides plenty of methods for traversing Excel workbooks using Cell and Range objects. It's relatively straightforward to write code that cycles through a worksheet to process cells. However, when you're dealing with very large worksheets with thousands of rows and columns, then you soon see that while the code is easy to write, the performance can slow to a crawl. And it's not just VBA that starts to slow things down - large worksheets that are heavily studded with array formulas and look-ups can also be painfully slow to perform.

The good news is that VBA provides the tools and objects to massively speed things up. The key to this is to use variant arrays to grab all the data from a woksheet or range and then to work on this array. The performance improvements can be dramatic - something that takes hours can be done in minutes.

The starting point is simple - we grab the values from a range and assign them to a variant array:

Sub test()
Dim vData() As Variant

    vData = ActiveSheet.UsedRange.Value
    Debug.Print "Rows: " & UBound(vData, 1) & " Columns: " & UBound(vData, 2)

End Sub

The important thing to note is that the variant array is two-dimensional, with the first dimension mapping to rows and the second to columns. [Continued]

New books on C programming are few and far between, far fewer even than new books on Java these days. Still rarer is a book on C that does more than give you and tweak on Kernighan and Ritchie or a dummies guide to some basic syntax. Bob Klemens aims to do more than just give you some curly braces syntax and a run around pointers to pointers to poi… you get the picture. Instead Klemens sets out to show you, dear reader, that C is a viable programming language for general purpose coding, with all the conveniences that developers in other languages take for granted - you know, stuff like library management, automated build tools, integrated environments, decent libraries and so on.

The first thing to point out is that this is definitely not a book for the beginner. It's assumed that you already have a grasp of the syntax and a degree of familiarity with the 'classic' C development paradigm - you know how to write code, how to build a make file, how to compile and link etc. That said, it's not assumed that you're a C guru, so often new topics are introduced with a bit of revision and some reminders.

I fit the target demographic for sure. I started developing a long time ago, and my first languages were C, assembler and APL (yes, I know, extreme ends of the spectrum when it comes to abstraction). But in the years since then I've coded in just about everything, but have pretty much left C (and assembler and APL), behind. When I've had to code in C, it's because I needed something extra in Java and JNI was easy enough to use, but even that was half a decade ago. So, has the book rekindled a desire to code in C again?

To be honest, I almost turned away at the first hurdle. The first section of the book is all about setting up a modern programming environment. I was hoping that there'd be the lazy way into this - a chapter on Eclipse or Netbeans or some other modern and cross-platform environment. [Continued]

This is the sort of glossy, good-looking book that makes you want to dive and get reading straight away. While it's not aimed at the hard core coder, there's a degree of technical content that puts it above the ranks of those 'become a WordPress guru in 10 minutes' books, of which there are plenty on the market. The pitch here is that this is the book that will help you move beyond the stage of merely using WordPress and take you into custom templates and detailed design. Unfortunately though, the book doesn't quite deliver all that it promises.

First the positives. The author walks the reader through the process of setting up a working development environment, meaning installing and running WordPress on a server, including the basic admin tasks. This is good for those who've never had to do this kind of thing before. There's some good material introducing templates and themes. And the author introduces a development style that uses HTML/CSS to build the design and then incrementally replaces these elements with templates and PHP calls. It's a good way of working, particularly for those who happier doing design using their existing HTML/CSS experience.

But these positives are counter-balanced by a number of negatives. Firstly the author breaks some fundamental rules (at least in this reader's opinion) in referring the reader to material on the accompanying web site and then not including the relevant information in the text itself. It means you can only make sense of some sections of the book when you're in front of a browser - which makes reading the book in the bath or on the train tricky. Secondly the source code in the book is colour coded (which is good), but the colours aren't always in the right place (which isn't good). [Continued]

The vast majority of computer books promise to make you a better developing by focusing on teaching a new programming language, new development paradigm or a specific technology. While these can be interesting, the plain fact is that for many new developers what's needed is not more syntax but more practice and not just practice doing the same things. And this is where this book steps in. The emphasis is not on syntax, programming theory or even application domain. Instead this is a book that's intended to help the new (and perhaps not so new) developer extend their skills by, essentially, reflecting and thinking about programming in a way that they possibly wouldn't normally.

On the whole this means focussing the attention on problem solving, algorithmic thinking, developing structured work habits and really paying attention to the process that you go through when developing code. Note that this is not the same as presenting a set of ready made algorithms or design patterns. While there are lots of good books on algorithms and data structures, and generally these really ought to be on the reading list for every serious developer, this is not what's on offer here. Instead the author presents some simple problems and in solving these in a step by step fashion he draws out lessons and code that are further developed. So, for example, a standard data structure like a linked list is introduced and coded from scratch rather than just being taken off the shelf and slotted into place.

Good developer skills, like decomposing problems into manageable chunks, solving specific sub-problems in order to generalise solutions, building your own code libraries and so on are central to the book. While some of this might seem obvious to a grizzled old pro, they're skills that are likely to be missed if your focus is on learning the syntax of a language or you're struggling to understand object orientation and so on. [Continued]

Programming Joomla!, Think Complexity, Scala For The Impatient and more..