Profile for Thing with a hook > Reviews

Personal Profile

Content by Thing with a hook
Top Reviewer Ranking: 239,553
Helpful Votes: 466

Learn more about Your Profile.

Reviews Written by
Thing with a hook

Page: 1 | 2 | 3 | 4 | 5 | 6 | 7
More C++ Gems (SIGS Reference Library)
More C++ Gems (SIGS Reference Library)
by Stanley Lippman
Edition: Paperback
Price: £48.00

4.0 out of 5 stars Interesting grab-bag of C++ topics, 19 Feb 2007
This is a collection of articles from C++ Report. A big book at 500 pages, but well-read C++ users, even if they've never read The C++ Report, may have come across a lot of the material before.

All of Herb Sutter's contributions (apart from a parody article about a 'BOOSE' language) have appeared in his Exceptional C++ trilogy, John Vlissides' article turns up in Pattern Hatching (itself a distillation of his columns in C++ Report), three articles by John Lakos are a distillation of his Large Scale C++ Software Design, and Robert C. Martin's discussion of The Open-Closed Principle is reminiscent (although by no means identical) to his coverage of it in his Agile Software Development book. That makes up about a third of the book.

However, the rest of it was new to me. In addition to Herb Sutter's articles on exceptions, further treatment of exceptions is given in articles by Richard Gillam and Matt Austern. There's also coverage of the Monostate and External Polymorphism patterns, a couple of threading patterns by Douglas Schmidt and some architectural patterns: Taskmaster (for GUIs), and Alberto Antenangeli on object-relational mapping patterns.

The quality of the articles is uniformly high, but of course the book does not feel particularly cohesive, given the large number of authors and topics covered. I would not say that, from the perspective of 2007, there's insights here that you absolutely cannot find elsewhere. And to some extent, if you're sufficiently into C++ that you would consider buying this, you've probably got a lot of the books I mentioned earlier.

But taken on its own merits, there are lots of good articles covering lots of subject matter, including that oft-ignored topic in C++, threading. If you're a C++ junkie, and the compilation format of the book appeals to you, this is worth your time.

Pattern Hatching: Design Patterns Applied (Software Patterns Series)
Pattern Hatching: Design Patterns Applied (Software Patterns Series)
by John Vlissides
Edition: Paperback
Price: £21.31

4.0 out of 5 stars Good while it lasts, 19 Feb 2007
This is a collection of the author's columns of the same name from C++ Report. This is not a tutorial; you need to be familiar with the original patterns from the GoF book, and the more you like C++, the better.

The book takes you through a couple of extended examples, including an abstraction of a Unix-style file system, slowly building up functionality, and demonstrating how to introduce patterns and choose which one to use. If you're looking for some examples of how to use patterns, along the lines of Design Patterns Explained, this is one of the best books you could hope to read. There's also a couple of non-GoF patterns. In particular, the chapter that details some of the discussion between the GoF on the merits of the proposed Multicast pattern is a very illuminating expose of pattern thinking.

While it's unclear who wrote which bit of the original GoF book, from reading Pattern Hatching, it's an enormous pity Vlissides wasn't handed the lion's share of the writing task. Where the GoF book can be stodgy and opaque, Pattern Hatching is informal and conversational. Vlissides clearly had a love of writing, and he gives advice on writing style for patterns in the final chapter.

A caveat is the C++-centric approach of the book. It no doubt made a lot of sense in the context of the original articles in a publication devoted to that language. Non C++ users should be warned that a large chunk of the book considers handling memory management with singleton - you may not find much of value.

And as other reviewers have noted, this is a slim book of 150 pages. If you have to pay more than a tenner for it, you probably will feel a bit ripped off.

That said, the material that is here is very good indeed, especially if you're a C++ user. If you can find an affordable copy, you should definitely get it.

Agile Database Techniques
Agile Database Techniques
by Scott Ambler
Edition: Paperback
Price: £22.94

2 of 2 people found the following review helpful
4.0 out of 5 stars go boldly beyond the persistence layer, 11 Jan 2007
This is very well written, enjoyable book, with few (if any) competitors. Given its agile sensitivities, it's perfect for a programmer looking for an overview of the whole data modelling she-bang, from use cases to impedance mismatch. Despite clocking in at 400 pages of fairly dense type, interspersed with various tables and UML diagrams, it's a breeze to read. It assumes a bit of knowledge of database technologies, but you don't need anything more than a nodding familiarity with SQL and basic concepts like normalisation.

This book deals with a lot of issues related to using databases as part of agile modelling. The main message is that agile application developers need to think about persistence issues, and database admins need to understand agile development. The differences between data-driven and object-driven models are clearly laid out, and there's an excellent section on refactoring databases.

The important thing about this book is not so much offering you specific solutions to problems, but alerting you to potential problems you might not even know exist, and explaining that you do have options in solving them. As well as introducing agile methods like TDD and refactoring, it also covers database issues like transactions, security, concurrency and object-relational mapping.

Additionally, there is an emphasis on the organisational and political issues you might face in transitioning to agile methodologies, and it's very pragmatic in pointing out that some things that might be considered the preserve of an application developer, could be done in the database itself. The issues are presented at the same level of detail as those presented in the likes of The Pragmatic Programmer (but a different subject, of course). For more specifics, you will need to turn to the likes of Martin Fowler's Patterns of Enterprise Application Architecture, or to see specific technologies being used, Chris Richardson's POJOs in Action. I would definitely recommend this book before reading those.

As someone with little knowledge of databases, I found this an excellent and unique resource to join up the dots when it comes to persistence and agile.

Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to OOA&D
Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to OOA&D
by Brett McLaughlin
Edition: Paperback
Price: £25.02

33 of 35 people found the following review helpful
4.0 out of 5 stars fun take on object orientation basics, 5 Jan 2007
HFOOA&D is designed to introduce the reader to the process of designing software. It doesn't push a formal methodology, but covers the basic building blocks that are common to most approaches, including requirements gathering, use cases and iterative design. Additionally, there is heavy emphasis on design principles such as the Open-Closed Principle, and the Single Responsibility Principle and more general concepts such as encapsulation and cohesion. UML class diagrams are used, but no more than the basics. Design patterns are mentioned in places, but you don't need any knowledge of them to understand what's going on. This book is more about the principles that underlie design patterns. Indeed, for those wondering where this book fits in with Head First Java and Head First Design Patterns, you should read HFJ first, then this one, and then HFDP.

Java is used as the language throughout - while Java 5.0 features are avoided (apart from enums), you still need to know the syntax and be comfortable with the mechanisms by which Java implements objects, such as interfaces. You can't jump into this book with just knowledge of VB, for example.

The material is treated in the usual Head First style: off-the-wall scenarios, conversational writing, lots of dialogue delivered in a pseudo-comic book style by using photos of real people, anthropomorphism of computer terms. A lot of effort is put into making the experience seem as much like social interaction as possible. It's a winning formula, and it works again here.

But Head First Java and Head First Design Patterns were two really stellar books. So, by comparison with those two, I must admit to being a little disappointed with this one. Maybe it's because this book was rewritten from scratch over a short time period, after an initial treatment by Dave Wood (google hfoobook to find the old webpage), but while there are some nice touches here and there, overall, this lacks the pizzazz of HFJ and HFDP. There are noticeably fewer pop culture references and the use of characters and scenarios are less memorable. Also, there are a couple of rhetorical devices lifted from HFDP. These are less fresh the second time around.

And in parts, the explanations are a little fuzzy. Partly this is due to the inherent fuzziness of design, partly due to the approach this book takes of showing the different aspects of analysis and design in an iterative fashion, with a series of long examples, which work very well in other ways. But Head First Design Patterns demonstrated that you can tackle this sort of material with clarity. Here, I suspect many will be left feeling confused about the difference between association, aggregation and composition in UML - some Java examples would have been illuminating.

However, HFDP was always going to be a very tough act to follow. If HFOOA&D isn't quite as good as that, it's still far preferable to slogging through the sort of heavyweight process books it competes with.

Head Rush Ajax (Head First)
Head Rush Ajax (Head First)
by Brett McLaughlin
Edition: Paperback
Price: £25.83

10 of 10 people found the following review helpful
5.0 out of 5 stars Another cracker from the HF stable, 12 Dec 2006
You may, like me, be wondering what the 'Head Rush' appelation is all about compared to the 'Head First' series. This is a slimmer book than the 'Head First' series, coming in at 400 pages (compared to 700-800 for the HF series). Also, it's focussed on a smaller topic. Apart from that, though, it's exactly the same format as the HF books, with some old HF characters popping up. HF stalwarts may be surprised to find that Frowning Woman In Denim is absent from this book, though.

As a prerequisite, you need to know HTML and CSS. You should also know a bit of Javascript. Nothing too fancy, just enough syntax to follow variable definitions, loops, conditionals and subroutines. If you don't know JS at all, I think you'll have trouble keeping up. The server side code is all in PHP. I don't know PHP, but it was close enough to Perl that I had no difficulty following it.

You also probably don't want to know too much about Ajax already. In fact, if you've done a lot of Javascript before, you may find the chapter on DOM a bit slow going. You'll find the pace just right if you're someone who's taking their first step in scripting on the browser side.

Brett McLaughlin proves he can do the HF style in this book. No worries there at all. In the first chapter, you could perhaps argue that some of the diagrams are over-annotated and have just too many arrows in them. In previous HF books, it was normally obvious what the flow of the diagrams were. Not so here, in a few places. However, from chapter 2 onwards, things are fine. In fact, the whole thing is a delight, as usual.

HR Ajax covers the basics very well and entertainingly so: what makes Ajax different from standard HTML requests, asynchrony, manipulating the DOM, and using XML versus JSON. Plus it mentions some browser-specific gotchas (including Opera and Safari), and provides very brief introductions to JS libraries like Rico and Prototype. Hardcore JS GUI-masters, this is not the book for you. Newcomers to Ajax, start here. You'll be glad you did.

Accelerated C++: Practical Programming by Example (C++ in Depth Series)
Accelerated C++: Practical Programming by Example (C++ in Depth Series)
by Andrew Koenig
Edition: Paperback
Price: £25.59

50 of 51 people found the following review helpful
5.0 out of 5 stars A C++ book that keeps on giving, 9 Dec 2006
This is a tutorial book on C++, but it goes well beyond the basics. In fact, I'm pretty sure it covers pretty much every major language feature and implementation detail you need for robust C++ coding. As such, it merits re-reading as your understanding of C++ grows, and I say that as someone who rarely re-reads computer books. Don't worry - it packs all the important bits of C++ in under 300 pages. And allow yourself a smug pat on the back when you're confident about everything that's written here.

C++ books historically assume the reader is migrating to C++ from C, and adopt a 'ontogeny recapitulates phylogeny' style approach, introducing low level details from C, before the more advanced features. This has the effect of swamping a beginner with unnecessary complications, when in fact the abstractions of modern C++ hide memory managment and pointer issues entirely. The authors of Accelerated C++ have recognised this and introduce the likes of strings and vectors very early, so their examples actually do something practical. They use an extended example of keeping track of student homework records for many of these early chapters, and the skill with which they are able to slowly introduce new features as they extend the scope of the code is very impressive.

As a result, someone with experience of procedural programming can probably get through the first six chapters, which is just under the half the book. By which time, they've been introduced to the standard library's string class, plus various containers and algorithms. All this and not a mention of a pointer or a malloc.

After this point, however, the discussion becomes a little less hands-on, and focuses on defining your own types. The authors do this by walking through the creation of basic versions of the vector and string class. This covers issues ranging from templates to constructors and destructors, to overloading operators, and I would advise previous exposure to basic object oriented principles like encapsulation to be able to follow it fully.

Pointers and arrays are eventually introduced, and then there's a fairly involved chapter on using 'smart' pointers to manage memory. At this point, I would recommend having been previously exposed to C and to be comfortable with pointers and allocating and freeing memory.

Finally, there's a chapter on object-oriented programming, making use of polymorphism. This is not the strongest part of the book. The mechanics of polymorphism in C++ are well described, but the underlying design issues are not.

If you're looking for a book that will teach you C++ from the ground up in one sitting, forget about it. No book can do that, C++ straddles too many programming paradigms. But this book comes close. I would suggest reading as far as you can until your brain hurts, then following up with a book that has a more traditional arrangement of topics - if you have knowledge of C, then Bruce Eckel's Thinking in C++ is perfect. Then, come back to this one, you'll probably find you can get a little further before getting stuck.

With that in mind, this is a book I would unhesitatingly recommend for anyone seeking to learn C++, whatever their level of expertise. Unlike other introductory books, experienced programmers will not find themselves skipping large chunks of the introductory chapters. And if you're already using C++, but treating it just as an improved C, this will open your eyes to the C++ way of doing things.

Of all the books published on C++ over the years, some titles crop up again and again on the recommended reading lists. This unique book is one of them and it's entirely deserved. If only there were more out there like this one...

Learning JavaScript
Learning JavaScript
by Shelley Powers
Edition: Paperback

16 of 16 people found the following review helpful
3.0 out of 5 stars decent introduction, marred by typos, 10 Nov 2006
This review is from: Learning JavaScript (Paperback)
As an introduction to javascript, this book covers all the ground you'd hope it would. It introduces JS in the context of a standalone programming language with its various procedural constructs, before moving onto the Document Object Model and Browser Object Model, touches upon objects, and finds the time to explain Ajax. Finally, there's a whistlestop tour of the commonly used JS libraries like Dojo, Prototype and Shelley Powers also sprinkles her opinions on JS best practices throughout, with a bias towards favouring accessibility over whiz-bang flashiness. I would recommend being comfortable with XHTML and CSS as a prerequisite for this book - something like O'Reilly's own Head First XHTML and CSS would be very suitable.

If, like me, you know a few programming languages, but nothing about JS, and wanted a crash course so you could understand what all the fuss about the likes of Ajax or the Google Web Toolkit is, this is just what you need. So why am I only giving it three stars?

First, I thought some of the features weren't very well explained - the writing lacks clarity when describing important points. Compounding this, a few of the examples are poorly chosen. Some of my quibbles may seem picky, but the feel of the book is that it's pitched at an inexperienced programmer, and a lot of the time I only followed the discussion because I was already familiar with the material from other languages. Some particular points follow.

i) Accessing the length of various parts of a multidimensional array is illustrated with:

alert(threedPoints[2][2].length); // prints out 3

alert(threedPoints[2].length); // prints out 3

alert(threedPoints.legnth); // prints out 3

ignoring the error on the third line (more on that later), as can be seen from the comments, a three dimensional array has been created where every dimension is of length 3 - surely making them of unequal size would have been more illustrative.

ii) The example of the associative array manages to be even worse:

assocArray["one"] = "one";

assocArray["two"] = "two";

I struggle to think of an example that could be more misleading.

iii) While the author recognises the importance of regular expressions, and goes into reasonable detail, the material is not terribly well organised, and the examples become complicated too quickly.

iv) The section of chained constructors, and the use of call and apply is also unclear - disappointing, given I was most interested in the prototype style of object creation that JS uses.

v) The callback functions of Array are not well described. The function Filter, apparently, "ensures that elements are not added to any element unless they pass certain criteria". So, elements are not added to any element - huh? wha? Those familiar with the likes of Lisp, Python, and especially the iterators in Smalltalk and Ruby will be able to pick up what's going on, but newcomers may be baffled.

vi) The attempt to explain recursion is weak. Admittedly, most programming books do a bad job, but what's here is far too short to be useful. An illustrative quote is: "think of each iteration of the function call as pushing the string and numeric sum onto a stack, and when the numeric array has been traversed, the string and number have to be popped up through the stack to the top". I'm not saying this is wrong, but I do not believe that someone who's just been introduced to recursion would find this description helpful.

vii) Not all the programs have their output shown. This wouldn't be easy for some of the more complicated examples, but a lot of them are text-based.

Second, there are lots and lots of typos in the book. When even a JS noob such as myself spots them, you know there's something up. Fortunately, they're only minor, and they generally aren't sufficiently bad to mislead. As an example, when function literals are introduced, the rather vital keyword 'function' is missing, but the examples quickly clarify the matter. However, elsewhere, some of the code won't actually run as presented (as early as the second example, alas), and it does take the shine off the production. Either the technical reviewers were asleep, or the editors at O'Reilly ignored them. Someone ought to be embarrassed, at any rate.

None of these things are sufficiently show-stopping for someone who knows a little programming, so I would still recommend this book before wrestling with enormous tomes like David Flanagan's JavaScript - The Essential Guide, or a dedicated Ajax book. Complete beginners and the inexperienced, however, should look elsewhere, I'm afraid.

Java Concurrency in Practice
Java Concurrency in Practice
by Brian Goetz
Edition: Paperback
Price: £31.19

61 of 61 people found the following review helpful
5.0 out of 5 stars At last! A readable expert book on Java concurrency, 7 Aug 2006
Concurrency is hard and boring. Unfortunately, my favoured technique of ignoring it and hoping it will go away doesn't look like it's going to bear fruit. Fortunately, Java 5.0 introduced a new bunch of concurrency utilities, that work at a higher level of abstraction than marking blocks as synchronized and fields as volatile. Unfortunately, there haven't been that many books on the subject - even the good Java 5.0 books (e.g. Head First Java or Agile Java) make little mention of them - Thinking in Java being an honourable exception. Fortunately, JCIP is here, and it is authoritative stuff. And it's (mostly) very easy to understand. Plus, at 350 pages, it's not an enormous chore to slog through. It even covers changes to the upcoming Java 6.

Before tackling this book, you should have at least some idea of pre-Java 5.0 concurrency. You don't need to be a threading master, though, as the first part of the book covers basics like deadlock, atomicity and liveness. This was my favourite part of the book, as it comes with lots of small code snippets, both right and (horribly) wrong, and pithy design guidelines. It's rather like Effective Java in that respect - although the material on threading was probably the weakest part of that book, so this is a definite improvement.

The second part deals with thread pools, cancellation strategies, and GUIs. This is also excellent. Part three covers performance and testing. The last 75 pages are for advanced users and goes into a fair amount of low level detail (including a discussion of the Java Memory Model), which may be of interest to experts only.

I would be lying if I said that reading this book will demystify concurrency completely. Who wrote which bit of the book is unclear (although readers of Effective Java will probably spot parts of the text that seem rather Joshua Blochish), but while it's mostly very clear, some parts of the text are a little murkier than other. Perhaps this is to be expected given the subject matter. But for the most part it's surprisingly easy reading, and very practical to boot.

Let's face it, short of aliens landing and introducing a radically new way of computing, multicores are here for the medium term at least, so thread-dodging wimps such as myself will just have to get used to it. That being so, this book is going to be installed as one of the must-read books in the Java pantheon.
Comment Comment (1) | Permalink | Most recent comment: May 31, 2011 2:45 PM BST

Python Cookbook
Python Cookbook
by Alex Martelli
Edition: Paperback

16 of 16 people found the following review helpful
4.0 out of 5 stars More than a cookbook, 6 Aug 2006
This review is from: Python Cookbook (Paperback)
String handling, money, time, dates. Email, network sockets, cgi, xml. The staples of the cookbook, and Python Cookbook certainly has these. However, interspersed throughout are chapters that seem to have come from at least one other completely different book, a more discursive rumination on Python programming in general. Each chapter begins with a mini essay from a Python luminary, and the discussion of each recipe is fairly extensive.

If you do any scientific or engineering work, you'll know that Python is everywhere on the scientific desktop, providing bindings, scripting and GUI front ends for ancient Fortran/C monstrosities. Reflecting this interest, there is a strong emphasis on performance, with chapters devoted to algorithms and searching and sorting.

Elsewhere, those who have graduated from the plethora of beginner's books, but have been bemused by the complete lack of any intermediate texts, will be pleased to find chapters on Python shortcuts (getting the most out of sequences for the most part) and one on generators and iterators. Futher, there is a chapter on OOP the Python way (including examples of dynamic delegation and design patterns implementation), and one on metaclasses.

This is an extremely useful book, particularly the chapters on using Python's basic collections, which will furnish the reader with some essential idioms for efficient use. However, this, and the OOP chapters would have been better as a separate book. But in lieu of a Thinking in Python or Effective Python, you need this book if you want to do any serious development in Python.

As a cookbook, it has everything you will be expecting as a springboard for exploring the standard library, except for regular expressions. But these are so well covered in introductory books, that you won't need enormous coverage here. On the other hand, the material is presented in a fairly wordy manner, which makes for interesting reading, but for dipping in and out, makes finding things more difficult than it might be.

The other notable thing about Python Cookbook is that it has rather a large number of errors in it. You will want to check the O'Reilly website for the errata, especially if you don't have the most recent printing, rather than scratching your head over why the Singleton implementation doesn't work at all.

Nonetheless, this is a vital resource for Python 2.4 users; even if you don't think you need a traditional cookbook, there is an enormous amount of material here you can benefit from.

Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series)
Patterns of Enterprise Application Architecture (The Addison-Wesley Signature Series)
by Martin Fowler
Edition: Hardcover
Price: £35.99

22 of 22 people found the following review helpful
4.0 out of 5 stars key book for enterprise patterns, 29 July 2006
Even if you find enterprise stuff immensely dull, dealing with databases and web pages is a pretty common task, most of the action in software development revolves around it, and who wants to be completely ignorant of the the alphabet soup of various technologies the IT blogs, books and websites are floating in?

So if you must immerse yourself in this area, what better than a Martin Fowler book? The code is mainly in Java, with a fairly large smattering of C#. It would probably help if you understood some basics of enterprise development in those languages, e.g. servlets and JDBC for Java.

The patterns in this book cover organising domain logic, database mapping and access, web presentation, concurrency, and the book finishes by covering base patterns, a mixture of lower level abstractions of the sort covered in Fowler's first book Analysis Patterns (e.g. Money) and those that bear a close resemblance to the classic vanilla Gang of Four patterns, with an enterprise twist (e.g. Plugin and Gateway). Nearly all the other patterns refer to these, so I don't know why these didn't appear first. Apart from that though, the book is very well organised. And the opening essay, that discusses the trade offs of every pattern and how they fit together in an application, is immensely helpful.

Wizened enterprisers looking for new material will not find much new here, but surely the point of patterns catalogues are to get down on paper the practices of those same wizened enterprisers, not to strike off in new directions. Therefore, an experienced developer should see this as a way to organise what they already know, and maybe in doing so, reveal some new insights.

A newcomer to enterprise development will definitely get a lot out of this, as the underpinnings to the plethora of modern enterprise applications are laid bare. You're not going to become a Hibernate, Struts or EJB expert from this book, but you should at least have a clue about what problems they're trying to solve.

As usual, Fowler manages to be a model of clarity, while still injecting regular touches of wry humour, quite an achievement given the potentially bone-dry material. If you want to know the basics of enterprise software, start here.

Page: 1 | 2 | 3 | 4 | 5 | 6 | 7