Book/Video Reviews

Functional Thinking

Functional Thinking: Functional Programming using Java, Clojure and Scala. Neal Ford is a fantastic teacher in this video. He succinctly explains what closure means and how it works better than any articles I've seen on the web.


The quote "functional is more a way of thinking than a tool set" summarizes the intent of the video. Neal covers various functional programming topics such as currying, memoization, laziness, and shows examples in Clojure, Scala, Groovy, and even Java (to a point). Then he continues to demonstrate how functional helps express your code better than imperative programming, and can be more natural language structured than verbose boilerplate code.


Borrowing a couple of quotes from Michael Feathers:
  • OO makes code understandable by encapsulating moving parts.
  • FP makes code understandable by minimizing moving parts.
This video is a good guide in achieving the desired results using functional thinking in the problem domain, and not be mired down in the steps from language limitations.


Node - Up and Running

Node - Up and Running is a good guide to do just that, get up and running with Node. Starting with a brief introduction to Node.js, the book walks the reader through the philosophies behind Node.js, core features, patterns, and external modules. These provide sufficient background for a newcomer to start building applications in Node.


Because everything is still evolving, version numbers should have been included in the modules discussed and used in code samples, which may use deprecated code. I think having version numbers would have helped more easily track down the differences between the current releases and the example code.

Read it to get an understanding of Node.js, but be ready to spend a little more time to work the code samples.


Getting Started with OAuth 2.0



Getting Started with OAuth 2.0 by Ryan Boyd is a small book that provides a fair introduction to OAuth 2.0. I think it does a great job at explaining the fundamentals and has a good structure in covering the various applications flows: server-side, client-side, resource owner password, and client credentials. However, even though it’s a short book, I find it a bit too verbose for the material covered. It also tries to be helpful in providing tips, recommendations, and the idiosyncrasies of Google’s and Facebook’s implementations, all scattered throughout the text, which unfortunately is a distraction.

I’d recommend this book if you are new to OAuth and want to read it on a flight. Otherwise, there are online resources that are just as useful. For example, Google’s Using OAuth 2.0 to Access Google APIs seems to cover almost as much content as this book.



JavaScript Web Applications
JavaScript Web Applications by Alex MacCaw illustrates the building blocks for a JavaScript MVC framework. It explains how to handle events, models, controllers, and views in JavaScript, which require some some careful consideration due to the nature of the language and tooling support.

The code samples start out following the best practices from another book, Douglas Crockford’s Javascript: The Good Parts, to build out the class structure and then relies on jQuery for the rest of conceptual implementations. Although there is a jQuery Primer in the appendix, some practical experience with jQuery would be helpful to understand the code samples.

After the conceptual chapters, MacCaw covers a few popular JavaScript MVC libraries: Spine, Backbone, and JavascriptMVC. This section provides a decent comparison between the libraries and the philosophies adopted in them.

Overall, JavaScript Web Applications is a good read for those who want to peek inside the inner workings of JavaScript MVC libraries.




Codermetrics: Analytics for Improving Software Teams



“Codermetrics: Analytics for Improving Software Teams” by Jonathan Alexander is a must read for management to improvement their software teams and products. Alexanders takes an organic approach to walk the reader through metrics and processes accompanies by insights from his 30 years of career experience.
The first few chapters have heavy usage of sports statistics as software metrics analogies. While they are occasionally illustrative, I find them mostly a distraction, maybe because they are too long for me to focus on the original topic. The use of sports analogies reappeared in the set of metrics definitions, which may work if you can get the software team to think in terms of offense, defense, assists for ideas such as code quality, bug fixes and helping other developers.

It might help to skim the processes section as it answered many of my questions I had in reading the earlier sections. People factors, metric collection methods, and such are all mostly explained in the processes section. I’m still not convinced that all the metrics on individual developers will be effective since they ultimately “grade” the coder even though Alexander cautions against it. However, one of the gems of this book is that it asks questions about those metrics or analysis of them to make you think and hopefully customize them to help your software teams.

Overall it’s a decent book, particular if you have yet to start collecting metrics.




Functional Programming for Java Developers: Tools for Better Concurrency, Abstraction, and Agility



“Functional Programming for Java Developers” by Dean Wampler; O’Reilly Media; is a great introduction for Java developers experienced in object-oriented programming (OOP) to get a taste of what functional programming (FP) is like. Wampler explains the functional programming concepts and demonstrates them with Java code (as best as possible in the language). Although this provides a glimpse of FP, I can see myself getting very confused following the book if I didn’t already have some FP exposure.

It is eye opening to see how concise and clearer the Java code is in FP style. Even if you prefer OOP, I’d still recommend giving this book a read for the advice on better design for more reusable modules and less buggy code, e.g. use immutable variables to simplify multi-threaded programs.

Since it’s a short book and some of the explanations are brief, I appreciate the comprehensive list of references to look up additional details on related topics. Overall, this book is well worth the few hours to read and add to my skill set.

FYI, Wampler also wrote a Scala book titled “Programming Scala: Scalability = Functional Programming + Objects”. This is going in my to-read list.







No comments: