vyper

You can write smart contracts in a Python inspired language also https://github.com/vyperlang/vyper

> I need a hero, and by that, I mean that I need a usable methodology for building scaleable decentralized apps. Yes, you've heard that right. We don't need more "Ethereum killers" that can do 10x more tx/s than Ethereum. Those are useless. Having worked on large Ethereum smart contracts (running a decentralized auction on chain) over two years, I fully agree with this. Ethereum needs better smart contract languages, better compilers and better dev tooling. As our smart contract written in Vyper (for ease of auditing) grew larger and larger, eventually we failed to deploy on the testnet, and closer inspection reveal that the compiler was blowing up code size which I had to patch[0]. Down the line upstream further increased gas costs by emitting code that zeroed out every member of an array (note the EVM already has all memory set to 0). T

Having worked with Ethereum, especially the low level bytecode, one of the changes I'm most excited for that I don't see mentioned a lot is the addition of eWASM support for nodes. There's many problems with the two dominant smart contract languages Solidity and Vyper, for instance bloated codegen that had to be patched otherwise complex contracts size could not be deployed[0], or more theoretical concerns such as soundness, semantics and correctness. Part of the problem is because of no coherent shared intermediate representation and developers writing backends from scratch, and lots of reinventing of the wheel[1]. There's an ongoing project[2] to create an LLVM backend for EVM but the stack based nature is at odds with LLVM IR's bias towards register-based architectures. (EVM doesn't even have a separate stack for return addresses to im

Vyper is available now. https://github.com/ethereum/vyper

The EVM is just a virtual machine. People are working on languages with less opportunity for bugs than Solidity, like Flint: https://github.com/flintlang/flint Also Vyper, which doesn't go as far but is already used in production: https://github.com/ethereum/vyper The EVM itself isn't the end of the road either. Over the next couple years, Ethereum is migrating to a more scalable sharded version using proof of stake, and it looks like that will allow pluggable execution engines.

Not explicitly. Currently, it's the most widest used language for interacting with the VM, but it's not the end development goal. I don't think the entire thing hinges on Solidity, though it's probably the most immediately accessible language. The hype driving the price up seems a bit premature, though. There are a couple of other languages in development that might improve the ecosystem: * Vyper https://github.com/ethereum/vyper * Serpent https://github.com/ethereum/serpent

Sure, but I'm not aware of any language with an optimizer that minimizes permanent storage (for example). The gas model has been forced to be a close representation of actual costs, because last year it wasn't close enough, and someone took advantage of that to launch denial of service attacks. Incidentally, last year someone wrote an Idris backend compiling to EVM for their doctoral thesis. They concluded that it had some benefits but not as much as they expected. [1] There's an effort in progress to migrate from the existing EVM to a modified webassembly [2], which would allow usage of existing languages, and potentially improve performance significantly. It's still experimental and may or may not work out, but seems to be making good progress. [3] With the existing EVM there are new languages in development that may improve matters, in

I totally agree with you about Solidity. If you're interested in developing a better language for smart contracts, check out Viper (https://github.com/ethereum/viper). Although development is kind of slow right now because Vitalik is the only one who merges pull requests.

This new language for Ethereum by Vitalik is exactly what you said: https://github.com/ethereum/viper

There are lots of different languages targeting EVM. The (IMO) most promising so far is https://github.com/ethereum/viper

I don't think it's very important. There are several other languages that can compile down to EVM bytecode. A cool one is Viper (https://github.com/ethereum/viper), which is NOT Turning complete, but decidable. This makes it easier to reason about the correctness of the code, and formally proving that your code is correct.

Nobody prevents you to write contracts in a more restrictive language. For example: https://github.com/ethereum/viper Or create your own. I am sure the creators of Solidity are aware of its limitations and quirks. But as far as I can tell they felt they had to ome up with something fast. And it grew from there. But as I said: Feel free to create your own language for the EVM if Solidity does not fit your needs or requirements. With a system allowing Turing completenes it should be possible to create a language that removes Turing completeness (for more security). It would be impossible the other way round.

One of the main Ethereum co-founders is working on a new experimental contract language targeting the Ethereum Virtual Machine called Viper which still seems to be under relatively active development[1]. Why pick Solidity if Viper and other languages like Low-level Lisp-like Language (LLL) by Consensys[2] are around the corner? Or is this just a matter of language flavour similar to how anybody can pick from a plethora of languages targeting the JVM (Clojure, Scala, Java, etc.)? [1] https://github.com/ethereum/viper [2] https://media.consensys.net/an-introduction-to-lll-for-ether...

Great explanation! I would also add that the code does not necessarily have to be turing complete. There is a new language that complies to EVM bytecode that is decidable (not turing complete) https://github.com/ethereum/viper It's a little less expressive, which makes it safer. Easier to reason about the code, for example)