Profile for Riccardo Di Meo > Reviews

Personal Profile

Content by Riccardo Di Meo
Top Reviewer Ranking: 524,426
Helpful Votes: 29

Learn more about Your Profile.

Reviews Written by
Riccardo Di Meo

Page: 1
JavaScript: The Good Parts
JavaScript: The Good Parts
by Douglas Crockford
Edition: Paperback
Price: 15.63

2 of 3 people found the following review helpful
5.0 out of 5 stars Enlightening, 12 Sep 2012
I confess: I started using JavaScript with almost no training (on the premise that "It's C-lish, after all..."), wrote a couple of short programs, and backed away from it in disgust.

Then I saw the Google Tech Talk gave by the author about this title, and as he was talking about the usual approach to JavaScript, and about how wrong it is, I found he was speaking about me: his points where compelling, the presentation witty, and so "why not buy the book and give JavaScript a second chance?!", I thought. As it turned out, the book is even better than the talk.

The author peels all the dangerous and mostly unnecessary features out of JavaScript (also showing how to work around the ones that cannot be avoided) and, with my great surprise, uncovers a sub-language which is both powerful, expressive and beautiful in its design.

Still, the greatest quality of this book is not its teaching JavaScript, but the way it gives voice and dignity to the process of subtraction and refinement we all use (although often shamefully reluctant to admit it), when it comes to coding (or cooking with a microwave owen, as the author points out): programming languages are imperfect creations, and being a good hacker is not a matter of using each and every feature, but instead it requires the wisdom to discern between the ones worth using and the ones to avoid.

The book is tough to grasp when it comes to getting all the subtleties (at least for people with little or no Javascript experience, as I am), but it will be worth your while and efforts. Warmly recommended.

Beginning OpenGL Game Programming, Second Edition
Beginning OpenGL Game Programming, Second Edition
by Luke Benstead
Edition: Paperback
Price: 24.47

0 of 1 people found the following review helpful
4.0 out of 5 stars A good book, although difficult to define, 2 Mar 2012
I started reading this book to fill the gaps left by another one about a similar topic (see my other reviews if you are curious) and, despite the fact that I did enjoy it (and found it useful), I'm still perplexed about what it aimed to achieve.

Despite the title (and as the shrewd reader would have already inferred by its size in pages), this book cannot possibly cover all aspects of graphic engine developing for game programming, neither can provide a complete introduction to OpenGL.

It is instead a gentle introduction to OpenGL with special care to techniques which might be particularly valuabe for game developing (like text rendering), covering topics that range from the setup of a context in Windows (the code for Linux is provided in the attached CD) to the basics of GLSL and Phong lighting, enriched with review questions and exercises.

Although the code in this book might look sparse and the explanations a way too brief for the sheer number and complexity of topics it deals with, it is worth noting that the author writes under the assumption that the keen reader will study and eviscerate the code in the enclosed CD (I didn't) and explains just the minimum, confident that you will do your homework and fill in the gaps.

Due to the year of publication, the OpenGL version used as a reference is the rather old 3.0, but the author makes a very good job in using the deprecated features to smooth the learning curve, while also carefully marking each one as such, so it's probably for the best. Also a welcome side effect is that you will pick some of the old OpenGL API on the way, which are both still used and nice to know.

All in one a good introductory text that, employing a very pragmatic approach, mixes the OpenGL API and some useful graphic techniques.

OpenGL SuperBible: Comprehensive Tutorial and Reference
OpenGL SuperBible: Comprehensive Tutorial and Reference
by Richard S. Wright
Edition: Paperback
Price: 38.99

17 of 18 people found the following review helpful
1.0 out of 5 stars OpenGL Super-disappointment, 15 Nov 2011
It's the first time that reading a book actually impends my progresses in understanding a topic. This volume, a collage of chapters from the previous version of the SuperBible plus new material (which has been never proof read), should had never been printed in the shape it is.

To prove my point, here is an incomplete description (at some point I got tired of writing....) of the goodies you'll have access to, should you decide to ignore all reasonable advices and decide that your wallet is too heavy of 50$:

- the authors must have been paid on a page basis, because about 1/3 of the opera is simply a printout of the OpenGL "Man Pages" (yes: the very same pages that you can obtain, for free, from the Khronos group on Internet) without any index or aid to help you in the navigation. Needless to say, you'll never use them (it's way easier to search them on-line), but you'll feel the weight of this "extra" every time you lift the book.

- since the new version of OpenGL is so tough to grasp, the author introduces his own library wrapper to smooth the learning curve (not a bad idea in itself). Pity however that you'll not get rid of the damn thing until the very last chapter. In other words: you bougth a book to learn the OpenGL, but why anyone in his right mind would waste his time learning it when he can spend it more fruitfully practicing with the (bug-ridden and abandoned) glt library by Richard Wright?

- The book is a collaborative work of many authors and, while this has its merits (for instance it allows to condense the experience of many people), it might present some drawbacks. In our case, I guess that during the development the authors might as well had a litigation or something, because they probably stopped communicating althogether: on a page I read that the feature X is going to be explained in the next chapter, and then when I actually (and eagerly) reach that chapter, I find out that X is taken for granted "as explained in the previous chapters" (are you curious about the mysterious "missing topic"? It's not an important one, really: just the explanation about how to actually "draw things"...).

- A particularly intriguing example is in chapter 11, the author cuts short on the explanation on the ground that "A complete implementation can be found on this book's Web site.", but the code is nowhere to be found: many of the examples that should have been on the web site (especially the ones from the more advanced chapters) just doesn't exist or are fairly incomplete (some crucial files cannot be found).

- chapter 12, the book reads: "there's plenty of advanced shader examples in the last chapter". Too bad that chapter 12 *is* the last useful chapter (the remaining ones are in the section "Platform Specific notes" and they don't deal with OpenGL at all)...

- the glossary explains terms that are actually never used in the whole book or supported by the OpenGL core profile, I guess because it has been copied & pasted from the previous version of the book. Look at the bright side: if you'll want to know what a NURB is, your curiosity will be satisfied (but don't expect to be able to create any).

- You'll get the chance to enjoy the splendid companion site (wait! you can actually check it for free:


) which compensates for it's HTML 1.0 vintage style with it's lack of contents. If not else, just read the (unintentionally) hilarious rant from the author in the MacOSX section...

- no matter how hard I tried, an errata corrige was nowhere to be found: I wasn't that surprised (should it ever existed, it's size would have probably surpassed that of the Superbible itself...): perhaps the author thought that the book was so good it didn't need it (or more likely, in my opinion, he never read it himself...)

- the code for the examples and accompanying library is registered on google code, but suggestions and corrections from the readers appear to have been systematically ignored. As already mentioned, many examples are missing or not complete.

Are you still wondering why the new version of this guide costs LESS than the previous one?

If you think you have a surplus of 50$ and you really have to do something about it, don't buy this book: go on the street and try to get mugged instead: you will get robbed anyway but, at least, it will only take minutes.

Hello, Android: Introducing Google's Mobile Development Platform (Pragmatic Programmers)
Hello, Android: Introducing Google's Mobile Development Platform (Pragmatic Programmers)
by Ed Burnette
Edition: Paperback
Price: 15.75

1 of 1 people found the following review helpful
4.0 out of 5 stars A pleasant surprise, 23 Aug 2011
As it promises, the books leads the reader into the world of Android application development, and it does it through a balanced set of examples, selected to show the most interesting (and funny) aspects of the platform, not forgetting more prosaic ones (like the use of SQLlite).

One thing should be clear however to anyone inclined to buy this book: it's not a smooth introduction to java development on Android, neither a guide on the platform: it looks more or less like a crash course, where the reader is quickly introduced to the many aspects of Android development, with only cursory explanations for most of the material presented, as well as useful and broad remarks about the technology at hand: it's purpose is more that of conveying the author's experience, rather than his technical knowledge, then the reader is expected to study the examples and get the details, in order to get the skills that will be required to build his/her own applications.

Although putting the reader in a "swim or sink" situation, this approach is a direct result of the amount of topics covered: the book doesn't have the presumption to completely exhaust the whole material (and it couldn't, without at least doubling the number of pages), instead it's meant to be a kind of "appetizer", and a starting point for future studies.

Personally, my only complaints about this title are about the typographical vest of some of the inlined code (the XML looks ugly, due to a messy syntax highlighting), and the uneven distribution of the material through the chapters (after reading the first one, I though the book was gonna be the kind of guide that spends 10 chapters just to tell you how to compile a source file, only to find out in the next one that the pace was going to be way way faster...).

All in one, a good introduction: pleasantly written, and entertaining to read.

Recommended to programmers with some background experience with java and mobile development.

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

1 of 1 people found the following review helpful
5.0 out of 5 stars Great book, if you are prepared for a LOT of work, 9 Feb 2011
This cleverly written and innovative guide will walk you through the main features of the C++ programming language, skipping the long and boring introductions that invariably constitute the first part of any similar work and, right from the first chapter, letting you learn enough to write some simple useful programs.

Still the name of the book is "Accelerated C++", not "C++ in a week" or "C++ for slackers", so if you have the unrealistic expectation of learning C++ by just browsing whatever book, you might well quit the idea of learning it altogether.

The authors take a very practical approach to the language, using a couple of very well devised programs (expanded and enhanced trough each chapter) to introduce the syntax and concepts behind the language, without ever falling into the temptation of delving too much or too long in plain theoretical issues.

At the end of each chapter, a list of exercises (that the serious reader should consider to solve at least in part) are presented, to consolidate the concepts explained and give the reader the opportunity to practice, along with a small section that summarizes and expand the contents.

A mention of honor should go to the references scattered thought the book: whenever a concept that's been already explained is revisited, a handy pointer to the relevant page where it was first described, or to the appendix is shown: a very appreciated addition that makes following the tutorial more agile (the complete index is still present).

Despite the favorable impression that this book gave me (and its usefulness), still this work isn't immune from defects: some of the exercises are not explained in the best possible way, and from time to time you'll wonder what exactly the authors want you to do.

In other cases, especially in the first chapters, some of the problems you should be supposed to solve just can't be done with the concepts already in your hands.

Being very packed with information, I wouldn't recommend this book to people who are just starting with programming, especially if they would like to do so for professional reasons as, even if they would make it to the end, it wouldn't provide the solid theoretic knowledge they would require to be more than hobbists. Still very motivated newbies might consider this book as a less pedantic introduction to programming in general.

Programming Massively Parallel Processors (Applications of GPU Computing Series)
Programming Massively Parallel Processors (Applications of GPU Computing Series)
by David Kirk
Edition: Paperback
Price: 42.99

3 of 3 people found the following review helpful
3.0 out of 5 stars A good yet disappointing book, 10 Nov 2010
* The Good

The authors, who are clearly involved directly in GPU computing and not simply tech writers, explain CUDA programming with a keen introspection into the actual hardware mechanisms, and go into the details of the various (mostly memory) performance bottlenecks, and ways to work around them.

Code efficiency, scheduling choices and optimizations are all presented from an enlightening hardware-wise perspective, which the reader can readily adapt to her/his own scenarios: on this topic the book succeeds in making easier a subject that would be way harder to learn from the reference manuals provided by NVIDIA.

Two application case studies in the middle of the book, directly taken from the on-field experience of the authors, give a taste of what coding and porting to CUDA actually looks like in real-life applications, with increasing levels of optimizations along with detailed benchmarking.

* The Bad

The first negative aspect, which strikes when opening the book, is the typographical sloppiness: the example code looks too tiny and dim, and the images look like cut and paste from the slides the authors admittedly started this book from: nothing unreadable, but for 31 pound I expected more care.

The content accuracy doesn't fare way better either: along with some errors (not many, you may refeer to the book homepage for the list) there are some "pearls", like the number of points assigned to the author's students for solving the questions at the end of one of the chapters, which let you wonder if the book was actually proof-read before being sent to print.

Honorable mention also to the very interesting questions the authors added in the "Exercises" section at the end of each chapter, which could have much contributed to the reader understanding, but whose answers are nowhere to be found...

In two words: amateur hour.

It isn't however in the presentation that this title actually disappoints the most: regardless the (over-hyped) claims on the covers of "completeness and awesomeness", the content is unacceptably outdated for a text that has been published in 2010: no clue of native multiple-GPU support and stream processing (which is worsened by a section with a custom solution to exploit the configuration, now outdated and misleading), nothing on texture memory and the Fermi architecture is seen as a "future outlook".

The book is also over-ambitious: despite the efforts to be both an introduction and a guide to parallel programming and thinking, and despite two slim chapters on floating point numbers and OpenCL (which are good but leave more to be wanted), this title can't be considered more than a guide that helps better understand the CUDA architecture, and a valuable introduction to optimization (which isn't a bad thing by itself).

* Conclusions

A book for people who are already familiar to CUDA computing and want to get serious about performances and optimization: altough it will probably fail from becoming a classic, it is yet a good introduction to the hardware and an interesting compendium of optimization techniques. Other people might want to wait for a 2th edition.

CUDA by Example: An Introduction to General-Purpose GPU Programming
CUDA by Example: An Introduction to General-Purpose GPU Programming
by Jason Sanders
Edition: Paperback
Price: 22.09

5 of 5 people found the following review helpful
5.0 out of 5 stars An excellent introduction to general purpose GPU computing, 10 Nov 2010
This was my first book on GPU computing and a really pleasant surprise: well written, up to date and extremely easy to read.

The author introduces the basic tools of the trade, adding more constructs and techniques as the book progresses, including not-so-basic topics as "texture memory", "CUDA-OpenGL integration", "Streams" and "atomic operations" (and going as far as to deal with mutexes in the appendix).

The style is witty, clear and informative and the examples appealing: on each chapter at least a simple program is presented bottom up, they show some interesting graphics and give an immediate idea of what GPU computing can actually deliver, without relying on the "usual" plain number crunching examples.

Being an introductory text however, this book doesn't provide all the content required for serious GPU developing and should be complemented with other resources (by the way, suggested in the last chapter): for instance, it doesn't cover the GPU hardware capabilities and limitations, and the ways to work around them (you can find more about this in "Programming massively parallel processors" which I have also reviewed).

All in one, a great introductory book which is both informative and a pleasure to read.

Page: 1