Bitcoin was invented to replace banks, having no regulatory bodies. Decentralization has led to the creation of smart contracts that once executed do not involve human intervention. Devs use ad hoc programming languages ​​for smart contracts. Although famous programming languages ​​such as C ++, Java, Python, Go, Ruby, JavaScript, etc are seen as the best, others have been created that rely on these: Solidity, Rust, Move and Clarity. Some blockchains use "classic" programming languages:

-Aion: Java
-Icon: Python
-EOS: C++
-NEO: C#

Then there are some variations.

SOLIDITY (ETHEREUM AND EVM)
Solidity is a programming language specifically designed to develop EVM smart contracts for Ethereum (Avalanche, Bnb Chain, Cronos Chain, Fantom, etc). Solidity is a high-level code broken down into specific instructions that are easy to understand for machines. It supports objects, booleans, enumerations, integers, strings, byte arrays and status variables. Even developers who are not experienced with Solidity can be helped with development if they are proficient in JavaScript, Python and C ++. In fact, Solidity's blockchain development foundations coordinate with these programming languages. It is therefore used to implement smart contracts in the Ethereum virtual machine. Solidity code is written on the EVM, converted by the compiler and then executed by the processor. It is also used to write dapps on Tendermint (open source software for launching blockchain on Cosmos).

RUST (SOLANA, POLKADOT, EGLD, NEAR)
Rust is mainly used for writing smart contracts on Solana, Polkadot, Near and Egld. It is a programming language close to the low-level ones, although not very different from C ++ and JavaScript. Rust offers many features such as memory security, reduced runtime, etc. This allows you to write a smart contract compiled in wasm that has no memory bugs and consumes less storage space on the blockchain. It allows devs to create customizable and scalable dapps.

MOVE (APTOS, SUI NETWORK)
Created to support the creation of digital assets, Move is an open source bytecode programming language, used to preserve simplicity while supporting the complex needs of the smart contract infrastructure. Based on Rust, Move aims to develop customizable transaction logics and smart contracts mainly for the Aptos and Sui Network blockchains. Move supports Booleans, references, unsigned 64-bit integers, fixed-size byte arrays, and 256-bit addresses. It also encodes ownership of digital assets and creates procedures for transferring these assets. It also addresses the problems of indirect representation by introducing resources, a customizable type inspired by linear logic. Furthermore, every single transaction has a script that is responsible for encoding the logic that a validator should execute. The Move language basically has three components: types, structures and procedures. The types are primitive data used in it such as Boolean, Integer, fixed size byte array and address data type. Structs are fundamentally limited and unbounded (resource structures and general structures). Procedures are simple methods in the Move programming language.

COSMWASM (COSMOS)
CosmWasm, enable WebAssembly (WASM) virtual machines (VM) in Cosmos SDK. Adding WebAssembly to Cosmos SDK allows the software to run securely on a blockchain. Wasm is an intermediate language that compiles developer code into a portable virtual machine. This product allows developers to write modules in Rust that integrate seamlessly with the Cosmos SDK, so they can take advantage of the SDK modules and the BPoS Tendermint consensus algorithm by developing custom application logic (largely based on Rust). Second, the ability to load code into transactions, rather than restarting the chain, allows for much faster implementation of new features.

MICHELSON (TEZOS)
This language used by Tezos is stack-based, with primitives, high-level data types, and strict static type checking. Its cherry design brings together traits from different language families (Scheme, Forth, ML and Cat). Michelson is a series of instructions executed in sequence: each instruction receives as input the stack resulting from the previous instruction and rewrites it for the next. The stack contains both immediate values ​​and heap-allocated structures. All values ​​are immutable and garbage collection. The input and output stack types are fixed and monomorphic, and the program is tested before being introduced into the system. No smart contract execution can fail because an instruction was executed on a stack of unexpected length or content.

SCILLA (ZILLIQA)
Scilla (Smart Contract Intermediate-Level Lannguage) is an intermediate-level smart contract language developed for the Zilliqa blockchain. It is mainly designed to ensure the security of smart contracts.
It imposes a framework for smart contracts by making applications less vulnerable to attack (by eliminating some vulnerabilities known directly at the linguistic level). Furthermore, Scylla's principle structure will make applications inherently safer and more susceptible to formal verification.
The language is developed in tandem with the formalization of its semantics and is incorporated into the Coq test assistant (a state-of-the-art tool for mechanized testing of program properties). Coq is based on an advanced theory of dependent typing and features a large set of mathematical libraries. It has been successfully applied previously to implement certified compilers (i.e. fully mechanically verified), concurrent and distributed applications, including blockchains among others.

HASKELL (CARDANO)
It is a functional programming language. Haskell has its roots in academia and the study of logic, as well as in previous iterations of functional programming languages, such as Miranda. Functional programming languages ​​emphasize the use of "pure" functions wherever possible: functions that always give the same result for the same input. It is suitable for code and programs that require a high degree of formal verification. Through Haskell, Cardano's Plutus and Marlowe smart contracts can be implemented with precise and formally verified code that offers a high level of assurance right from the start. Plutus and Marlowe are offered as a set of libraries for Haskell, leveraging existing Haskell documentation, toolkits, and a highly professional community providing a foundation from which to build secure, enterprise-grade smart contracts.
Both the off-chain and on-chain code for Cardano is written in Haskell.

CLARITY (BLOCKSTACK)
Clarity is a smart contract programming language introduced by Blockstack for its blockchain Stacks. Blockstack aims to build its Internet by providing smart contract services. It is a programming language, designed as "not complete" and "not intended for compilation" (it is an interpreted language). Clarity supports Boolean, Optional, tuple, list, response, and principal types. With the help of its rotational incompleteness, Clarity is able to calculate transactions well in advance. In Clarity, the source code of the contract itself is published and executed by the blockchain nodes, removing any pre-compiled intermediate representations. Through control functions it can also reduce any bugs. Predictability lets devs know how the program will run.

Are you interested in ways to earn crypto bonus? Check it out here: Some Sites To Earn Crypto Bonus (Old & New)