Comparação das 10 principais linguagens de programação de contratos inteligentes em 2021

Autor: Lee Ting Ting

Fundador do Instituto Z

Pré-requisitos
Este artigo é para desenvolvedores que estão familiarizados com blockchain e contratos inteligentes. Se você não está confortável com essas terminologias, primeiro assista a este vídeo de 5 minutos explicando blockchain de forma simples. Você também pode usar este guia de blockchain para iniciantes para referenciar termos-chave quando você lê.

Motivação

Como desenvolvedor de blockchain que se juntou ao espaço desde 2017, tenho experiência em codificação de contratos inteligentes em várias linguagens de programação diferentes. Acredito que os desenvolvedores devem se perguntar “Por que existem tantas linguagens de contratos inteligentes e quais são suas diferenças? Como posso investir melhor meu tempo para aprender uma única linguagem e desenvolver em várias blockchains?” Essas perguntas estão há muito tempo presas em minha mente. Assim, achei que valia a pena pesquisar as 10 principais linguagens comumente vistas e publicá-las como um post de blog que descreve suas principais características para salvar a vida dos desenvolvedores. :)

Introdução & Esboço

As 10 principais linguagens de contratos inteligentes são selecionadas com base na minha observação da prevalência entre as comunidades de desenvolvedores atuais, que incluem Solidity, Vyper, Rust, C/C++, Go, C#, Bitcoin Script, Clarity, Move e Haskell. Entre estes, alguns foram criados especificamente para o desenvolvimento de blockchain (como Solidity e Vyper), enquanto outros foram ajustados a partir de linguagens existentes para trabalhar com blockchains e contratos inteligentes (como C e Rust).

Intuitivamente, ao comparar essas linguagens, as principais perguntas são: “Quais são suas diferenças do ponto de vista dos desenvolvedores? Qual é a lógica do projeto? Há necessidade de criar novas linguagens para blockchains específicas? Por que algumas linguagens são Turing-incompletas?” Especificamente, resumi sete métricas de comparação que serão descritas na seção a seguir. Também vou analisar os prós e contras de me desenvolver em cada idioma com base em minhas experiências.

O objetivo deste post é ajudar você, como desenvolvedor, a entender melhor como escolher entre várias linguagens e fornecer tutoriais para você começar.

Resumo Rápido da Tabela

Esta tabela fornece uma visão geral do nosso resumo de comparação. Não se preocupe se algumas métricas parecerem assustadoras à primeira vista. Explicaremos cada um deles em detalhes a seguir.

Métricas de comparação

Aqui está uma lista de aspectos a serem considerados ao avaliar linguagens de contratos inteligentes:

1. Quais blockchains usam essa linguagem como sua linguagem de contrato inteligente?
um. Quanto mais blockchains uma linguagem de contrato inteligente suportar, melhor. Todos nós queremos aprender uma linguagem e aplicá-la a vários blockchains, ou portar projetos existentes para outros blockchains para uma maior exposição do público.

2. Qual linguagem de programação tradicional tem a sintaxe mais semelhante a essa linguagem?
a.Esta informação ajuda-o a estimar o quão difícil é para si aprender esta nova língua. Por exemplo, você pode achar o Solidity mais fácil de pegar se já for um desenvolvedor JavaScript devido à semelhança de sintaxe.

3.Is essa linguagem Turing completa? (Para uma análise mais aprofundada, consulte este artigo.)
a.Há prós e contras para uma linguagem ser Turing completa. A vantagem de Turing completo é que ele pode “resolver qualquer problema se puder ser codificado”. Quando o Solidity nasceu em 2015 como uma linguagem de contrato inteligente Turing completa, ele abriu possibilidades ilimitadas de aplicativos a serem construídos aproveitando o poder do blockchain, enquanto o Bitcoin era considerado apenas como uma reserva de valor devido às suas funcionalidades limitadas que podem ser implementadas no script Bitcoin.

No entanto, a desvantagem de Turing completo é que, teoricamente, “ele não pode garantir quanto tempo levará para resolver o problema”. No caso do primeiro blockchain programável, o Ethereum, os contratos inteligentes são executados em série em vez de simultaneamente. Loops infinitos que podem bloquear a execução de outros contratos inteligentes não são, portanto, possíveis. O Ethereum aborda essa questão adotando “limites de gás”, definindo um limite superior que limita a complexidade máxima de uma única execução. Além disso, a pesquisa mostra que qualquer análise estática de linguagens completas de Turing é muito limitada ou fundamentalmente incompleta. Linguagens de Turing incompletas bem construídas suportarão análises estáticas muito mais aprofundadas, aumentando a segurança.

Como resultado, Turing “incompleto” tornou-se gradualmente o novo “recurso” de algumas linguagens de contratos inteligentes, como Vyper e Clarity.

https://twitter.com/TO/status/1408945872365187074?s=20

Esta linguagem suporta loops?
um. Normalmente, as linguagens de programação funcionais não possuem loops. Os desenvolvedores devem aprender a sintaxe alternativa para obter o mesmo resultado em comparação com o uso de loops. Por exemplo, no Clarity, podemos usar ‘map’ ou ‘fold’ como um substituto para loops.
É uma linguagem interpretada ou compilada? (consulte este artigo para as diferenças entre linguagem interpretada e compilada)
um. As linguagens interpretadas minimizam a área de superfície para a introdução de bugs removendo a representação compilada intermediária (como o código de bytes EVM para Solidity). Bugs do compilador são prejudiciais em blockchains porque mesmo que o código-fonte esteja livre de erros, o eventual programa que chega ao blockchain pode conter erros (referência). No entanto, o código interpretado geralmente é executado cerca de 5 a 10 vezes mais lento do que o código compilado (referência), uma vez que o interpretador deve analisar cada instrução em tempo de execução. (Mais sobre intérprete da Wikipedia) Em resumo, a codificação em linguagens interpretadas pode ser menos propensa a erros, mas lenta.
Quão tendência é essa linguagem com base em sua popularidade (avaliada pelas estrelas do Github)? (referência dos dados)
a. Nota: Se a nova linguagem for criada especificamente para criar contratos inteligentes, fazemos referência à linguagem que tem a sintaxe mais semelhante a ela.
b) Se um idioma tem muito tráfego no Github, isso implica que ele tem uma comunidade relativamente ativa e bem estabelecida. Isso implica uma adoção ainda mais impressionante se a linguagem for popular, mas relativamente nova, como o Move.
Qual é o seu ranking na “Linguagem de programação mais amada” da pesquisa do desenvolvedor Stack Overflow 2020?
um. Se uma linguagem é amada por muitos desenvolvedores, é mais provável que essa linguagem se torne mais prevalente no futuro e tenha um apoio crescente da comunidade.
Qual é a contagem real de estrelas do Github de seu próprio repositório?
a.Isto é para lhe dar uma visão quantitativa de quão popular cada linguagem de programação é. O link para o repositório do Github também é fornecido na tabela de comparação acima.

Top 10 Linguagens de Programação

Observe que a ordem abaixo é determinada pela prevalência da linguagem no espaço blockchain a partir de minhas observações.

Solidity

pragma solidity >=0.7.0 <0.9.0;

contract Storage {

    uint256 number;
    
    function store(uint256 num) public {
        number = num;
    }

    function retrieve() public view returns (uint256){
        return number;
    }
}

Exemplo 👆 de código
Blockchains suportados: cadeias compatíveis com Ethereum e EVM, como Binance Smart Chain (BSC), Tron, Polygon, xDAI, TomoChain, Cronos (desenvolvido pela crypto.com) e Quorum.
Sintaxe semelhante a: JavaScript
Construído com: C++
Completude de Turing: Verdadeiro
Loops de suporte: True
Linguagem interpretada ou compilada: compilada
Ranking de tendências com base nas estrelas do Github: 1
Ranking mais amado com base na pesquisa Stack Overflow: 10
Descrição

1.Factos

Inicialmente proposto em 2014, o Solidity é uma linguagem de programação orientada a objetos e tipada estaticamente para escrever contratos inteligentes em blockchains compatíveis com Ethereum e EVM (Ethereum Virtual Machine). A razão pela qual o Solidity foi criado pode ser rastreada até por que o Ethereum precisa de seu próprio EVM em vez de VMs existentes. Como dito no Stack Overflow, nenhuma das VMs existentes satisfazia os requisitos do Ethereum.

2.Prós

Valor histórico como uma das primeiras linguagens de contrato inteligente de blockchain programável
Curva de aprendizado relativamente suave
Boa capacidade de escrita e legibilidade
Comunidade bem estabelecida com documentação suficiente, tutoriais em vídeo / escritos e perguntas e respostas sobre o Stack Overflow.
É mais fácil encontrar talentos técnicos familiarizados com essa linguagem para trabalhar em projetos de blockchain.
Os padrões existentes são bem definidos para aplicações específicas, como ERC20 e ERC721.
Muitas ferramentas disponíveis:
O OpenZeppelin oferece bibliotecas de código aberto para o desenvolvimento seguro de contratos inteligentes. Os desenvolvedores podem herdar e construir com base em contratos inteligentes existentes que se provam seguros ao longo do tempo.
O Truffle & Hardhat fornece um ambiente de desenvolvimento fácil de usar e uma estrutura de teste para desenvolver aplicativos.
Ecossistema bem desenvolvido que leva a melhores experiências do usuário combinado com protocolos descentralizados existentes.

3.Contras

Como um novo idioma, algumas armadilhas de segurança ainda precisam ser descobertas. (Referenciado da documentação oficial do Solidity)
Difícil realizar análise estática para evitar bugs no programa, uma vez que a propriedade Turing complete introduz infinitas possibilidades de como um programa pode se comportar.
Os desenvolvedores precisam escrever testes que atinjam mais de 95% de cobertura para garantir a solidez do programa.
Diferenças significativas de sintaxe entre diferentes versões do Solidity, tornando os códigos escritos em versões anteriores mais difíceis de serem reutilizados.
Os desenvolvedores têm menos experiência com essa nova linguagem, o que leva a uma maior probabilidade de bugs.
Falta de verificações internas de estouro e subfluxo para operações aritméticas.

5.Referências

Solidity Wiki, minhas próprias experiências
Links: Github (estrelas: 11.3K), documentação

Script Bitcoin

scriptPubKey: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
scriptSig: <sig> <pubKey>

Exemplo👆 de código
Blockchains suportados: Bitcoin
Sintaxe semelhante a: Forth
Construído com: C++
Completude de Turing: Falso
Loops de suporte: False
Linguagem interpretada ou compilada: interpretada
Ranking de tendências com base nas estrelas do Github: (Não há dados relevantes disponíveis)
Ranking dos mais amados com base na pesquisa Stack Overflow: (Não há dados relevantes disponíveis)
Descrição
Fatos
a.Apareceu junto com o Bitcoin em 2009, o Bitcoin Script é simples, baseado em pilha e Turing incompleto. As instruções são processadas sequencialmente. Os dados são enviados para a pilha e os opcodes (códigos de operação) são usados para executar operações nos itens na pilha.
Prós
a.Valor histórico como o script do blockchain mais prevalente.
Contras
a. Os opcodes não são fáceis de aprender, escrever e ler.
b) Poucas pessoas realmente usam essa linguagem para criar aplicativos. A maioria de seus casos de uso são para transferir fundos com lógica simples.
Referências
Bitcoin Wiki, minhas próprias experiências
Links: Github (estrelas: 55.9K), documentação

Vyper

stored_data: uint256  

@public  
def set(new_value : uint256):  
self.stored_data = new_value  

@public  
@constant  
def get() -> uint256:  
return self.stored_data

Exemplo👆 de código
Blockchains suportados: cadeias compatíveis com Ethereum e EVM
Sintaxe semelhante a: Python
Construído com: Python
Completude de Turing: Falso
Loops de suporte: True
Linguagem interpretada ou compilada: compilada
Ranking de tendências com base nas estrelas do Github: 2
Ranking mais amado com base na pesquisa Stack Overflow: 3
Descrição
Fatos:
a. Vyper é uma linguagem de contrato inteligente pythonic criada em 2017 que compila para bytecode EVM como Solidity. Os desenvolvedores aprenderam com os problemas do Solidity e projetaram a linguagem para ser mais simples, segura e fácil de auditar. Ele remove os recursos que se mostraram problemáticos no Solidity. Não é um substituto para o Solidity, mas uma linguagem para usar quando eles precisam do mais alto nível de segurança.
Prós:
a. Sintaxe semelhante ao Python
b. Verificação de limites e estouro em acessos de array e aritmética.
c) Programas escritos em Vyper sempre terão uma saída previsível, enquanto programas escritos em Solidity não terão uma saída previsível até que seja implantado e executado.
Contras:
a. Poucos projetos adotam o Vyper como sua linguagem de contrato inteligente. O número de contratos Vyper vs contratos Solidity no Github é 1000 vs 740K no momento da escrita.
b) Menos documentação e exemplos para começar.
Referências: O Vyper é uma boa alternativa ao Solidity?, documentação do Vyper Links: Github (estrelas: 3.2K), documentação

Rust

use solana_program::{
    account_info::{next_account_info, AccountInfo},
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    program_error::ProgramError,
    pubkey::Pubkey,
};

entrypoint!(process_instruction);

pub fn process_instruction(
    program_id: &Pubkey, 
    accounts: &[AccountInfo], 
    _instruction_data: &[u8], 
) -> ProgramResult {
    msg!("Hello World Rust program entrypoint");
    Ok(())
}

exemplo de código (solana), contrato de token fungível no NEAR, contrato ERC20 no Polkadot
Blockchains suportados: Solana, Near, Polkadot
Sintaxe semelhante a: (Linguagem existente modificada para oferecer suporte a contratos inteligentes)
Construído com: Rust
Completude de Turing: Verdadeiro
Loops de suporte: True
Linguagem interpretada ou compilada: compilada
Ranking de tendências com base nas estrelas do Github: 13
Ranking mais amado com base na pesquisa Stack Overflow: 1
Descrição
Fatos
a. Apareceu pela primeira vez em 2011, Rust é uma linguagem projetada para desempenho e segurança, especialmente simultaneidade segura. É sintaticamente semelhante ao C++ com desempenho competente, mas pode garantir a segurança da memória sem coleta de lixo. Além disso, foi eleita a “linguagem de programação mais amada” no Stack Overflow Developer Survey todos os anos desde 2016.
Prós:
a. Rust é a linguagem de contrato inteligente mais usada para Solana, o blockchain com um dos maiores TPS (transações por segundo) até hoje (TPS em tempo real).
b) Desempenho competente como C/C++
c. Bugs (exceto os lógicos) podem ser eliminados durante a compilação do programa.
d. Gerenciador de dependência embutido chamado Cargo.
e. Os desenvolvedores de Rust geralmente são mais experientes, levando a menos bugs nos aplicativos desenvolvidos.
Não. Os programas Rust podem ser executados em sistemas embarcados.
Contras:
a. A compilação de programas pode ser demorada (acima de 10 minutos para grandes projetos)
b. A sintaxe é mais complicada de aprender, escrever e ler.
c) Menos exemplos de contratos inteligentes Rust.
Referências: Golang vs Rust, Rust Wiki, minhas próprias experiências
Links: Github (estrelas:
56.8K), documentação para Solana, documentação para Near, documentação para Polkadot

C/C++

#include <hello.hpp>

[[eosio::action]]
void hello::hi( name nm ) {
   print_f("Name : %\n", nm);
}

[[eosio::action]]
void hello::check( name nm ) {
   print_f("Name : %\n", nm);
   eosio::check(nm == "hello"_n, "check name not equal to `hello`");
}

exemplo de código, Registrando contrato no Solana
Blockchains suportados: EOS, Solana
Sintaxe semelhante a: (Linguagem existente modificada para oferecer suporte a contratos inteligentes)
Construído com: C / C++
Completude de Turing: Verdadeiro
Loops de suporte: True
Linguagem interpretada ou compilada: compilada
Ranking de tendências com base nas estrelas do Github: 7
Ranking mais amado com base na pesquisa Stack Overflow: 18
Descrição
Fatos:
a.Apareceu pela primeira vez em 1972, C é uma linguagem de programação procedural com um sistema de tipos estáticos. Ele foi inicialmente desenvolvido para construir utilitários rodando em Unix, e foi aplicado para re-implementar o kernel do sistema operacional Unix.
Prós:
a. C/C++ está no currículo obrigatório de todos os alunos com um curso de ciência da computação. Mais desenvolvedores estão familiarizados com sua sintaxe.
b. C é uma linguagem portátil que pode ser executada em várias máquinas.
c) Bibliotecas ricas para algoritmos e estruturas de dados eficientes.
d. Comunidade bem estabelecida com documentação suficiente, tutoriais em vídeo / escritos e perguntas e respostas sobre o Stack Overflow.
Contras:
a. Em comparação com Rust, é difícil escrever código seguro para memória.
b) Ponteiros em C/C++ são um conceito relativamente difícil de entender e consome muita memória. O uso indevido de ponteiros como ponteiros selvagens pode fazer com que o sistema trave ou se comporte de forma anômala.
c) Poucas blockchains adotam C/C++ como sua linguagem de contrato inteligente. A ferrugem costuma ser mais preferida.
d. O código de contrato inteligente escrito em C/C++ não é conciso em comparação com o Solidity.
Referências: C Wiki, Vantagens e Desvantagens da Programação C, minhas próprias experiências
Links: Github (estrelas:
168), documentação para EOS, documentação para Solana

Go

func (s *SmartContract) CreateAsset(ctx contractapi.TransactionContextInterface, id string, color string, size int, owner string, appraisedValue int) error {
    exists, err := s.AssetExists(ctx, id)
    if err != nil {
        return err
    }
    if exists {
        return fmt.Errorf("the asset %s already exists", id)
    }

    asset := Asset{
        ID:             id,
        Color:          color,
        Size:           size,
        Owner:          owner,
        AppraisedValue: appraisedValue,
    }
    assetJSON, err := json.Marshal(asset)
    if err != nil {
        return err
    }

    return ctx.GetStub().PutState(id, assetJSON)
}

exemplo de código (hyperledger), contrato de token no Neo
Blockchains suportados: Hyperledger Fabric, Neo
Sintaxe semelhante a: (Linguagem existente modificada para oferecer suporte a contratos inteligentes)
Construído com: Go
Completude de Turing: Verdadeiro
Loops de suporte: True
Linguagem interpretada ou compilada: compilada
Ranking de tendências com base nas estrelas do Github: 3
Ranking mais amado com base na pesquisa Stack Overflow: 5
Descrição
Fatos:
a. Introduzido pelo Google em 2009, o Golang é uma linguagem de programação tipada estaticamente para tornar eficiente o software do lado do servidor.
Prós:
a. Go é a linguagem ideal para escrever contratos inteligentes Hyperledger Fabric (uma estrutura de blockchain com permissão e focada na empresa).
b) Bom desempenho como C/C++. Com simplicidade de sintaxe semelhante, o Go é normalmente 40 vezes mais rápido do que o Python altamente otimizado.
c) Tempo de compilação extremamente rápido (geralmente terminado em segundos).
d. Possui uma rica biblioteca padrão. Os desenvolvedores não precisam importar ou aprender bibliotecas secundárias complicadas.
e. A sintaxe é relativamente simples, fácil de aprender e ler.
Não. Código mais simples é geralmente mais seguro do que código complicado. Mais fácil de identificar erros.
Contras:
a. Não oferece suporte à programação orientada a objetos.
b) Falta de um único framework dominante como Rails para Ruby e Django para Python.
Referências: Golang Wiki, Golang vs Rust, Rust Vs Go:
Qual escolher e por quê?, devo ir? Os prós e contras de usar a linguagem de programação Go, Por que mudamos de Python para Go
Links: Github (estrelas: 87.8K), documentação para Hyperledger Fabric

C

using Neo;
using Neo.SmartContract;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;
using System;

namespace Helloworld
{
    [ManifestExtra("Author", "Neo")]
    [ManifestExtra("Email", "dev@neo.org")]
    [ManifestExtra("Description", "This is a contract example")]
    public class Contract1 : SmartContract
    {
        //TODO: Replace it with your own address.
        [InitialValue("NiNmXL8FjEUEs1nfX9uHFBNaenxDHJtmuB", ContractParameterType.Hash160)]
        static readonly UInt160 Owner = default;

        private static bool IsOwner() => Runtime.CheckWitness(Owner);

        // When this contract address is included in the transaction signature,
        // this method will be triggered as a VerificationTrigger to verify that the signature is correct.
        // For example, this method needs to be called when withdrawing token from the contract.
        public static bool Verify() => IsOwner();

        // TODO: Replace it with your methods.
        public static string MyMethod()
        {
            return Storage.Get(Storage.CurrentContext, "Hello");
        }

        public static void _deploy(object data, bool update)
        {
            if (update) return;

            // It will be executed during deploy
            Storage.Put(Storage.CurrentContext, "Hello", "World");
        }

        public static void Update(ByteString nefFile, string manifest)
        {
            if (!IsOwner()) throw new Exception("No authorization.");
            ContractManagement.Update(nefFile, manifest, null);
        }

        public static void Destroy()
        {
            if (!IsOwner()) throw new Exception("No authorization.");
            ContractManagement.Destroy();
        }
    }
}

Exemplo de código
Blockchains suportados: Neo
Sintaxe semelhante a: (Linguagem existente modificada para oferecer suporte a contratos inteligentes)
Construído com: C#
Completude de Turing: Verdadeiro
Loops de suporte: True
Linguagem interpretada ou compilada: compilada
Ranking de tendências com base nas estrelas do Github: 9
Ranking mais amado com base na pesquisa Stack Overflow: 8
Descrição
Fatos
a. Desenvolvido por volta de 2000 pela Microsoft como parte de sua iniciativa .NET, o C# é uma linguagem de programação de uso geral e orientada a objetos.
Prós A sintaxe é relativamente fácil de
aprender, escrever e ler.
O código C# pode ser executado em sistemas embarcados.
Os desenvolvedores de jogos que usam o Unity para o desenvolvimento de jogos já estão familiarizados com essa linguagem.
Contras Poucas blockchains adotam isso como sua linguagem de
contrato inteligente.
O desempenho não é tão bom quanto o C/C++.
Mais consumo de memória em comparação com C/C++.
Requer que a versão correta do .NET Framework seja instalada para executar o programa, o que leva a um tempo de instalação maior.
Referências
C# Wiki, Quais são os prós e contras de C# vs Java?, minhas próprias experiências
Links: Github (estrelas: 7.2K), documentação para Neo

Clarity

;; sip009-nft
;; A SIP009-compliant NFT with a mint function.

(impl-trait .sip009-nft-trait.nft-trait)

(define-constant contract-owner tx-sender)

(define-constant err-owner-only (err u100))
(define-constant err-token-id-failure (err u101))
(define-constant err-not-token-owner (err u102))

(define-non-fungible-token stacksies uint)
(define-data-var token-id-nonce uint u0)

;; "Takes no arguments and returns the identifier for the last NFT registered using the contract."
;; What if no NFTs were ever minted?
(define-read-only (get-last-token-id)
	(ok (var-get token-id-nonce))
)

(define-read-only (get-token-uri (token-id uint))
	(begin
		(unwrap! (nft-get-owner? stacksies token-id) (ok none))
		(ok (some "https://stacksies.com/metadata/"))
		;; (ok (some (concat (concat "https://stacksies.com/metadata/" (to-ascii token-id)) ".json")))
	)
)

(define-read-only (get-owner (token-id uint))
	(ok (nft-get-owner? stacksies token-id))
)

(define-public (transfer (token-id uint) (sender principal) (recipient principal))
	(begin
		(asserts! (is-eq tx-sender sender) err-not-token-owner)
		(nft-transfer? stacksies token-id sender recipient)
	)
)

(define-public (mint (recipient principal))
	(let ((token-id (+ (var-get token-id-nonce) u1)))
		(asserts! (is-eq tx-sender contract-owner) err-owner-only)
		(try! (nft-mint? stacksies token-id recipient))
		(asserts! (var-set token-id-nonce token-id) err-token-id-failure)
		(ok token-id)
	)
)

exemplo de código (NFT)
Blockchains suportados: Stacks (Blockstack-backed, um blockchain de camada 1 que traz contratos inteligentes e aplicativos descentralizados para o Bitcoin)
Sintaxe semelhante a: Lisp
Construído com: Ferrugem
Completude de Turing: Falso
Loops de suporte: False
Linguagem interpretada ou compilada: interpretada
Ranking de tendências com base nas estrelas do Github: 40
Ranking dos mais amados com base na pesquisa Stack Overflow: (Não há dados relevantes disponíveis)
Descrição
Fatos
a. Criado em 2020, o Clarity é uma nova linguagem de programação para escrever contratos inteligentes no blockchain Stacks 2.0. O Stacks 2.0 ancora contratos inteligentes claros ao Bitcoin, tornando possível que contratos inteligentes operem com base em ações vistas no blockchain do bitcoin.
Prós
Os desenvolvedores podem usar o Clarity para escrever código legível que funcione com o blockchain do Bitcoin.
A clareza é uma linguagem decidível. Pode-se saber pelo próprio código o que o programa fará. A clareza é intencionalmente Turing incompleta.
Isso permite uma análise estática completa de todo o gráfico de chamadas de um determinado contrato inteligente.
Como uma linguagem interpretada, ele não tem compilador e, portanto, nenhum bug do compilador.
Seguro por design: a reentrância não é permitida e verifica se há subfluxos e transbordamentos.
A sintaxe é fácil de aprender, escrever e ler quando você se sente confortável com os parênteses.
Contras
A língua é muito jovem. Leva tempo para que a linguagem se prove segura e não propensa a erros.
O único blockchain que ele suporta é o Stacks. O código do contrato inteligente não pode ser portado para outros blockchains existentes.
O design intencionalmente limitado pode dificultar a criação de contratos inteligentes.
Como essa linguagem não é nada parecida com o Solidity, o ecossistema do Stacks precisa ser construído do zero.
Os exemplos e tutoriais são relativamente poucos.
Referências
Stacks whitepaper, Clarity book, minhas próprias experiências
Links: Github (estrelas: 103), documentação, Clarity Visual Studio Code plugin

Move

Exemplo de código
Blockchains suportados: Diem (apoiado pelo Facebook), Pontem
Sintaxe semelhante a: Rust
Construído com: Ferrugem
Completude de Turing: Verdadeiro
Loops de suporte: True
Linguagem interpretada ou compilada: interpretada
Ranking de tendências com base nas estrelas do Github: (Não há dados relevantes disponíveis)
Ranking dos mais amados com base na pesquisa Stack Overflow: (Não há dados relevantes disponíveis)
Descrição
Fatos
a. Apresentado em 2019, o Move é uma linguagem de código de bytes executável usada para implementar transações personalizadas e contratos inteligentes. O principal recurso do Move é a capacidade de definir tipos de recursos personalizados. Um recurso nunca pode ser copiado ou descartado implicitamente, apenas movido entre locais de armazenamento do programa. A linguagem foi criada para resolver problemas de linguagens de contratos inteligentes existentes, como a eliminação da possibilidade de reentrância. Ele também adiciona flexibilidade ao adotar conceitos semelhantes à programação orientada a objetos, como módulos.
Profissionais

Flexibilidade

O Move introduz o conceito de “script de transação”, que permite comportamentos únicos e comportamentos reutilizáveis, enquanto outras linguagens de contrato inteligente permitem apenas comportamentos reutilizáveis.
Comportamento único: pagar um conjunto específico de destinatários
Comportamento reutilizável: invocando um único procedimento que encapsula uma lógica reutilizável

Segurança

Como uma linguagem de código de bytes executável, o Move adota um verificador de código de bytes e um interpretador de código de bytes em vez de um compilador como o Solidity, o que o torna livre de possíveis falhas ou ataques em compiladores, como declarado na documentação oficial do Solidity.
Cada ativo no Move tem propriedades nativas de escassez e controle de acesso.
A solidez não tem verificação de escassez nativa. Quando novos tokens são cunhados, você tem que verificar manualmente se a escassez (fornecimento total neste caso) foi atingida.
O Solidity não tem verificação de controle de acesso nativo, você precisa escrever modificadores como onlyOwner.
Move Introduz o conceito de “recurso”, que nunca pode ser duplicado ou descartado implicitamente, ele só pode ser movido entre locais de armazenamento do programa. Isso é semelhante a um “token” em outras blockchains.
Por exemplo, Coin é um recurso, que só pode ser movido uma vez de um local para outro e não pode ser copiado ou gasto duas vezes.
Em Solidity, não existe esse conceito. A transferência de ativos precisa ser especificada manualmente, aumentando a chance de escrever códigos com bugs.

Modularidade

Os módulos Move estão relacionados, mas não são os mesmos que o conceito de “contratos inteligentes” no Ethereum e em outras plataformas blockchain.
Um contrato inteligente Ethereum contém código e dados publicados. Em Libra, os módulos contêm valores de código e os recursos contêm valores de dados.
Em termos orientados a objetos, um contrato inteligente Ethereum é como um objeto singleton publicado sob um único endereço de conta. Um módulo é uma receita para criar recursos, mas pode criar um número arbitrário de recursos que podem ser publicados em endereços de conta diferentes. (referência)
Os dados em um contrato inteligente só podem ser modificados dentro do escopo do contrato, mas não em outros contratos de fora. No Solidity, os dados não têm escopo e, portanto, não têm esse tipo de proteção.
Por exemplo, na parte de código a seguir, somente os procedimentos do módulo Moeda podem criar ou destruir valores do tipo Coin.

Contras
Como Move é uma linguagem interpretada onde cada linha precisa ser avaliada em tempo de execução, o desempenho não é tão bom quanto as linguagens compiladas. Observe que essa é uma compensação para fins de segurança (livre de bugs do compilador).
A língua é muito jovem. Leva tempo para que a linguagem se prove segura e não propensa a erros.
As únicas blockchains que suporta são Diem e Pontem. O código do contrato inteligente não pode ser portado para outros blockchains existentes. No entanto, vale a pena notar que a Pontem fornecerá ferramentas para portar aplicações em um futuro próximo. Por exemplo, os desenvolvedores podem executar a maioria dos aplicativos no EVM e criar as alterações necessárias no Move com uma ferramenta de migração automatizada que substitui o código herdado pelo atual.
Como essa linguagem não é nada parecida com o Solidity, o ecossistema do Diem precisa ser construído do zero.
Os exemplos e tutoriais são relativamente poucos.

Referências

Mover whitepaper aprofunde, Mover visão geral do whitepaper
Notas especiais: Ligação entre Rust & Move (referência)
Se você está familiarizado com Rust, você pode se lembrar dos conceitos de “recurso”, “propriedade” e “mover”. Em Rust, os recursos só podem ter um dono.
Ao fazer atribuições (let x = y) ou passar argumentos de função por valor (foo(x)), a propriedade dos recursos é transferida. Em Rust-speak, isso é conhecido como um movimento.
É assim que vem o nome da linguagem de programação “Move”. Depois de mover recursos, o proprietário anterior não pode mais ser usado. Isso se alinha com as propriedades das moedas digitais que não podem ser gastas em dobro.
Também vale a pena notar que a linguagem Move e o blockchain Diem são escritos em Rust. O líder da equipe da carteira Novi da Diem mencionou no Reddit que “Como um projeto onde a segurança é um foco principal, a segurança de tipo e de memória de Rust eram extremamente atraentes”.
Links: Github (estrelas: 15.9K), documentação, introdução ao Pontem, Move VS Code Extension

Haskell*

import qualified Data.Text                 as T
import           Language.Plutus.Contract  hiding (when)
import           Language.PlutusTx.Prelude
import           Playground.Contract

-- | A 'Contract' that logs a message.
hello :: Contract BlockchainActions T.Text ()
hello = logInfo @String "Hello, world"

endpoints :: Contract BlockchainActions T.Text ()
endpoints = hello

mkSchemaDefinitions ''BlockchainActions

$(mkKnownCurrencies [])

exemplo de código (Marlowe incorporado em Haskell)
Blockchains suportados: Cardano
Sintaxe semelhante a: Miranda
Construído com: GHC (Glasgow Haskell Compiler)
Completude de Turing: Verdadeiro
Loops de suporte: False
Linguagem interpretada ou compilada: compilada
Ranking de tendências com base nas estrelas do Github: 22
Ranking mais amado com base na pesquisa Stack Overflow: 15
Descrição
Fatos
a. Haskell é uma linguagem de programação estaticamente tipada, preguiçosa e puramente funcional. As linguagens funcionais são excelentes para escrever especificações que podem realmente ser executadas e também mais fáceis de manter.
b) Haskell é fácil de implementar um processo de verificação formal verificando se um projeto satisfaz alguns requisitos.
Prós
Código mais curto, claro e de maior manutenção.
Mesmo que você não esteja em posição de usar Haskell em seus projetos de programação, aprender Haskell pode torná-lo um programador melhor em qualquer linguagem.
Usufrui de todas as vantagens das linguagens de programação funcionais.
Contras Poucas blockchains adotam isso como sua linguagem de
contrato inteligente.
Não são muitos os desenvolvedores experientes com programação funcional.
Muito poucos aplicativos estão sendo construídos no Cardano, o que significa que há poucas referências para o desenvolvimento de contratos inteligentes Haskell.
Referências
- Haskell Wiki
- A plataforma Plutus
- Links:
  - Github (estrelas: 3.6K),
  - documentação,
  - IDE em tempo real

Reconhecimento

Este trabalho foi revisado por Chia-Chi Chang, Alejandro Pinto, Chi-Chen Liang, Marvin Janssen e Sean Sie:)

Embrulhar

Agora você tem uma visão geral das 10 principais linguagens de programação de contratos inteligentes em 2021, seus prós e contras e comparações em termos de sete métricas de avaliação. Se você acompanha o artigo, deve ser capaz de responder “Por que existem tantas linguagens de contratos inteligentes? Quais são suas diferenças? Qual a língua que melhor se adapta às minhas necessidades”. Espero que este artigo seja útil para sua jornada de escolha e aprendizado de contratos inteligentes.

Obrigado pelo seu tempo de leitura. Sugestões são bem-vindas e sinta-se livre para me indicar se algo não estiver claro. Até a próxima! :)

Artigo Original

Table of Contents