Fitness for Geeks by Bruce Perry is an excellent introduction to nutrition and fitness, aimed at self-described geeks. He does an excellent job of two important things. He gives an introduction to some of the principles of exercise and nutrition, relating them to things that geeks like and are familiar with. And, he gives excellent references to scientific publications that back-up the principles he lays forth. Furthermore, the author’s writing style is very conversational. He makes what can be dry material entertaining to read. I also like how he gives many pointers to gadgets that geeks may find fun to experiment with and that encourage mesauring exercise and nutrition as part of their operation. One thing that I liked, but a novice to fitness and nutrition may not like is he never gives strict recipes for how to improve your level of fitness, he only gives general guidelines, some of which are self-conflicting. I think this is important because there is no right answer, each person must find what works best for them through careful experimentation. A novice, however, may prefer more definitive answers.
Fitness for Geeks is an excellent book for any ‘geek’ who is interested in learning more about fitness and nutrition and would like to start getting in better shape.
Functional Programming for Java Developers has the noble goal of introducing ideas from functional programming to developers who are familiar with Java. In my opinion, functional programming will be the dominant programming paradigm within 10 years and this book presents an brief introduction to the world of functional programming, however, there is some ugliness in trying to program functionally in a language like java, that doesn’t treat functions as first class citizens. Honestly, the right book to fulfill introducing functional programming to Java developers will either introduce a functional language that runs on the JVM, like Scala, or use a language like Python, which has many features of a functional language. I think many of the ideas of functional programming, immutability, first-class functions, and the important higher-order functions, map, fold, and friends, are best learned by example and this book doesn’t give good, clean examples of these ideas because Java lacks good, built-in support for these concepts.
The idea behind Functional Programming for Java Developers is a fundamentally good idea, but this book falls short on the need that it was designed to meet. This book is a decent read for someone who is already somewhat familiar with functional programming concepts, but I would not recommend it to someone who is unfamiliar with functional programming. Such a reader may get lost in the ugliness of trying to bolt functional programming onto Java.
Programming Pig, the early release version, is a decent introduction to using Pig to process large scale data sets. As an early release version, it has some rough edges that will undoubtably be smoothed over before the final release, but some of the explanations of Pig’s more complex areas don’t have a satisfactory, simple explanation.
Simplifying the processing of large, terabyte or more, scale datasets is the goal of the Pig project and Programming Pig aims at introducing the reader to Pig. The book does a good job of introducing the basic concepts behind Pig and how to introduce Pig into a data analysis flow. The chapters on installing and running Pig in different environments, those that introduce Pig’s data model and Pig Latin do a good job of getting the reader up and running with these parts of the system. Overall though, the book, however, can be overly verbose at times and does not do a good job of simplifying the more complex parts of the Pig System. In particular, the chapter on advanced Pig Latin does not do a good job of introducing many of the advanced concepts from Pig Latin in a simple to understand way.
I will definitely re-read this book when it is released and would recommend it to anyone that is looking to learn Pig or is considering adding Pig to their data analysis workflow. While it was not the most enjoyable technical book I’ve ever read and it does not do a great job of simplifying the concepts behind Pig, it does achieve its goal of introducing Pig and the concepts behind it.
Learn you a Haskell for Great Good is an excellent guide to the Haskell programming language for experienced programmers who have had little exposure the functional programming languages. Most of the important ideas in functional programming are introduced in an easy to understandway and the book is written in a witty style that makes reading it enjoyable.
Functional programming can be difficult for programmers used to imperative-style languages, like Java and C/C++. This book does an excellent job of introducing these concepts in a way that makes them much easier to understand. For example, monads are traditionally something that is thought of as being very difficult to grasp. After reading this book, however, I now feel I have a solid grasp on the idea of monads. The Haskell type system, another topic that is viewed as being difficult to learn for people with experience with imperative programming languages. Learn You a Haskell introduces the ideas behind the type system in a way that makes it very easy to understand. Finally, the witty style and fun illustrations make the book a very enjoyable read.
I read through the on-line version of Learn you a Haskell (http://learnyouahaskell.com/) before this was released. The print version has been cleaned up and extended and I fully recommend it to anyone who is curious about functional programming and Haskell.
Data Analysis with Open Source Tools is an excellent primer for those who need an overview of the field of Data Analysis, along with pointers to some of the most popular free and open source tools.
The book does have it’s short comings. There are places where the text is either confusing to read, or just wrong, and they should have a website with links to all of the tools presented, along with the data used with the examples in order to make it easier for the reader to follow along with the examples and jump-start them playing with the tools presented. The presentation of a set of analytic techniques, followed by a workshop where one of the tools is introduced to work through a real example is a strong point of this book. I also appreciated the informal description of classical statistics to help provide context to the subject. This is something that should accompany any introductory text on classical statistics. It both gives an opportunity to see the techniques in action and provides some pointers for those wanting more hands-on experience with a set of techniques. Overall, I would recommend this as the best primer to Data Analysis techniques that I have come across, but it still fall short of being an excellent book.
The Myths of Innovation is one of the most insightful books I’ve read in a while. It should be required reading for anyone who works for a technology start-up or manages engineers.
The first part of the book presents 10 popular myths of how innovation and invention happen. Through re-telling of many popular invention stories, the author discounts all of my least favorite myths, including that innovation happens through magical epiphanies, that great ideas are instantly adopted, and that the best ideas win. He does this through an easy to read, story-telling style. Plus, he manages to include plenty of references to boost the credability of his arguments. In the second part of the book, he gives some direction of those who think of themselves as innovators. These include some ways to help put yourself in a state of mind that will boost your creative thinking, how to stay motivated in the face of the many roadblocks that stand in the way of your potential innovation, and some tips on how to pitch your ideas, whether your audience is your boss, potential investors, or others. There are many pieces of advice/motivation in this last section that I will come back to in the years to come. The kicker is the last chapter, which gives a list of other references that the author recommends, as pieces of further advice and/or motivation for innovators. This will form the basis of my continued reading list.
Overall, I highly recommend this book to anyone that is either doing the innovation themself, or manages people who are innovating.
While this is not one of the greatest programming book I’ve ever read, it is a worthwhile read for those who are proficient in the basics of Python programming and want to take their knowledge of the language, it’s standard library, and it’s uses to the next level.
The author does a good job of presenting real-world applications of the language, explaining the problem and solution in a clear style and showing the ultimate python solution in clear code. However, be prepared to do some skimming and skipping. The book is 1600 pages long and part of the reason for this is the author’s verbose style. The other con for this book is the examples are showing some age. He presents a program for breaking up a file into small enough chunks to fit onto floppy disks. I haven’t had to do that in > 10 years. Further, he spends a lot of time presenting techniques for developing GUI applications, including a 400+ page, multi-chapter part of the book. In the days of web applications, that time would have been better spent on a quick intro to a modern day web app framework like Django.
If you are familiar with the basics of Python programming, and want to advance your skills, I recommend picking up Programming Python and working through it, your Python skills will be the better for it.