Language Matters: Thank You for Calling them Smart Contracts, Vitalik

Smart contracts are small, independent applications running on blockchains, like Ethereum, that support them.  The term “smart contract” came from Nick Szabo’s papers, including Smart Contracts: Building Blocks for Digital Markets. For example:

The basic idea of smart contracts is that many kinds of contractual clauses (such as liens, bonding, delineation of property rights, etc.) can be embedded in the hardware and software we deal with, in such a way as to make breach of contract expensive (if desired, sometimes prohibitively so) for the breacher. . . . A broad statement of the key idea of smart contracts, then, is to say that contracts should be embedded in the world.

Ethereum and Smart Contracts

Later, when Ethereum was created, Vitalik Buterin adopted Szabo’s term, smart contracts, to describe the code running on the Ethereum Virtual Machine (“EVM”).  As Ethereum and blockchain has grown, however, the term has has created confusion from non-technical commentators who assume there is a legal or contractual element to them.

Perhaps because of the swirl that followed, Vitalik very recently mentioned he regrets using the term:


Vitalik would have used a more technical, “boring” term, like “persistent scripts.”

Language Matters

Who can know for sure, but I suspect if Vitalik actually used the term “persistent scripts” instead of smart contracts I’m pretty sure it wouldn’t have captured the broad-based attention beyond the computer science industry, especially from the legal academy, as it has.

For example, when I first heard about smart contract back in about 2014 or ’15, they were described to me as something that would completely replace the need for lawyers and courts.

Today I have lawyers who approach me and ask, “What are these smart contract things?” Had they been named differently, I’m pretty sure they wouldn’t approach me in the first place, let alone ask, “What are these persistent script things?”

Now I have lawyers who come up to me and say, “What are these smart contract things?” Pretty sure they wouldn’t say, “What are these persistent script things?”

And for me, the skills and need for legal engineering is strongly expressed in the blockchain industry, and I believe it’s largely because of Szabo and Buterin’s word choice.

So I’m glad you did it, Vitalik. Thank you!

Had a Great Time at the UCI Blockathon – What I Learned from the Front and the Back of the Room

UCI Blockathon Picture 1
This is Sid and the leadership team. UC Irvine October 2018

I was lucky enough to have an opportunity to present Solidity programming to about 150 people at the University of California, Irvine Blockchain association (UCI Blockchain), mostly to computer science students. Thought I’d share a few notes about what I heard and what I saw.

Fortunately for me, I was on after USC Professor Bhaskar Krishnamachari who presented a comprehensive overview of blockchain in a way that resonates with computer science students and, key for me, in a way that I couldn’t do!

What I Learned From the Front of the Room

UCI Blockathon Picture 2
UC Irvine October 2018 (That’s not actually me at the front of the room in this picture.)

When it was my turn, I walked them through a step by step build up of a Solidity smart contract locally using Truffle and Ganache. Then we deployed the contract on Rinkeby and had about eight of the students interact with it using MetaMast. It was very close to what I did at Desert Code Camp a few weeks ago.

During my session, a few issues came up that you might find interesting if you’re out there evangelizing on smart contract development. First, I probably started too fast and glossed over what a smart contract is in the first instance. It’s a key concept, and it takes a minute and a few iterations to soak in—even for a bunch of super smart students.

Second, you might need to spend a little more time on the protocol itself. When I showed them how to interact with the contract using Pragma or through Truffle, they missed some of the fundamentals so there were quite a few questions about who would interact with the contract under what terms, which is basic protocol stuff.

What I Learned from the Back of the Room

UCI Blockathon Picture 4
UCI Blockathon – UC Irvine October 2018

While there was a heavy emphasis on learning and training at the UCI Blockathon, some of the students stayed and hacked all night. (I’m at an age now where, if I tried that, I’d be paying for it all the way to Wednesday.)

Since I wasn’t mentoring them all night, I was ok with judging the teams. I’m glad I did because I was blown away with what they created overnight (after three very long training sessions).

First, I noticed that five of the seven teams chose to develop on Ethereum using almost exactly the tech stack and workflow I showed them, which I’ll take as a win.

Next, I noticed a few teams struggled to articulate whether their project was appropriate for blockchain. For example, one team sought to build a supply chain project. Supply chain is a great use case for blockchain, but may not be necessary where a simple B2B transactional system would suffice.

Three of the teams nailed the use case almost perfectly, however. The winner created a complete, end to end Dapp for transferring rights in artists works. The next up has a great use case to put academic records on chain. The third was a using blockchain to track real world payments to charities for transparency.

Finally, the leadership team at UCI Blockchain was fantastic. If they keep operating at high levels like that, I’m expecting great things out of their careers!

Thanks for having me!

UCI Blockathon Picture 3
UC Irvine October 2018

StandardToken.sol deleted? How to move to OpenZeppelin 2.0 for your ERC-20 token

Today I was playing around with some ERC-20 stuff and, because things are moving really fast in the blockchain, smart contract, and Ethereum space, I hit some serious speed bumps.

Ether as a cryptocurrency and digital asset is one key aspect of the Ethereum world computer, but a lot of the most interesting things are happening through tokens, whether it’s ICOs, STOs, utility tokens, or some of the fascinating economic engineering going on behind them.

Tokens follow the ERC-20 standard, which is pretty simple (if you keep it that way).  And, for the most part, new developers are likely to lean on the OpenZepplin library.  There are many blogs, Medium posts, StackOveflow questions, and more giving you code snippets to use based on early versions of OpenZepplin.

It’s so easy.  You’re probably going to do something like:

npm i openzeppelin-solidity

The problem is you’re going to download the new OpenZepplin library (version 2.0) and basically nothing you read will help you anymore.  Let me try.

Forget about StandardToken.sol or manipulating the tokenSupply or any of that.  Just create a new token with the following:


That’s going to start a new token contract with a supply of 100000000000 and transfer all of them, initially, to whoever created the contract.

That should get you going.  Good luck out there legal engineers!