Book Reviews
Just as I have a book reviews section at my spanish website La Web de Programacion, here you will find reviews in english of books I've purchased or obtained on purpose and I think can be of interest to anyone.
Last Update: 07 of March 2010
Index of books reviewed (in order of publication):
Title: PHP Objects, Patterns, and Practice
Author: Matt Zandstra
Language: English
The book starts a bit silly. If I'm reading a book about object oriented PHP development, is because I WANT to do OOP with PHP, you don't have to sell it to me or tell me that since previous versions there was some hideous object orientation-like structure. I fear this comes to "fix" the issue that a most of the opensource PHP projects I've seen are not object oriented (or were not when I looked at them), so the book tries to teach how to do things better in OOP.
Apart from that, it starts not teaching you the basics of PHP, but entering directly into objects in PHP5, which I appreciate. It goes step by step explaining everything, and giving good advices of bad practices to avoid.
There are a lot of notes of how to "fix" the code for PHP4, not bad, but a bit annoying. Given the poor object orientation of all previous versions, the book should stick to PHP5 only.
The book explains all basic concepts of OOP (including advices and good practices), UML diagrams, going on to specific design pattern implementations in Part 3 of the book. This has been for me personally the "gold" part of the book, specific PHP 5 implementations of DP allowed me to see true object oriented source codes.
The patterns come from three widely known books, and are very well explained. We can find from the typical Singleton or Factory, to some other advanced ones like the Strategy or the Observer.
The code samples are quite good, giving you direct examples of how to implement a Factory design pattern or playing with classes and inheritance to show exactly how they work. There is a lot of theory and good practices too. Much better than the usual hello world and simple ones, this codes can be really of help in real word scenarios.
Avoiding reinventing the wheel, whenever necessary the book mentions the SPL (Standard PHP Library) for already available pattern tools and objects (like the Observer or the Iterator).
Chapter 11 goes on some Gang of Four patternns (the classics), but chapter 12 talks about enterprise patterns, and chapter 13 database patterns.
One of the big examples is actually how to build a full MVC engine, with a frontend controller, an application controller for the logic, views, templates (including the Template pattern by Flowler)...
After the MVC and presentation patterns, another bunch of Business Logic Layer patterns (like the Domain Models), and then goes into Database patterns, like the Data Access Layer, Identity Map...
When approaching serialization, gives good advices on how to do it. And if any kind of code hack or "non-perfect technique" is performed, we are advised of it very clearly. I wish other books were so careful to try to teach only good things...
After a bit more than 300 pages, the book switches to non-coding advices, tips and basic knowledge, like source code control (but using CVS, which is quite outdated!!), PEAR, testing with PHPUnit, automated builds...
This part for me felt a bit like filling up pages of the book. If I want generic advices I will search for them, I was searching for design patterns applied to PHP and as much as general advices, not more than 160 pages of non-patterns stuff.
Being a .NET developer since years, at first looks strange to me to be teached once and again that I should use classes and structure accordingly the code. While not yet perfect, object orientation in PHP5 looks useful enough to be able to do really good architectures for web applications, it just lacks more restrictions to avoid an inmense amount of errors that still can happen if you're not a skilled PHP developer (things like dynamic properties creation, untyped parameters or dynamic class instantiation should be at least redone in a more restrictive syntax).
Also, I liked the author's point of view, not telling you to always implement design patterns the same way, but understand what they try to solve, and extract what you need for your projects. I really wish other books (whenever about PHP or any other language) had so good and real-life practical examples as this one.
This book is a must-read for PHP developers that want to take out the common thinking of "you can't do clean code with PHP" (which sadly occurs too often). Even when it should be only 300 pages, is worth it.
Title: Masters of Doom: How Two Guys Created an Empire and Transformed Pop Culture
Author: David Kushner
Language: English
Masters of Doom is a semi biographic book. You won't find source code on it, or algorithms to create awesome 3D games. Instead, you will read about the creation and evolution of id Software, and specifically of John Carmack & John Romero, early adopters of the Shareware software distribution model, creators of the revolutionary Doom and the first truly 3D first person shooter (Quake)...
This is a book about motivation, about people good at what they do, but also commited to do things well and get to the top. A book of how hard effort sometimes comes with a good reward. It servers as an example of a (huge) success on creating a startup. Carmack is a 3D guru and a maths monster, and John Romero was good motivating people and doing PR.
Obviously with this kind of books, some info is skipped (for example, id Games have never been acknowledged for having deep or elaborated plots, in fact Quake's plot is not only missing but the resulting theme is a frankenstein-like mixture of medieval, futuristic and horror graphics and monsters), but overall you get a nice picture of how everything happened at id Software.
If, like me, you grown up playing Wolfenstein, Doom and Quake, if you were able to see the creation and rise of the FPS genre, you will surely enjoy this book and the story it tells. If not, it might still serve you as inspiration and motivation.
Title: Design Patterns: Elements of Reusable Object-Oriented Software
Author: Erich Gamma, Richard Helm, Ralph Johnson & John M. Vlissides / Addison-Wesley
Language: English
A design pattern is a verified and correct solution to a well known problem
or situation.
This book should be mandatory for all software engineer students. Design
patterns are, at least in Spain, sadly not very common, and of those times that
are actually used, a few are incorrectly used (for having read about them in a
small tutorial but not properly understood the specific pattern).
The patterns explained are divided in three groups:
- Creational: As the name implies, groups patterns related to object
construction and instancing.
- Structural: How to structure, organize, architecture, join and access
objects.
- Behavioral: The more varied one. From ways of communication between objects,
to command systems, hiearchies, state management…
The nice thing of design patterns is that not only they provide you solutions
to problems you might encounter in the future, usually you find solutions to
problems you’ve had too (and how knows, maybe you used the same approach without
knowing it was a design pattern!).
Some of this design patterns are so useful you’ll end up using them very
frecuently, like the Factory, Singleton, probably a Facade, and Iterator (, just
to mention a few) are already present in a lot of languages in core
modules/components.
While the examples of the book are in C and Java, the patterns explained are
so important that we have ports of them to other languages like .NET. There are
even books that talk about them again (along with other newer patterns) in
languages like PHP.
As I mentioned, a must-read to avoid reinventing the wheel and losing precious time.
Title: The
Pragmatic Programmer: From Journeyman to Master
Author:
Andrew Hunt & David Thomas / Addison-Wesley
Language:
English
This book is similar to Coder
to Developer: Gives advice on a lot of topics to improve your skills as a
developer (to stop being a simple developer and get into the path for an analyst
or software architect). One difference though is that this book doesn't even
talks about .NET, using C++ or Java examples instead (if you work with C# that
shouldn't be any problem!).
Overall, the book has an inspiring, motivating speech. The authors have
fought a lot of battles when developing software and most of the tips are really
useful and will make you avoid common (and not so common) mistakes.
In each chapter, small tips and advices are given to the reader, even with
small tales and metaphors to make you understand easily some concepts or
problems.
In some advices they are a bit too extreme, like "learn one new programming
language each year" (a bit hardcore), or ttrying to have 100% of your code
uncoupled (performance, or customer requirements to give two examples may force
you to tightly couple some components). But this are the minor ones.
It gives a lot of intersting principles, like the DRY (don't repeat
yourself), WYSIAYG (what you see is all you get), "design to test"
or the very interesting "testing saboteur" (place someone in the project to
brach the source and place bugs to see if the test batteries catch them or not).
I like the "tracer code" concept. Instead of prototyping (throwing away code
and redoing it), making a framework and adding code in tiny bits, with constant
feedback to change what is wrongly implemented. Looks like saving future effort,
and we sometimes do it unconsciously. It just requires having a clear view of
the overall system.
The book has chapters about prototyping, estimations, "basic tools", code
coupling, code structure, the Law of Demeter,
multithreading, design patterns (including the now so famous
Model-View-Controller), testing, using use cases in requirements definitions (I
actually did this recently at work!), web-based documentation ...
Touches multiple ways of doing "defensive programming": Design by contract,
knowing when the impossible has happened, assertive programming,...
Another nice point is that along the whole book the message for the reader is
"you're not just a developer, think!"
Some topics lack a bit more of depth, but the starting point given is more
than enough for becoming a "pragmatic programmer".
Title: Coder
to Developer: Tools and Strategies for Delivering your
Software
Author: Mike Gunderloy /
Sybex
Language: English
I'll point out small bits of comments of this book.
For example, the author misses the usefullness of virtual machines,
encouraging readers to buy cheap pcs to test their software projects. Having
Virtual PC or VMWare for free, it is a much cheaper solution.
Another "warning" comes from the lists of tools, maybe too much in my
opinion. A developer can unfocus from the most important point: coding and
thinking correctly. At least, the author notices that they should be used with
caution.
Overall, gives very good advices and practices for developing, bot lonely and
in small groups. It gives good tips about managing projects too.
There are chapters about source code control, testing, visual studio
tooltips, code analysing and generation, bug tracking, logging... even
automation techniques and tools (continuous integration software included!).
Great for newcomers to this critical components. The documentation chapter is
very good too, mentioning even developer diaries and postmortems.
Some of the tools mentioned are outdated, and some tools like Resharper,
Virtual PC or Reflector are missing, so their chapters seem uncomplete, but
software development is a very fast-evolving world so it's logic.
I recommend it to anyone who just have developed with Visual Studio "standard
applications" and wants to learn more professional tools and techniques oriented
to the development lifecycle.
Title: .NET
XML Web Services - Step by Step
Author: Microsoft
Press
Language: English
I've recently readed this book while travelling to and from work, and my goal
was to learn more about Web Services, and precisely those that gave XML
responses, so this book was a good candidate.
The book contains what it says: all about web services in .NET. This is good,
because you can always have it as a reference book whenever developing web
services. It covers SOAP, HTTP POST and GET protocols, ASMX web services and
WSDL-created proxy classes, UDDI and DISCO files, state management, caching,
session and state management, and even asynchronous examples.
The only "bad" thing about the book that I've found is the "STEP BY STEP"
sub-header... At least in this book it means "complete examples in every
chapter".
The book is 373 pages long (apart from the appendixes), at least
one third of that being code examples. And of that 100+ pages of code, the
majority is trivial basic WS code that seeing one is ok, twice maybe, but the
third time you just skip to the bold part that marks the "important" code.
The authors could have avoided full samples from later chapters, instead only
showing the relevant code snippets.
But anyway, as I started saying it is a recommended book to learn (or get
deep into) .NET web services development.
Title: Blog Profits Blueprint
Author: Yaro Starak
Language: English
When I came to this free ebook I first thought "why reading it if I don't want to monetize my blog?". I'm a big fan of "don't do to others what you don't like done to you" (or however it is said in english). I hate ad-populated pages, I don't like advertising in RSS feeds... hell, I've been using Ad-block since it appeared!
But anyway, I love reading so why not learn something about how to earn money with a blog and maybe, just if I feel is not agressive to readers, apply one or two techniques here?
The book is a bit too optimistic. I've seen lots of blogs and I don't think all of them can make money. This is no "super-secret", you need to have good content to be able to generate visits and potentially money sources. But it is true too that by not doing anything clearly you won't get anything ;)
It provides a small non-technical approach to what a blog is and what benefits it brings, very well explained, before entering in how to monetize one. Inside the "business" part, gives away some suggestions, clarifies what your goal should be, etcetera.
Includes interesting topics as "passion vs profit", pilars for building a good blog, marketing a blog, available communication channels (mostly as traffic sources for your blog)...
There is a big section about generating incomes, as the tittle suggests, which is the most important part. I won't enter in details, but gives good examples and ways of making money.
Not a bad reading to get some interesting ideas, but does not discover any magical formulae apart from "spend time and effort on what you do".
Title: Videogame Marketing and PR
Author: Scott Steinberg
Publisher: Embassy Multimedia Consultants
Language: English
The book is clearly aimed at development studios. It is basically a
compilation of suggestions, success stories, usual mistakes and recommendations
related with marketing and public relations in the videogame industry.
It is interesting however for a more broad audience to read it and learn how
difficult is creating a videogame this days. The book contains money sums, stime
chedules, estimates of team people numbers, handicaps... I like too the
real-world examples that any avid gamer will notice.
Some sections are like a big speech, others are a group of points, and others
have a question-answer format. A chapter with advices from the industry
professionals is also here (and quite interesting). It has some auto-advertising
(the author is of course in the game PR sector), but nothing annoying or
excessive.
While I'm not becoming a PR agent (at least in the near future ;) it was more
like a casual reading that a serious one. I already knew some of the examples,
but others may be of use for a game dev. studio.
Title: Writing Secure Code for Windows Vista
Author: Michael Howard & David LeBlanc
Publisher: Microsoft Press
Language: English
Initially I didn't liked Windows Vista. A resource hog, some incompatibilities... But I had to use it at work so I installed it and worked with it for two months. After that, I really like the security features it has, but I felt like missing more details about specific topics... So I decided to buy this book.
Writing Secure Code for Windows Vista comes as a, mostly C++ oriented (although contains some C# examples), "how to use all new features" book. Very well structured, with lots of code examples, best practices, direct to the topic, and one thing I liked a lot: very sincere. If something is working bad, the authors state it clearly (for example, the Windows Firewall API, which has bugs), and they even provide workarounds to avoid them.
Down to the content, the book covers a lot of topics: New safer C functions, banned APIs, new APIs, UAC, token manipulation, integrity levels, code signing, virtualization, buffer overrun defenses, IPv6, Secure Socket extensions, Windows Firewall (Vista version, of course), IE7 security mechanisms & defenses (very interesting), Windows services development best practices, protected mode API and DEP, and the new CNG (Cryptography API:
Next Generation).
Even if you don't usually develop with C++ I highly recommend this book. With it you will learn a lot about all the new security features of Vista. You just need some basic knowledge of standard Windows security features and some C++/API programming.
Title: The Design of Everyday Things
Author: Donald A. Norman
Publisher: Basic Books
Language: English
The Design of Everyday Things is not a common book. It is a book about thinking how things are made, and more important, why they are made that way. It's a fantastic way of speaking about usability, about utility, and about design.
After you read it, you'll start to look all around you. You can apply it to software design: Remember those hellish tools nobody could master even reading once and again the help? Or remember that tool that was so easy to use you didn't even opened the help... And analyse them, extract that factors make it good (or bad).
But you can apply it to your life. Are you dumb because you can't program your dishwasher, or maybe is that having 10 buttons is a mess?
I am left-handed and a lot of times I've thought "I can't do this well because it's designed for right handed". Now, sometimes I look more closely and see that even for them it's hard to use.
Something not common to read to learn something about usability and design, but a good source to learn them.
Title: Organiza tus ideas utilizando mapas mentales
Author: Jean-Luc Deladrière, Frédéric Le Bihan, Pierre Mongin, Denis Rebaud
Publisher: Gestión 2000
Language: Spanish
Mind Maps are a technique I found interesting when I first read about it, mainly because I tend to make incredible "packed" abstracts and indexes about things. When at the university, I compacted some books in 15 pages to study (and it worked ;)
So, when I read about drawing just the ideas, expanding them like tree branches, focusing on not writing redundant info but the topics, the facts, the critical info... I thought "this is perfect for me".
The book is enjoyable, easy to read, with lots of examples, sample mind maps, and per-chapter abstracts (of course presented as a mind-map).
I recommend it without any doubt, very very interesting.
I think I've catch the idea of how to make mind maps perfectly. Let's see if I can put it into practice at work :D