Let’s get down to brass tacks. Solidity seems to be inspired by Go and Javascript and ends up as the sandboxed child of both, with few of the best qualities and some new terrible ones. A marginally complex sample of Solidity code will end up looking something like this (borrowed, with minor edits, from Solidity documentation):

pragma solidity ^0.4.11; contract SimpleAuction {

address public beneficiary;

uint public auctionStart;

uint public biddingTime;

address public highestBidder;

uint public highestBid;

mapping(address => uint) pendingReturns;

bool ended; // Events that will be fired on changes.

event HighestBidIncreased(address bidder, uint amount);

event AuctionEnded(address winner, uint amount); function SimpleAuction(

uint _biddingTime,

address _beneficiary

) {

beneficiary = _beneficiary;

auctionStart = now;

biddingTime = _biddingTime;

} function bid() payable {

require(now <= (auctionStart + biddingTime));

require(msg.value > highestBid); if (highestBidder != 0) {

pendingReturns[highestBidder] += highestBid;

}

highestBidder = msg.sender;

highestBid = msg.value;

HighestBidIncreased(msg.sender, msg.value);

} function withdraw() returns (bool) {

uint amount = pendingReturns[msg.sender];

if (amount > 0) {

pendingReturns[msg.sender] = 0; if (!msg.sender.send(amount)) {

pendingReturns[msg.sender] = amount;

return false;

}

}

return true;

} function auctionEnd() {

require(now >= (auctionStart + biddingTime));

require(!ended); ended = true;

AuctionEnded(highestBidder, highestBid); beneficiary.transfer(highestBid);

}

}

One of the statements commonly made about Solidity is that it feels similar to Javascript. Look, if you’re one of the people saying this, I’m not trying to claim that the syntax is totally foreign, but saying that it’s like Javascript is such a bizarre statement to make. Yes, there are your normal function and if and your friendly braces, and no, there aren’t those funny := operators.

The one reliable way to anger a Javascript developer

But then we get into the fact that semicolons aren’t optional, return and declaration types are explicit, the literal 0 is a byte (not an int), and pretty soon you’ll realise that almost any other general-purpose language (syntax, style, and use) makes for a better comparison. And thank goodness for that, considering that the static typing helps tremendously with deciphering author intent.

So what are we actually borrowing from Javascript? Certainly not any of the functional core. I imagine we’ve just gained some comfort in knowing that by talking about Javascript, we have made Solidity somehow more accessible.

And perhaps herein lies the problem: by trying to make smart contract writing as superficially accessible as possible, we’ve unwittingly assigned the critical task of designing once-deployable, unfamiliarly-patterned financial software to full stack devs who are used to building things that have completely incomparable degrees of adverse effects from failure.