Learn Solidity in Y Minutes

Solidity is a statically typed, contract-oriented programming language with syntax similar to JavaScript and C. Designed specifically for writing smart contracts on blockchain platforms like Ethereum, Solidity enables developers to define self-executing code with persistent state. Each contract encapsulates state variables, functions, custom data types, modifiers for access control, and events for external notifications—making it a powerful tool for decentralized applications (dApps).

However, Solidity development carries high risks and high costs. A single bug can lead to irreversible loss of funds. Therefore, you must rigorously test your code and deploy gradually. Given how rapidly Ethereum evolves, this guide may not reflect the latest compiler versions or security practices. Always consult official Solidity documentation, community forums, and recent blog updates before deploying any contract. Do not copy-paste example code directly into production environments.

👉 Discover how blockchain developers use real-time data to test smart contracts securely.

Core Data Types and Variable Declarations

Solidity supports a variety of built-in data types essential for secure and efficient contract logic.

// Integer types – used for balances, timestamps, etc.
uint x; // Unsigned 256-bit integer
int constant a = 8; // Constant value replaced at compile time
uint constant VERSION_ID = 0x123A1; // Hexadecimal constant

// Explicit bit sizing (8 to 256 bits, in steps of 8)
uint8 b;
int64 c;
uint248 e;

// Addresses – 160-bit Ethereum account identifiers
address public owner;

// Bytes and strings
bytes32 c;        // Fixed-size byte array
bytes m;          // Dynamic byte array (more expensive)
string n = "hello"; // UTF-8 encoded string

Use constant for values that never change—this avoids storage costs. Be cautious with type inference using var, as it may result in unintended smaller types (e.g., int8 instead of int256), leading to overflow issues.

Data Structures: Arrays, Mappings, and Structs

Solidity provides robust data structures to manage complex on-chain information.

Arrays

bytes32[5] nicknames;     // Static array
bytes32[] names;          // Dynamic array
names.push("John");       // Append element
names.length = 1;         // Resize (only allowed for storage)

Mappings

Mappings are key-value stores ideal for tracking user balances or permissions:

mapping(address => uint) public balances;
balances[msg.sender] = 100;

Note: You cannot iterate over all keys in a mapping. To enable enumeration, build auxiliary data structures (e.g., arrays of keys).

Structs and Enums

Define custom types using struct and enum:

struct Bank {
    address owner;
    uint balance;
}
Bank b = Bank(msg.sender, 5);

enum State { Created, Locked, Inactive }
State public state = State.Created;

Function Basics and Visibility Modifiers

Functions in Solidity can be annotated with visibility specifiers:

• public: Callable internally and externally.
• private: Only visible within the contract.
• internal: Accessible by the contract and derived contracts.
• external: Only callable from outside.

Additionally:

• view: Guarantees no state changes (formerly constant).
• pure: No state read or write allowed.
• payable: Accepts Ether along with the call.

Example:

function deposit() public payable returns (uint) {
    balances[msg.sender] += msg.value;
    return balances[msg.sender];
}

👉 See how leading dApps verify function safety before deployment.

Security Patterns: Reentrancy and Input Validation

One of the most critical vulnerabilities in Solidity is reentrancy attacks, where a malicious contract recursively calls back into a vulnerable function before state updates complete.

To prevent this:

1. Apply the "Checks-Effects-Interactions" pattern:

   • First validate inputs (require).
   • Then update state.
   • Finally interact with external contracts.

function withdraw(uint amount) public {
    require(amount <= balances[msg.sender]);
    balances[msg.sender] -= amount; // Update state first
    msg.sender.transfer(amount);    // Then transfer
}

2. Use SafeMath libraries (or enable compiler overflow checks in Solidity >=0.8.0) to prevent arithmetic overflows.

Events and Modifiers

Events

Events notify off-chain applications about on-chain actions:

event LogDepositMade(address indexed account, uint amount);
LogDepositMade(msg.sender, msg.value);

External tools like Web3.js can listen to these logs efficiently.

Modifiers

Modifiers act as reusable guards:

modifier onlyOwner {
    require(msg.sender == owner, "Not owner");
    _;
}

function changeOwner(address newOwner) public onlyOwner {
    owner = newOwner;
}

Common use cases include access control, time locks, and state machine transitions.

Global Variables and Built-in Units

Solidity exposes several global variables:

• msg.sender, msg.value: Caller and sent Ether.
• block.timestamp, block.number: Current block metadata.
• now: Alias for block.timestamp (use cautiously—miners can manipulate slightly).

It also includes native support for currency units (wei, finney, ether) and time units (seconds, minutes, days):

uint deadline = now + 7 days;
uint minContribution = 1 ether;

Best Practices and Style Guidelines

Follow the Solidity Style Guide, inspired by Python’s PEP8:

• Use 4-space indentation.
• Separate top-level definitions with blank lines.
• Avoid extra spaces inside parentheses.

• Write clear NatSpec comments:

  /// @notice Deposits Ether into user balance
  /// @dev Requires non-zero value
  /// @param amount Amount of Ether sent
  function deposit(uint amount) public payable { ... }

Frequently Asked Questions

Q: Can I generate random numbers in Solidity?
A: Not securely on-chain. Block variables like blockhash are manipulatable. Use off-chain oracles or commit-reveal schemes instead.

Q: How do I handle upgrades in smart contracts?
A: Use proxy patterns (e.g., OpenZeppelin Upgrades) since deployed contracts are immutable. This allows logic updates while preserving data.

Q: What is the difference between transfer() and send()?
A: Both send Ether, but transfer() throws on failure (reverting the transaction), while send() returns false. Prefer transfer() for safety.

Q: Why avoid dynamic arrays in storage?
A: They’re more gas-intensive and harder to manage. Fixed-size arrays or mappings are often more efficient.

Q: Is recursion supported in Solidity?
A: Technically yes, but stack depth is limited (~1024). Prefer loops over recursion to avoid runtime errors.

Q: How do I delete a contract?
A: Use selfdestruct(recipient) to terminate a contract and send remaining funds. Only callable under strict access controls.

👉 Learn how developers simulate contract behavior using sandbox environments.

Final Thoughts

Mastering Solidity requires more than syntax—it demands deep awareness of security implications, gas optimization, and design patterns. Always audit your code, use formal verification tools when possible, and stay updated with evolving best practices.

Whether you're building DeFi protocols, NFT marketplaces, or DAO governance systems, Solidity remains the foundational language of Ethereum's ecosystem. Start small, test thoroughly, and deploy confidently.

Keywords: Solidity, smart contracts, Ethereum, blockchain development, reentrancy attack, SafeMath, function modifiers, event logging