Bitcoin and other blockchain variants like Ethereum are currently garnering a tremendous amount of professional and public interest. While this undoubtedly is, in part, due to their financial (highly speculative) rise, I was curious to learn more details about the new and admittedly attractive features of this type of peer-to-peer protocol, implementing a cryptographically secured ledger of generalized transactions (to provide a concise and accurate definition of a generic blockchain, albeit not found in this work).
This book definitely is not the systematic and accurate “introduction” its title boldly claims, either to Ethereum or to (one of) the programming languages for actually developing and writing smart contracts, Solidity. It--very loosely--resembles an unstructured collection of smaller or larger (imprecise, I have to add) blog entries or text snippets that, somehow, are collected into chapters and sections to make everything look like a book. Additionally, in some places, the book simply copies publicly available information verbatim.
In general, I was not able to recognize a central theme. The author often mentions and sets out to explain certain concepts (like “block validation”), and then stops prematurely, only to pick up the very same concept a few pages later. That might be due to the fact that the author is unable to decide and focus on a putative audience for this book. At places, he seems to write for a layperson who never has heard a single word about programming at all (or the word “digital,” a command line interface, how to change a directory, how to install software, what a “for” loop looks like; how to use CTRL-C to copy text; that computers “read code from top to bottom”; and many other similar trivia points), but then he “explains” Merkle-Patricia trees or how a hash works in only a few words without an accompanying diagram or a worked-out example.
Generally, the book explains trivial things in a lot of superfluous text, but the really hard and interesting parts of smart contracts or how a blockchain really works internally (for example, the working of the consensus mechanism including forks) are only hinted at.
It also abounds with imprecise notions (consistently confusing “longest” chain of blocks with the “heaviest” chain, confounding the value of a variable with the variable itself); leaves several key concepts undefined (“nonce,” Ethereum’s “state transition function,” “consensus mechanism,” “i++” postincrement operator, and “proof of stake”); and contains small errors (externally owned accounts do possess state information; a private chain is not a “cloud database”; a smart contract does not refer to a financial contract for a derivative or option; and the reward calculation for uncle blocks is wrong). While largely ignoring the dangers of having smart contracts automatically execute “no matter what” (and also ignoring the heist of “The DAO” in 2016), he then mentions automated formal proofs as a potential safeguard, although apparently with an incorrect notion of this concept.
Amazingly, the introduction to the programming language Solidity--with which you would actually write smart contracts to be executed on the Ethereum public blockchain--turns out to be an incomprehensibly abbreviated and incomplete list of operators, some special keywords, and a few global variables cobbled together from its publicly available specification. The single “example” presented consists of 30 lines of code without a single word of explanation on what it is supposed to accomplish or how it actually works.
I have to correct myself here a little bit: the author explains that Solidity uses “CapsCase” instead of “camelCase” as a naming convention for its function and variable names--which actually is wrong (there is no “CapsCase” style but only camelCase with a capitalized or an uncapitalized initial letter). And we do see screen shots of another smart contract example, albeit the resolution of these screen shots (as most of the other pictures) is so poor that the reader is not able to learn anything useful here, especially about writing Solidity programs or developing “Dapps” (distributed apps, that is, smart contracts connected to a user interface).
After these criticisms, one might rightfully wonder whether the book is worth reading at all.
If you want to read a lightweight introduction to Ethereum, if you are content with getting bits and pieces of information drawn from various depths of this domain, if you want to learn a little bit about smart contracts and even cryptoeconomics (including a list of 22 high-level and very general use cases), and if you do not need to understand everything in great detail, or you do not need all of the information and metaphors to be accurate, then you still might consider it, especially if you do not want to spend your time searching the web for the same information. (In many cases, the publicly available official Ethereum information is of a better structure and higher quality than this book!)
In all other cases, specifically if you want to learn to program Solidity, how to really write smart contracts or even Dapps, or how the Ethereum blockchain actually works internally from a technical perspective, you can safely and completely ignore this work.
More reviews about this item: Amazon, Goodreads