Book Reviews

Completed book reviews

• 

  Presentation zen: simple ideas on presentation design and delivery

  Garr Reynolds

  ISBN: 0321525655 - New Riders Pub., 2008 Reviewer: Sebastiano Cobianco Started: 06-04-2010 Finished on: 04-06-2010 More

  Keywords

  Business presentations, visual communications, marketing

  
  

  Review:

  When I first saw a zero words presentation, a couple of years ago, it took me a while before i could recover from the positive shock it made on me. How comes that someone can stand up for 30 minutes and talk business with no bullet point slides? And be entertaining and connected with the audience instead of boring and pointless?
  
  Then it was time for Steve Jobs keynote speech on iPhone...yesss, that was a show! :)
  
  These emotions came back suddenly when a colleague suggested me to have a look at
  Presentation Zen by Garr Raynolds. I read the introduction by Guy Kawasaki - now one of my favourite authors - and I clicked.
  
  The book offers a new perspective into delivering a presentation, no more bullet-points or verbose slides but rather visual contents, so that you can reach out to your audience in a much more effective way. Of course the idea is detrimental to the cut+paste pattern, and calls for more preparation work and presentation skills. Fortunately, the book covers that too, and helps you to reconsider important aspects such as connecting to the audience, adapt to circumstances, stay focused, consciously use your voice, etc.
  
  You are warned: it might be difficult to make others believe you have done your homework
  even though you have no bullet-point slides to show :) so perhaps a good suggestion (not in
  the book) is to wisely choose how to start practising your visual presentation skills. In any case, a book well worth reading and a very useful reference for your next speeches.

  
  
• 

  Intellectual property and open source

  Van Lindberg

  ISBN: 0596517963 - O'Reilly Media, Inc., 2008 Reviewer: Sebastiano Cobianco Started: 01-03-2010 Finished on: 30-04-2010 More

  Keywords

  intellectual property, open source, licences, GPL, copyright

  
  

  Review:

  Reading a book on legal topics might seem a daunting perspective for someone with a technical background, and I shared this viewpoint before start reading Intellectual Property and Open Source.
  
  For instance, one thing I noticed as common practice in legal contracts is referring to later content. E.g. it is typical that wording in clause 8 makes reference to what is stated in clause 9, or 11. This clashes with a developer - i.e. analytical - mindset, where you can only build on what has already been defined and/or computed, not on something which is following next :)
  
  With this in mind, I approached the book openly and I was pleased to find that the author could seamlessly take me throught aspects of patent law, copyright, trademarks, etc. with a very accessible language, clear examples, and honest considerations.
  
  Most of the chapters, particularly in the second half of the book, take the developer's perspective on open source licensing. The author jumps in the oss developer's shoes to figure out what licensing is all about, what you need to consider when chosing a licence for your own code, and IP aspects you should consider when working either as an employee or a freelance.
  
  Examples are often taken from prominent case studies, and it is easy to remember them and the argument they referred to. While deep and clear, the author succeeds not to indulge too much in legalese, which is good when you are not a lawyer :P
  
  Most popular open source licences are included in appendix for reference, so that they don't get in the way when you are focusing on specific aspects of IP. For this reason, I believe that the book can serve both as an introduction to IP in oss and a reference book.
  
  A must have book for developers keen on their own IP rights and willing to contribute to open source communities.

  
  
• 

  Hadoop: The Definitive Guide

  Tom White

  ISBN: 0596521979, 9780596521974 - O'Reilly Reviewer: Paolo Canesi Started: 25-01-2010 Finished on: 06-04-2010 More

  Keywords

  
  

  Review:

  Managing and analyzing huge data sets has become a very common problem in various areas of modern information technology, from different types of Web applications (social, financial, trading, ...) to applications for analyzing scientific data.
  
  Distributed systems over a cluster of machines are almost a mandatory choice in such cases, but designing and implementing an effective solution in those areas may be troublesome and become a nightmare.
  
  The Apache Hadoop Project is an infrastructure that helps the construction of reliable, scalable, distributed systems. Mainly known for its MapReduce and distributed file system (HDFS) subprojects, it actually includes other services that complement or extend them.
  
  Tom Whites' "Hadoop: The Definitive Guide" is an enjoyable book which fully explains these complex technologies. The book is organized in such a way that the reader is gently guided into the Hadoop ecosystem. It begins with a couple of very readable chapters as a general introduction to the problems Hadoop is meant to solve and the main solutions to them (MapReduce and HDFS), then examines closely all its aspects, often describing what really happens under the scenes, giving useful design suggestions and common pitfalls descriptions. When reading this book you won't be overwhelmed by tons of lines of code: examples are short and yet effective.
  
  This kind of structure makes it hard to classify the book as a mere tutorial or as a real reference guide, it can be rather considered a mix of the two. If this turns out to be a positive choice in many ways, it has some drawbacks: the reader is sometimes forced to go back and forth through the chapters and has to read it almost entirely to get a full understanding. But this is perhaps the price to pay for having a fluent and pleasant reading.
  
  Let's go quickly through the chapters:
  
  The first chapter is a brief history of Hadoop project illustrating its main characteristics and comparing them to those of others similar technologies. Chapter two is a pleasant introduction to MapReduce. The third chapter breaks the continuity of the previous one examining the Hadoop Distributed File System (HDFS subproject) in detail. Chapter four makes a step down in the abstraction layer talking about the Hadoop I/O fundamentals: data integrity, compression, serialization and data structures, explaining the design choice.
  
  Chapters five to eight are an excellent source for learning Hadoop MapReduce in depth. They cover all the aspects of it: starting from practical ones, such as how to configure, run, test and debug map reduce programs, to those more advanced and formal, like programming models, data formats, sorting and joining tools.
  
  The two following chapters list few very interesting and useful suggestions for managing and setting up a Hadoop cluster, a precious resource for administrators.
  
  Chapters eleven to thirteen are for Pig, HBase and Zookeper subprojects under the Hadoop umbrella. Despite of suffering from brevity, they are still interesting.
  
  Chapter fourteen is made for the reader not to feel alone: important case studies using Hadoop (e.g. Yahoo, and others contributions from Apache Hadoop community).
  
  My final opinion is that "Hadoop: The Definitive Guide" is a very useful resource for those who want to learn how to ride the "pachydermic" Hadoop (like a "Mahout", perhaps?).
  
  

  
  
• 

  Programming Scala

  Dean Wampler, Alex Payne

  ISBN: 0596155956, 9780596155957 - O'Reilly Reviewer: Roberto Bentivoglio Started: 07-12-2009 Finished on: 07-02-2010 More

  Keywords

  scala, functional programming

  
  

  Review:

  One of the book's authors worked at Twitter, and knowing that Scala is the platform used to develop Twitter immediately makes this book very promising.
  
  The Scala programming language requires a relatively long time to be understood, even for programmers coming from other mainstream languages such as Java.
  
  Scala is introduced in the first chapter as a language to address the major needs of modern development. To explain the power of Scala the authors compare it with other popular programming languages such as Java, C#, Ruby, Python, PHP. How to install the Scala environment and complete HelloWorld is also presented.
  
  Subsequent chapters delve into concepts of the Scala programming language like syntax, traits, oo and functional programming, concurrency with actors, DSLs, Type system.
  
  A very interesting chapter is devoted to application design in Scala.
  
  The last chapter covers the tools, the libraries and the IDE support for Scala.
  
  The book contains many (working) examples that are very useful when you aim to learn the Scala structure. Authors use a plain and simple language and helps to easily understand the complexities of the subject matter.
  
  One of the major hallmarks of the book is that the authors try to use the Scala syntax that they consider the best from the first examples. This helps to learn from the begin what the authors consider best practice when programming in Scala. On the other hand, for newbies it can turn out to be difficult to understand why it's better to use some structure or syntax instead of others.
  
  Overall "Programming Scala" is neat and most remarkably one of the best ways to enter the wonderful world of Scala.

  
  
• 

  Real-Time Java Programming: With Java RTS

  Eric J. Bruno, Greg Bollella, Ph.D.

  ISBN: 978-0137142989 - Prentice Hall PTR Reviewer: Gianfranco Tognana Started: 24-09-2009 Finished on: 24-11-2009 More

  Keywords

  Real Time, java

  
  

  Review:

  This book starts very intriguing: An elavator is a real time system. A web server is not.
  Real Time in not 'run as fast as you can' like the Gingerbread says. It is all about reliable timing.
  
  This book explain in thorough (very thorough) detail what's wrong with standard java and what happens when RTSJ comes to the rescue.
  You will learn how the garbage collector, a bad guy of standard java, is tamed, the JIT compiler, another nasty mug, is rendered harmless and how you can instruct threads to perform exactly what you want and not let them dawdle.
  
  You will find:
  long deep theoretical explanations of how the garbage collertors are (or could be) implemented and
  long deep theoretical and practical explanations of how you can avoid the JIT compiler and
  long deep theoretical and practical explanations of how you can avoid the dynamic classloading and
  long deep explanations of how to set up a real time environment: the JVM itself need a real time operating system (windows is obviously excluded)
  
  Until you will see what means to write a program with RTSJ: in same ways is like coming back to C and sit right on the memory...
  
  The examples in the book quite gently introduce you to the core concepts and the final application wraps up all the tecniques useful in RTSJ described in the book.
  
  It's an interesting book if you want to learn the internals of java or if you need to evaluate real time java for your next project.
  

  
  
• 

  JavaFX. Developing Rich Internet Applications

  Jim Clarke, Jim Connors, Eric Bruno

  ISBN: 013701287X - Addison Wesley Reviewer: Pasquale Granato Started: 24-09-2009 Finished on: 20-11-2009 More

  Keywords

  JavaFX, java, RIA

  
  

  Review:

  Approaching a book about a brand new technology can be dangerously misleading because you can end up to write about the latter instead to focus on the former. On the other side it’s really hard to separate the two things but I swear that I’ll do my best.
  
  Let’s start talking about the book intended audience. The authors target the book to Java developers and to graphic designers as well. Probably people without a specific programming background will have some serious difficulties to follow many of the topics covered in the book. Speaking as a Java programmer I’d have appreciated more explanations where needed on the differences between Java and JavaFX script.
  
  (Personal annotation. I looked astonished for five minutes at this
  
  var num = if(sizeof args > 0) {
  java.lang.Integer.valueOf(args[0]);
  } else {
  10;
  }
  
  before be acquainted with it. The JavaFX Script programming language is indeed an expression language, which means that everything, including loops, conditionals and even blocks, are expressions and can return a value.)
  
  The first two chapters of the book are devoted to set up the environments for both the programmers and the graphic designers. In a few pages it really makes clear how to get started using NetBeans or Eclipse (for programmers) and Photoshop or Illustrator (for graphic designers). Just to reassure you: yes, "Hello, world!" is the very first example of the book.
  
  In chapters three and four authors introduce the core of the JavaFX scripting language. Topics like sequences, expressions, binding and triggers are clearly covered with many short examples.
  
  After this boring but necessary stuff the fireworks begin. From the chapter five to eight the power of JavaFX is unleashed: the creation of cool and appealing user interfaces.
  The theater metaphor within the JavaFX user interface framework is really well covered. The reader will learn about the Stage, the Scene and the Nodes and how they combine as basic elements to make complex user interfaces. Special effects and animations are topics exceptionally well enlightened with clear descriptions, many examples, pictures and graphs.
  In comparison, the multimedia topic is covered extremely concisely. This is due to the fact that putting images and video in a JavaFX project is really simple.
  
  The publication of JavaFX project is an important topic covered in good detail in the chapter nine. The use of applet and Java Web Start as a way of publication is explained with many hints and with a cool paragraph about the integration between JavaFX and JavaScript. Unfortunately no attention is paid to other publication methods like mobile or television profile.
  
  An advanced topic, namely the creation of RESTful applications, is covered in chapter ten which presents an example widget that shows current weather conditions using data received form external web services.
  
  Java programmers will then be grateful for the chapter eleven, which covers in deep detail the integration between JavaFX and Java, with many tables about function parameter and return mapping and about type conversion mapping.
  
  A special mention should be deserved for the contents of the chapter twelve, JavaFX Code Recipes. In this chapter the authors present many code samples that will help the reader in several real world situation. For a new technology like JavaFX the value of being taught by the creators comes out in this advices that surely help to understand the language and to avoid the traps.
  
  In the last chapter of the book a complete Sudoku application is presented. This is an invaluable reference because all the range of topics are dissected, starting from the concept and the design, to the logic, to the interface. Many excerpts of code are analyzed with several useful considerations.
  
  The book has been written before the specification JavaFX 1.2 was finalized. So in many parts of the book the authors complain the absence of definitive example and send the reader to the web site in which they’ll publish as soon as finished new chapters on 1.2 and revised examples. As this review has been written, those chapters have not yet been published on the web site. The examples instead have been updated for 1.2 specifications and can be downloaded for free.
  
  In conclusion, this is a really good book to learn JavaFX. All topics are presented clearly and the overall readability of the book is excellent. It should be used for linear reading only; it hardly will work as a reference. JavaFX experts will do better looking somewhere else. New comers of the technology (with a good background of Java) will probably not find any better.

  
  
• 

  Java Fundamentals I and II

  Paul Deitel

  ISBN: 978-0137131136 - Dietel & Associates, Inc Reviewer: Biagio Beatrice Started: 24-09-2009 Finished on: 20-11-2009 More

  Keywords

  java, course, dvd, multimedia

  
  

  Review:

  Java Fundamentals I and II by Dietel & Associates, Inc
  
  Java Fundamentals I and II is a multimedia Java programming language course. It's composed by 14 hours of video tutorials in 2 Dvd plus one book with code used in the video tutorials.
  In the first Dvd, 7 hours of video are dedicated to the basic Java concepts: statements, classes and objects.
  In the second dvd are approached the object oriented concept like inheritance and polymorphism.
  In both Dvd there are tutorials about Netbeans and Eclipse very useful to the beginners.
  
  The course don't need to be installed, there's a software that play video tutorials, you put inside and go. It run on Windows 2000, XP , Vista and on Mac but not on Linux (!!) you should use wine to run it on Linux but i didn't tested it. It would be fine if it could run on Linux too.
  The Dvd needs at least 1280x960 video resolution so should not work fine on all personal computers. The course doesn't run on a dvd player, that improvement would be nice too , because you can work on the code you're learning while watching it on Tv.
  
  The interface is simple and very easy to use.
  Video tutorials are in English, Steve Dietel talk in all of them. It is not available another language or subtitles, but the English is clear for a non English speaker too. A good improvement could be to add subtitles, so it would be easier for non English speaker to follow the course.
  Another good improvement would be add a bookmark, so if you have to stop for any reason the tutorial you can easily start from that point.
  
  The strong point of the course is the “live code” approach , that means Java concepts in a working context. I found very easy to learn while working . For a lot of people this is the best approach and it's not boring indeed. To go further there's a lot of stuff on the editor website www.deitel.com.
  It's not required Object Oriented programming skill to follow the course, it's easy for people that have few experience in programming. Everything you need is in the course.
  A very nice feature is that after the course you learn how to help yourself with Java API, essential skill for a Java programmer.
  
  
  I found Java Fundamentals very nice and complete, is highly suggested for people that never have played with Java but have generic programming skill, after the course the student will be able to write simple programs and to go further with practice. It could be a good inspiration for teacher too I suggest for the beginners to start the course following the tutorials on Netbeans or Eclipse, so you can easily repeat and improve the code of the course. Another good improvement would be to put some exercise about topic covered.
  
  Topics covered: Introduction to Java applications, introduction to Classes and Objects, Control Statements, Methods, Arrays, Classes and Objects, Inheritance, Polymorphism, Introduction to Graphical User Interfaces and Event Handling, Exception Handling, The Collection Framework, Introduction to NetBeans, Introduction to Eclipse.
  
  Product Details
  • Misc. Supplies: 128 pages
  • Publisher: Prentice Hall PTR; 1 Pap/DVD edition (March 20, 2008)
  • Language: English
  • ISBN-10: 0137131135
  • ISBN-13: 978-0137131136
  • Product Dimensions: 9 x 7.5 x 1.2 inches
  
  
  
  

  
  
• 

  Clean Code: A Handbook of Agile Software Craftsmanship

  Robert C. Martin

  ISBN: 978-0132350884 - Prentice Hall, 2008 Reviewer: Mario Fusco Started: 24-09-2009 Finished on: 20-11-2009 More

  Keywords

  agile software development, vertical formatting, implementation patterns, String Arguments, Successive Refinement Listing, Kent Beck

  
  

  Review:

  Programmers spend probably more than 80% of their time reading someone else code instead of writing their own. This is why is important that who writes the code pays particular attention not only to what it does but also to how it does that. For example, for a compiler doesn't make any difference if a variable is called p or pageCounter, but of course it makes a big difference for the programmer who have to figure out what kind of information that variable contains. That explains why it is easier to write code for compilers than for people.
  
  Of course a well chosen name is definitively not enough to make your code readable. This book provides some really good principles that all developers can benefit from using in order to make your code more readable and consequently cheaper to be maintained and easier to be refactored. Among the suggestions made by the book to achieve these results you can find:
  
  * keep each method as short as possible: 15 lines of code is a reasonable limit that should not be overcome;
  * give each method a single responsibility: if you are trying to give a meaningful name to the method and it comes out that the name should contain an "and" there is a big likelihood that you are breaking this rule;
  * never declare a method with more than 3 parameters: if you need more it is always a good idea to group them as properties of an object;
  * don't use nested cycles or conditions: you can improve both readability and reusability by putting them in little separated methods;
  * write comments only when strictly necessary and keep them updated with the code: there is nothing more useless than a comment that explains what you can easily read from the code or more confounding than a comment that says something different from what the code actually does;
  * fix a set of shared coding standards: a programmer can understand a piece of code faster if he doesn’t meet unexpected surprises while reading it.
  
  Reading this book you will learn how to implement in your code these and other advices through lots of wonderfully clear and easily reusable examples. The book put an important accent also on how to make your code more robust by building a set of meaningful unit tests and how to leverage that test suite in order to safely improve your code through successive refinements.
  
  In the end this book will teach you how to make your code easily readable by another programmer, making his job more simple. And this is a valuable thing especially considering that there is a high possibility that the next programmer who will read that code could be yourself.

  
  

• 

  The Art of SEO

  Eric Enge, Stephan Spencer, Jessie C. Stricchiola, Rand Fishkin

  ISBN: 0596518862 - O'Reilly Media, Inc., 2009 Reviewer: Mario Fusco Started: 20-04-2010
  
  
• 

  Search Patterns: Design for Discovery

  Peter Morville, Jeffery Callender

  ISBN: 0596802277 - O'Reilly Media, Inc., 2010 Reviewer: Luca Manno Started: 20-04-2010
  
  
• 

  The Social Media Marketing Book

  Dan Zarrella

  ISBN: 0596806604 - O'Reilly Media, Inc., 2009 Reviewer: Sebastiano Cobianco Started: 10-05-2010
  
  
• 

  Mobile Design and Development

  Brian Fling

  ISBN: 0596155441 - O'Reilly Media, Inc., 2009 Reviewer: Pasquale Granato Started: 27-05-2010
  
  
• 

  iPhone SDK Development

  Bill Dudney, Christopher Adamson

  ISBN: 1934356255 - Pragmatic Bookshelf Reviewer: Emilia Ciardi Started: 27-05-2010
  
  
• 

  High Performance JavaScript

  Nicholas Zakas

  ISBN: 059680279X - O'Reilly Media, Inc., 2010 Reviewer: Nicola Rizzo Started: 27-05-2010
  
  

• 

  JavaFX

  Gail Anderson, Paul Anderson

  ISBN: 0137042795, 9780137042791 - Prentice Hall, 2009
  
  

• Completed
• In Progress
• Available