Getting Started with Solidity, All you need to know (A Step by Step Guide).
Tags: blockchain, javascript, web3, beginners
Published: 2023-05-03 16:39:05

Solidity is a high-level programming language used to write smart contracts on the Ethereum blockchain. Smart contracts are self-executing programs that automatically enforce the terms of an agreement between two or more parties.

In this article, we will provide a step-by-step guide on getting started with Solidity. We'll begin by giving a brief introduction to the language and its basic structure, followed by an overview of data types, functions, and events in Solidity. So, let's dive right in and learn how to write smart contracts using Solidity.

## Getting Started

To start writing Solidity code, you need to have at least all of the following;

- A development environment like Remix or Hardhat: Remix is an online IDE that allows you to write and test Solidity code in your browser, while Hardhat is a local development environment that gives you more control over your development process.

- A text editor: This can be any text editor, such as Visual Studio Code, Atom, or Sublime Text.

- An Ethereum wallet: You will need to have an Ethereum wallet to deploy your smart contracts to the blockchain. There are several wallets available, including MetaMask and MyEtherWallet.

- Solidity compiler: You will need a Solidity compiler to compile your code into bytecode that can be executed on the Ethereum Virtual Machine (EVM). The most popular compiler is the solc compiler.

## Basic Structure

A Solidity contract is a collection of functions and data that can be deployed to the Ethereum blockchain. Here's an example of a simple Solidity contract:

```
pragma solidity ^0.8.0;

contract MyContract {
    uint256 myVariable;

    function set(uint256 _myVariable) public {
        myVariable = _myVariable;
    }

    function get() public view returns (uint256) {
        return myVariable;
    }
}
```
Hey, Don't Chicken Out! We would explain and go through this together. Cool!👌

In this contract, there is a state variable myVariable, set, get.

This Solidity code creates a smart contract with a single unsigned integer variable called myVariable It has two functions, set and get. The set function takes an argument _myVariable and sets the value of myVariable to it. The get function returns the current value of myVariable. The pragma statement specifies the version of the Solidity compiler to be used.

Cool Right? It's Just the Intro, Let's dive right into data types In solidity.👨‍🍳

## Data Types

Here's an explanation of some data types in Solidity with examples

- **bool**
: A boolean value that can be either true or false. For example:

```
bool myBool = true;

```
- **int**

and uint: These are integer types where int can store negative values and uint can only store positive values. The number after the type determines the number of bits used to represent the value. For example:

```
int8 myInt8 = -123;
uint16 myUint16 = 12345;
```

- **address**

: This is a 20-byte variable used to store Ethereum addresses. For example:


```
address myAddress = 0x1234567890123456789012345678901234567890;
```

- **string**
: This is used to store dynamic string values. For example:

```
string myString = "Hello, world!";
```

- **bytes**

: This is used to store byte arrays. For example:

```
bytes myBytes = hex"0011223344556677";
```

- **struct**

: A struct is a custom-defined composite type that groups other variables. For example:

```
struct Person {
    string name;
    uint age;
}

Person myPerson = Person("Alice", 25);

```
- **enum**

: An enumeration is a custom-defined type that defines a set of named constants. For example:

```
enum Color { RED, GREEN, BLUE }
Color myColor = Color.RED;
```

- **mapping**

: A mapping is a key-value store where the keys and values can be of any type. For example:

```
mapping(address => uint256) balances;
balances[0x1234567890123456789012345678901234567890] = 100;
```

- **array**

: An array is used to store a collection of values of the same type. For example:

```
uint256[] myArray = [1, 2, 3];
```

These are just some of the basic data types available in Solidity. There are more specialized types such as fixed-point numbers, multi-dimensional arrays, and others that you can learn about as you dive deeper into Solidity programming.

Next Up, Functions!✨

## Functions

Functions are an essential component of Solidity, allowing developers to define the behavior and functionality of smart contracts. We would go through some key examples of functions in Solidity:

Defining a public function:

```
pragma solidity ^0.8.0;

contract MyContract {
    uint256 myVariable;

    function set(uint256 _myVariable) public {
        myVariable = _myVariable;
    }

    function get() public view returns (uint256) {
        return myVariable;
    }
}

```
In this example, we define two functions set and get. The set function is a public function that sets the value of myVariable, while the get function is a public view function that returns the value of myVariable.

Defining a private function:

```
pragma solidity ^0.8.0;

contract MyContract {
    uint256 myVariable;

    function set(uint256 _myVariable) public {
        myVariable = _myVariable;
        doSomething();
    }

    function doSomething() private {
        // Do something here
    }
}
```

Here, we define a private function doSomething which can only be called from within the contract (set calls doSomething). Private functions are not visible to external contracts or accounts.

Defining an external function:

```
pragma solidity ^0.8.0;

contract MyContract {
    function doSomething() external {
        // Do something here
    }
}
```

Similarly! In this case, we define an external function doSomething. External functions can only be called from outside the contract and not from within the contract itself.

Defining an internal function:

```
pragma solidity ^0.8.0;

contract MyContract {
    uint256 myVariable;

    function set(uint256 _myVariable) public {
        myVariable = _myVariable;
        doSomething();
    }

    function doSomething() internal {
        // Do something here
    }
}
```

We define an internal function here, doSomething which can only be called from within the contract or any derived contracts. Internal functions are not visible to external contracts or accounts.

Next Up, Events!✨

## Events

Events in Solidity are used to notify external applications or contracts about certain actions that have occurred within a smart contract. They are similar to log messages and can be accessed via the Ethereum blockchain.

Here is an example of how to create and emit an event in Solidity:

```
pragma solidity ^0.8.0;

contract MyContract {
    event MyEvent(uint256 indexed id, string message);

    function doSomething(uint256 id, string memory message) public {
        // perform some action here

        emit MyEvent(id, message);
    }
}
```

In this example, we define an event called MyEventwith two parameters: id (an unsigned integer with an index) and message (a string). Within the doSomething function, we perform some action and then emit the event with the appropriate values.

To listen for and respond to events in another contract or application, you can use the web3.js library or a similar tool. Here is an example of how to listen for events emitted by the above contract using web3.js:

```
const myContract = new web3.eth.Contract(contractABI, contractAddress);

myContract.events.MyEvent({ filter: { id: 123 } })
    .on('data', function(event) {
        console.log(event.returnValues.message);
    })
    .on('error', console.error);
```

This code creates a new instance of MyContractusing the contract's ABI and address. It then listens for the MyEvent event with an ID of 123 and logs the corresponding message to the console when the event is triggered. If an error occurs, it will also be logged into the console.

Overall, events are a powerful way to communicate information between different parts of a decentralized application or even between different applications on the Ethereum network.

## Conclusion

Congratulations, you've successfully taken your first steps into the exciting world of Solidity! Armed with the knowledge of basic structure, data types, functions, and events, you're ready to start building on the Ethereum blockchain like a pro. Get ready to amaze your friends and family with your newfound skills in writing smart contracts - who knows, you might even become the next Vitalik Buterin!🧖‍♂️(Imagination)

This is just an Introductory guide to Solidity, but don't be afraid to dive deep and expand your knowledge! Get friendly with the language, read through the documentation, try building a mini Dapp and maybe you'll even create the next big thing on the blockchain.

## Reference

In a blog post for [Web3Afrika](https://blog.web3afrika.com/), I discussed the benefits of using blockchain technology and an Introductory guide on all you need to know to get started with solidity. For more content analysis like this, check out my [Personal Page](https://dev.to/vinyldavyl) here and follow me here on DevTo.

Until next time, Happy Exploring!

Cheers,

Vinyl-Davyl.