Solidity Overview

 Solidity is a contract-oriented, high-level programming language for implementing smart contracts.

It has been designed to target the Ethereum Virtual Machine (EVM).


Solidity is an object-oriented programming language for writing smart contracts. It is used for implementing smart contracts on various blockchain platforms, most notably, Ethereum.


Solidity is statically typed (A statically-typed language is a language (such as Java, C, or C++) where variable types are known at compile time.), supports inheritance, libraries and complex user-defined types programming language.


You can use Solidity to create contracts for uses such as voting, crowdfunding,  and multi-signature wallets.


What is Ethereum?

Ethereum is a decentralized ie. blockchain platform that runs smart contracts i.e. applications that run exactly as programmed without any possibility of downtime, censorship, fraud or third-party interference.


In blockchain, decentralization refers to the transfer of control and decision-making from a centralized entity (individual, organization, or group thereof) to a distributed network. 


The Ethereum Virtual Machine (EVM)

The Ethereum Virtual Machine, also known as EVM, is the runtime environment for smart contracts in Ethereum. The Ethereum Virtual Machine focuses on providing security and executing untrusted code by computers all over the world.

The Ethereum Virtual Machine has been designed to serve as a runtime environment for smart contracts based on Ethereum.


What is Smart Contract?

A smart contract is a computer protocol intended to digitally facilitate, verify, or enforce the negotiation or performance of a contract. Smart contracts allow the performance of credible transactions without third parties. These transactions are trackable and irreversible.

protocol is a system of rules that allows two or more entities of a communications system to transmit information






Comments

Post a Comment

Popular posts from this blog

Solidity - Variable Scope

  Scope of local variables is limited to function in which they are defined but State variables can have three types of scopes. Public  − Public state variables can be accessed internally as well as via messages. For a public state variable, an automatic getter function is generated. Internal  − Internal state variables can be accessed only internally from the current contract or contract deriving from it without using this. Private  − Private state variables can be accessed only internally from the current contract they are defined not in the derived contract from it. pragma solidity ^ 0.5 . 0 ; contract C { uint public data = 30 ; uint internal iData = 10 ; function x () public returns ( uint ) { data = 3 ; // internal access return data ; } } contract Caller { C c = new C (); function f () public view returns ( uint ) { return c . data (); //external access } } contract D is C { function y () publ
Read more

Solidity Syntex

A Solidity source files can contain an any number of contract definitions, import directives and pragma directives. Let's start with a simple source file of Solidity. Following is an example of a Solidity file − pragma solidity >= 0.4 . 0 < 0.6 . 0 ; contract SimpleStorage { uint storedData ; function set ( uint x ) public { storedData = x ; } function get () public view returns ( uint ) { return storedData ; } } Pragma The first line is a pragma directive which tells that the source code is written for Solidity version 0.4.0 or anything newer that does not break functionality up to, but not including, version 0.6.0. A pragma directive is always local to a source file and if you import another file, the pragma from that file will not automatically apply to the importing file. So a pragma for a file which will not compile earlier than version 0.4.0 and it will also not work on a compiler starting from version 0.5.0 will be writt
Read more

Solidity - Variables

 S olidity supports three types of variables. State Variables  − Variables whose values are permanently stored in a contract storage. Local Variables  − Variables whose values are present till function is executing. Global Variables  − Special variables exists in the global namespace used to get information about the blockchain. Solidity is a statically typed language, which means that the state or local variable type needs to be specified during declaration. Each declared variable always have a default value based on its type. There is no concept of "undefined" or "null". State Variable Variables whose values are permanently stored in a contract storage. State Variable Variables whose values are permanently stored in a contract storage. pragma solidity ^ 0.5 . 0 ; contract SolidityTest { uint storedData ; // State variable constructor () public { storedData = 10 ; // Using State variable } } Local Variable Variables whose values a
Read more