Publisher:Springer, 2008

ISBN: 978-1848001206

Aimed at: Undergraduates in Computer Science

Rating: 4

Pros: Covers academic topics with plenty of introductory help

Cons: Quickly ramps up

Reviewed by: Mike James

First and foremost it is important to realise that this book isn’t about computer hardware nor is it about programming languages or assembler. It's about the theory of formal languages, grammar and abstract machines such as the Turing machine. It’s the sort of material covered in any good computer science degree.

What is special about this particular text book is that it attempts to introduce the very mathematical ideas of formal grammars and symbolic manipulation in a way that is easy to understand even if you don’t know much modern maths.

For example in the first chapter it introduces the formal mathematical notation necessary to work up to production rule grammars and the Chomsky hierarchy by spelling out what each means in everyday English. This is a very good approach but if continued at this level would make the book thousands of pages long and eventually it has to switch to using just the notation and developments on the notation without spoon feeding the reader.

What this means is that at some point the mathematically naive reader is going to stop and wonder what some expression means. This is also made harder by the fact that there is no glossary of symbols and no “crib” sheet to let you check what each part of the expression might mean.

As a result, despite the very gentle start the reader will eventually have to put some work into making the transition from non-maths speaking to maths speaking. The gentle start does however make it more likely that the attempt will be made and might encourage some readers who think of themselves as maths haters to think that it is at least possible.

A bigger problem however is that when we finally reach the Chomsky hierarchy it is presented as a table, in a fairly formal style, with very little attempt at giving the reader any feeling for what sort of language characteristics the hierarchy is controlling. It doesn’t give any insight into why we bother to build such a set of restrictions. This omission is made up for in later chapters but why wait so long to motivate such comparatively simple ideas?

The rest of the book deals with the standard ideas encountered on a course on the theory of computation working its way through finite state machines to the Turing machine and the idea of universal computer. Finally the book rounds off with an overview of computability, solvability and the halting problem and a brief excursion into dimensions of computation and the “big O” notation.

By the end of the book the reader should be able to appreciate the big questions such as P=NP? and will be either ready to move on to something more advanced or will be better educated in the very basics of computational theory.

If you are looking for a textbook to base a course on, or need a refresher especially if your maths is a little rusty, this is a good choice but it isn’t suitable as a general non-technical introduction.I hope that the next edition adds material to make up for these problems because it's a good book that could be excellent.

]]>Publisher:O'Reilly,2008

Pages: 326

ISBN: 978-0596516246

Aimed at: Professional developers

Rating: 5

Pros: A readable and informative book you will want to refer to for years to come

Cons:

Reviewed by: Mike James

Algorithm books aren’t entirely new, but this one is a little different. A standard algorithm book simply presents common or classic algorithms to do a range of things in the language of choice. Some of them, like Donald Knuth’s classic, “The Art of Computer Programming”, indulge in detailed mathematical analysis of the efficiency and properties of the algorithms. This book, however, isn’t at all academic and it’s a very good and easy read.

{loadposition morebooks}

The first chapter presents a case study describing how, despite the best intentions of the programmers concerned, selecting an algorithm for a particular job is difficult. The account is interesting and well told, a sort of “who dun-it” and it doesn’t matter that it's obvious that it was the algorithm that did it. Following this there is an introduction to the ideas involved in evaluating and understanding algorithms. Even if you know about “big O” notation it makes a good refresher course.

From here we launch into a consideration of algorithms by type with searching and sorting being the obvious place to start. Each algorithm is placed into its context and an explanation of how it works is given. Example code is mostly in C or C++ but it doesn’t really matter because if you know any block structured language you will be able to follow the examples. What is important to emphasis is that while the book presents the properties of the algorithms without trying to oversimplify you are not subjected to long derivations of the execution times or space requirements. The whole presentation is informal but informative at just the right level for a working programmer. Moving on from the essential skills of searching and sorting the following chapters are more varied and less universally useful: Graph algorithms (e.g. shortest path), Path finding in AI (e.g. Minimax, Alphabeta pruning), Network flow (e.g. Max flow, Linear Programming) and Computational Geometry (Convex Hull, Nearest Neighbour). Clearly which algorithms are of interest depends on what you are working on but the selection covers a useful range and you can expect to encounter them all in a reasonable programming career.

The final part of the book deals with slightly more exotic topics such as what to do when you can’t get an algorithm to suit – including go parallel and try randomised algorithms. The Epilog ends the book with a collection of “principes” that you should apply to your interaction with algorithms. Take to heart the last one – “Writing Algorithms Is Hard – Testing Algorithms is Harder”. Despite is not covering much of the academic analysis needed for a computer science course it would also make a really good basis for such a course or background reading.

This book is a “keeper” - make room for it on your bookshelf as it’s essential reading.

<ASIN:0072970545>

<ASIN:0321358287>

{loadposition morebooks}

{loadposition morebooksART}

]]>Publisher: O'Reilly

Pages: 390

ISBN: 978-1491948927

Print: 1491948922

Kindle: B01DAWPK6S

Audience: Programmers wanting to catch up on algorithms

Rating: 5

Reviewer: Mike James

A second edition of one of the most enjoyable books on algorithms raises the question, can it get any better?

]]>Author: Thomas H. Cormen

Publisher: MIT Press

Pages: 240

ISBN: 978-0262518802

Audience: General readers interested in Computer Science

Rating: 4

Reviewer: Mike James

An easy to read book about algorithms. What could be better reading for a programmer - or a non-programmer?

]]>Publisher: O'Reilly, 2008

Pages: 618

ISBN: 978-0596510046

Aimed at: Anyone who has an interest in programming

Rating: 4.5

Pros: A novel way to showcase good code

Cons: Not all the examples rise to the challenge

Reviewed by: Mike James

This isn’t a book you have to read – but if you are a programmer at almost any skill level you will find it deeply enjoyable. It’s a collection of 30 essays about a piece of code that each invited author regards as the most beautiful they know. It’s a simple idea but one that allows a group of programmers to write about aspects of programming that we very rarely talk about. As programmers we discuss our current problems, extol the virtues of one language over another or describe some particularly messy bug that we have managed to solve but we very rarely present each other with code we consider good, let alone beautify. Unfortunately it is a difficult topic and in this case the authors don’t really rise to the challenge. We have a range of different styles and different languages used to present the principles of good code and this makes it harder to appreciate. If code is beautiful then it will be so when expressed in a pseudo code we can all understand. Another problem is that the authors don’t really tackle the problem of describing why the code they present in evidence is beautiful. They present it and say “see this code is beautiful” and if you don’t then you are left out in the cold without any real way to make a connection to what the author saw in it. This said there are some gems and they are mostly from the authors that have a track record in expressing programming ideas – Brian Kernighan, Jon Bently, Charles Petzold, Brian Hayes and so on. However even in these essays you might well need to follow up the references to web articles or academic papers quoted. This makes the book far from self contained.

There is also the niggling doubt that perhaps the book fosters the idea that beautiful code is the invention of an inspired idiosyncratic genius rather than the result of a careful application of practice and principle – but why spoil an nice idea even if it isn’t executed as well as it might be. You will almost certainly find something to interest you among the essays, but be prepared to skip large chunks. There is clearly scope for another book under this title but with a little more editorial control and direction aimed at teasing out what programmers actually think about the code they create.

{loadposition morebooks}

{loadposition morebooksART}

]]>Author: Nell Dale & John Lewis

Publisher: Jones & Bartlett

Pages: 672

ISBN: 978-1449672843

Audience: Undergraduate students

Rating: 4

Reviewer: Mike James

A gentle introduction to computer science - just what a lot of people are looking for.

]]>Publisher: Addison Wesley

Pages: 312

ISBN: 978-0131387683

Aimed at: Cuda beginners

Rating: 4.5

Pros: Well structured, easy-to-read

Cons: Lacks overview

Reviewed by: Harry Fairhead

Is it possible to explain parallel programming in a way that makes it seem easy?

]]>Author: Paul Butcher

Publisher: Pragmatic Bookshelf

Pages: 232

ISBN: 978-1934356289

Aimed at: Every practicing programmer

Rating: 5

Pros: Excellent discussion of the strategy of debugging

Cons: Doesn't cover any specific technology

Reviewed by: Mike James

Some programmers are just better at finding bugs than others. Can this skill be taught?

]]>Publisher: Manning, 2009

Pages: 352

ISBN: 978-1933988559

Aimed at: Java developers

Rating: 4.5

Pros: A clear practical account of a difficult topic

Cons: Later chapters tend to be repetitive

Reviewed by: Mike James

It seems that dependency injection is all the rage at the moment - but can you find a clear account of what it's all about? This book satisfies this request in most respects and as such it's a worthwhile read even if you don't plan to use DI any time in the near future. Of course the book is all about Java technologies and this just emphasises the fact that other languages, and .NET in particular, just haven't kept up with these ideas.

The book starts off with a very readable account of dependency and how to manage it. Moving from getter/setter, constructor, factory objects and finally to full dependency injection as ways of coping. The argument is persuasive and the examples are short enough to follow. The only problem is that there is quite a lot of repetition in the following chapters which seem to repeat the argument for why we need DI made in the first chapter.

The book is based on the use of Spring and Google Guice - pronounced Juice and we have to forgive Google's obsession with G's. This isn't a problem but many of the early examples are explained using Spring and then using Guice or some other framework to contrast different approaches to the problem. This is a good idea but not so early in the book when the beginner might still be struggling to with the basic ideas. Also the repetition tends to undermine your understanding as you ask yourself if this is something new or a restatement of what you were told and thought you understood.

Despite these criticisms this is the best book so far on dependency injection and it is worth it for the early chapters alone which do succeed in getting the ideas across to a complete beginner - as long as you are comfortable with Java and fairly sophisticated about object technologies. So until something better comes along if you want to join in the conversations about dependency injection you probably need to read this book.

]]>Publisher: Addison Wesley

Pages: 336

ISBN: 978-0134291062

Print: 0134291069

Kindle: B01LHSV9ZI

Audience: Software Developers

Rating: 4

Reviewer: Kay Ewbank

This book aims to show you how to combine development and testing by writing testable code.

]]>