- The book provides an introductory look at building Ethereum smart contracts
- It covers both Solidity and web3.js
- The last part of the book introduces enterprise-level smart contract development
- Experienced developers may find the book somewhat entry-level
Chapter 1 deals with basic terminology of distributed applications based on cryptocurrency foundations (DApps). Even early on, the book stumbles on some simple concepts, including a rather confused description of the distinction between "distributed" and "decentralised".
The order that concepts are introduced in is also somewhat odd. Rather than starting with a description of the (potentially more familiar) use case cases such as Bitcoin and Ethereum, the book instead tries to define DApps and decentralised organisations (DAOs) directly.
This leads to a section where the book gets rather lost in the detail of concerns such as managing identity in distributed applications and the attendant difficulties. This is a bit much to take in so early on, especially without all the relevant technical concepts being introduced.
From here, the concept of a digital currency (or as the book calls it, an "internal currency") is introduced. Only at this point are some examples of DApps introduced, including Bitcoin and Ethereum. The description of Bitcoin is very short and rather lacking in nuance, with several very standard positive talking points repeated without any real analysis as to whether they're actually true or not.
Next, Ethereum is introduced in a very short section. This again seems rather odd, as the building of smart contracts and related projects on the Ethereum platform is the subject of the entire rest of the book. A much fuller description of Ethereum is provided in the next chapter, but the overall effect is somewhat jarring.
The book may well have flowed considerably better if Ethereum was introduced first, with the concepts of decentralisation woven into the narrative being told and explained as necessary.
The second chapter is much better, and provides a concentrated, if rather high-level, introduction to the Ethereum platform and its core concepts. For the reader who is unfamiliar with cryptocurrencies (or with Ethereum specifically) this may be a useful overview. However, several more conceptually challenging aspects (e.g. POS and Casper) are not covered in any depth, leaving the reader with little understanding of these parts of the technology or why they are required or useful for Ethereum.
Chapter 3, "Writing Smart Contracts" addresses the Solidity programming language. This is a tricky subject to cover - as Solidity is quite different to most other programming languages that developers are likely to have used. Unfortunately, the coverage of the language is sometimes less than clear, and fails to call out exactly which aspects of the language may differ from a reader's expectations.
For example, the usage of the var keyword does not make it at all clear whether it is required and what the semantics are.
Nevertheless, there is useful material here, not least because the fast, unvarnished presentation of the language strips bare many of Solidity's shortcomings and occasionally bizarre language design decisions.
Another aspect that seems unnecessary is the inline dumps of HTML that appear in this chapter. This seems to be present simply to allow the reader to cut and paste the code out into an IDE from the ebook, but does seem quite jarring in a modern technical book.
Chapter 5 deals with the basics of wallets, and introduces them via the teaching aid of building a wallet service. This again uses Node to produce a simple site that's capable of signing transactions offline and managing basic wallet functionality.
The topics covered in this part include building a basic contract deployment platform, accessing external services using Oraclize (to build a betting app as an extended example) and using the truffle build platform to create and manage larger deployments of smart contracts.
The final chapter provides a whirlwind tour through the implementation of a private blockchain (referred to as a "consortium" blockchain throughout) based on Ethereum. The primary technology used is the parity node, and the book embarks on a very rapid set of steps on how to build this from scratch. Parity is written in Rust, a language that has not previously been used in the book, and the instructions are brief to say the least.
The end result is that it feels like parity has been chosen simply because it is based on Ethereum, rather than because it is a particularly good way to showcase private ("consortium") blockchains. The technology provides a reasonable place to end the book, however.
Overall, the book suffers from a number of production problems. For example, the quality of the copy-editing and indexing is noticeably below average - there are numerous examples of incorrect grammar and spelling, as well as more serious errors (e.g. the table of contents page does not correctly link to some chapters, etc).
The book also feels quite outdated already - not only are there obvious signs of age (e.g. in the version numbers of software), but the book simply does not cover many of the major developments in the Ethereum and smart contract space over the last year.
Some of the technical material is now also obsolete or no longer recommended. For example, the issues that the Ethereum network has had with providing stable testnets and allowing developers to test in a true distributed environment are not even mentioned.
In summary, this provides an entry point into smart contract and Ethereum development that some developers may fund useful. However, experienced programmers and those who already have some knowledge of Ethereum may find other works more suitable to their needs.
About the Book Author