Solidity Basics

Your First Steps in Solidity

Solidity is the language used to write smart contracts on the Ethereum blockchain. Think of a smart contract as a program that runs on a decentralized network, executing automatically when certain conditions are met. These contracts are the building blocks of decentralized applications (dApps).

Solidity is a programming language, specifically designed for creating and implementing smart contracts on Ethereum and other blockchain platforms.

If you have experience with languages like JavaScript, Python, or C++, you'll find that Solidity's syntax feels familiar. It's statically typed, meaning you have to declare the type of your variables upfront, which helps prevent common bugs.

Setting Up Your Workspace

The easiest way to start writing Solidity is with Remix IDE, a powerful, open-source tool that runs right in your browser. There's no need to install any complex software to get started. It provides a complete environment for writing, compiling, and deploying your contracts.

To get started, open a web browser and navigate to remix.ethereum.org. Create a new file by clicking the file icon in the top-left and name it SimpleStorage.sol. The .sol extension is standard for Solidity files.

The Anatomy of a Contract

Every Solidity file starts with a couple of important lines. Let's look at the basic structure of a smart contract.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract SimpleStorage {
    // Your code will go here
}

Let's break this down:

SPDX License Identifier: This is a comment that specifies the software license for your code. It's considered a best practice and helps build trust.
pragma solidity ^0.8.20;: This line tells the compiler which version of Solidity to use. The caret ^ means the code is compatible with version 0.8.20 and any newer patch releases in the 0.8.x series, but not version 0.9.0 or higher.
contract SimpleStorage { ... }: This declares the contract itself. All of your contract's logic, variables, and functions will be inside these curly braces.

Basic Building Blocks

Solidity has several data types for storing different kinds of information. Variables are containers for this information. Here are a few of the most common types you'll use.

Data Type	Description	Example
`uint`	Unsigned integer, a non-negative whole number. Often `uint256`.	`uint256 public myNumber = 10;`
`string`	A sequence of characters.	`string public myMessage = "Hello";`
`address`	Holds a 20-byte Ethereum address.	`address public owner;`
`bool`	A boolean value, which can be `true` or `false`.	`bool public isComplete = false;`

The public keyword you see in the examples is a visibility specifier. When you mark a variable as public, the compiler automatically creates a "getter" function for it. This means other contracts and external clients can read its value.

Writing a Simple Contract

Let's write a contract that can store a number and let us retrieve it. This is a classic "Hello, World!" example for smart contracts.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract SimpleStorage {
    uint256 private storedNumber;

    // Stores a new number
    function store(uint256 _newNumber) public {
        storedNumber = _newNumber;
    }

    // Retrieves the stored number
    function retrieve() public view returns (uint256) {
        return storedNumber;
    }
}

Here, we've added two functions:

store(uint256 _newNumber): This function takes one argument, an unsigned integer named _newNumber, and sets our storedNumber variable to its value. Since this function changes the state of the contract (it modifies a variable), it would require a transaction (and gas fees) on a live blockchain.
retrieve(): This function reads and returns the value of storedNumber. Notice the view keyword. This tells Solidity that the function only reads from the blockchain and doesn't modify its state. Calling view functions is free. The returns (uint256) part specifies that this function will return an unsigned integer.

Compiling and Deploying

Now that you've written your first contract, it's time to compile and deploy it using Remix.

Compile: Go to the "Solidity compiler" tab in Remix (the second icon on the left). Ensure the compiler version matches the one in your pragma line (e.g., 0.8.20). Click the "Compile SimpleStorage.sol" button. You should see a green checkmark if everything is correct.
Deploy: Switch to the "Deploy & run transactions" tab (the third icon). Make sure the SimpleStorage contract is selected in the "CONTRACT" dropdown. Click the orange "Deploy" button.

Once deployed, you'll see your contract appear under "Deployed Contracts." You can now interact with it. Enter a number into the field next to the store button and click it. Then, click the retrieve button to see the number you just stored.

Congratulations! You've just written, compiled, and deployed your first smart contract. This simple example covers the fundamental workflow you'll use for more complex projects.

Quiz Questions 1/5

What is the primary purpose of the Solidity programming language?

Quiz Questions 2/5

What does the line pragma solidity ^0.8.20; at the beginning of a contract file signify?

Solidity Smart Contracts and Blockchain Integration