Like the title says, this is a reference book for the latest version of ANTLR . However, it also does a decent job of introducing ANTLR to someone new.

While you can certainly find some of the information about ANTLR on its website or mailing list, this book contains a lot more examples especially on the thorny aspects of language parsers. In fact, the strong point of this book is abundant set of examples that it presents.

However, don’t expect everything to be crystal clear to you the first time you finish reading the book (unless you have used some other parser generator before). In fact, it might be hard to read this book cover-to-cover the first time. The best approach is to quickly skim the sections so that you have a rough idea of what is possible with ANTLR and where to find that information. Then you can refer to the relevant sections when you are facing some problems.

This book is best used in conjunction with some project on the side (the book itself already contain some full-fledged project but you can find more on the ANTLR website). As you tweak your language, you can refer to it for details on how to fix problems that you are having with the language that you are developing. Its usefulness begins to shine when you need to use some of the more advanced features of ANTLR which are not documented anyway else. I am constantly surprised by the wealth of information in this book; most of the time when I run into a problem, the book contains a section that describes that problem and potential solutions.

If you are using ANTLR for a large project, this book definitely becomes indispensable. Use it as your primary source of reference and refer to the ANTLR wiki/ documentation /mailing list if you have more esoteric questions.

(I actually picked up this book from a box that my friend wanted to donate. I saw the title and thought that it was interesting so I decided to read it.)

It’s nice to actually read about other people’s perspective on popular anime series such as Akira, Ranma 1/2, Neon Genesis Evangelion, Princess Mononoke, Ghost in the Shell, etc. Because I have watched almost all the different anime series, I found the book to be an easy read. For the ones that I have not watched, the summary given in each chapter was sufficient in delivering the main idea of the anime.

While it did offer a different view of anime, I felt that certain parts of the book over-analyzed the anime series. It would have been more interesting if the author had solicited the opinions of the original writers and designers of the anime series in addition to other prominent reviewers and critiques. Some parts of the book seemed pretty far-fetched to me and it would be beneficial to compare and contrast what the author thinks with the original intent of the authors and designers of the anime.

I’ll probably watch some of the anime titles again and try to experience the anime from the author’s point of view.

There is a good introduction to Domain-Driven Design at http://www.infoq.com/articles/eric-evans-ddd-matters-today.

This book is thin so I might have just read through it too quickly. Some of the anecdotes were pretty antiquated so they did not really appeal to me. I borrowed it from the library because it was mentioned in The Ruby Way (First Edition):

Thus spake the master programmer: “Though a program be but three lines long, someday it will have to be maintained.”

Geoffrey James, The Tao of Programming

If you plan to read it, good for you. But if you are not, there is probably nothing much that you are missing.

The authoritative source for using Subversion is still the http://svnbook.red-bean.com/ but this book is a nice introduction for anyone who is using a version control system for the first time.

The examples are clear and simple. But more importantly, the examples are not just snippets; they are properly documented step-by-step so that anyone new to version control can actually try it out.

Moreover, if you really need a quick start, all you need to do is read the first 2 chapters. Reading the first 2 chapters will not make you a pro but at least you are now equipped with the knowledge to use Subversion in your own projects.

If you are going to do some serious Eclipse programming (not just using the IDE for developing your own java programs) then do not get this book unless they update it. Eclipse 3.x has some rather significant changes and this book only contains code and explanation for Eclipse 2.x. As such, the examples might not work, or worse still, might contain deprecated ways of doing things.

In fact, if you are going to do any Eclipse programming, it might be better to go online and look for some tutorials on the Eclipse website, gain some ideas and hack together something simple. Eclipse is a complicated system and you will probably need a better reference manual for it than this. Consider getting the Eclipse 3.0 FAQ’s instead once you are more comfortable with the paradigm of the Eclipse environment.

Even though the rest of the world does not take Smalltalk seriously, it does not mean that you shouldn’t. In fact, Smalltalk remains one of the cleanest object oriented languages I have seen. True, getting used to its environment can take some time, but once you have, you will wonder how come you are not programming like this.

Anyway, this book has some good patterns that are useful not only for Smalltalk but for any of the other language that derives indirectly from it. For instance, Java and Ruby share some of the concepts of the Collection class from Smalltalk. Moreover, some simple patterns such as naming methods and classes might seem trivial but if you follow the advice, it will definitely impact the readability of your code. Some of the other patterns are really specific to Smalltalk though and probably will not be useful for other programming languages.

The only drawback of this book is its price. It’s almost $40 for a fairly thin book.

If you want to learn programming in an environment where the source code is available and almost everything is written in the language you are trying to learn, look no further than Smalltalk. Because of its dynamic environment, you can basicallty inspect every line of code in the system, make changes, and see the results.

You cannot get the people who really need to read it to actually read it. The people who should read this book will not even bother stealing this book to read it. So, in a way this book has failed.

Anyway, this book does offer some advice on computer security and it has lots links to online resources. However, it also promotes a lot of books published by the same publisher.

Original articles can be found here: http://www.visibleworkings.com/little-ruby/

This book has an interesting way of teaching programming. I am not sure if someone who has no clue about programming would appreciate it but then again, Friedman has an interesting approach.

This book was suprisingly easy to finish compared to the previous books. Maybe because it did not introduce too many new characters. Somehow, ( I might have missed it) there was not really much of a twist in this one. Maybe, one just has to infer more the reading.
Anyway, this book prepares the way for book 7 by introducing more on Voldermort and how he comes to be.