You already know that a blockchain is a distributed ledger. But some blockchains, like Ethereum, are much more. They're programmable. Instead of just recording who owns what, they can run applications that execute logic automatically, without a central server or administrator. These applications are called smart contracts.

A smart contract is just a program stored on the blockchain that runs when predetermined conditions are met. It's the code that replaces the intermediary. Instead of trusting a bank to transfer your money, you trust code that's visible to everyone and can't be changed once it's deployed. This is the core of Web3's functionality.

So where does this code actually run? It executes inside the Ethereum Virtual Machine (EVM). Think of the EVM as a single, global computer. Every full node on the Ethereum network runs a copy of the EVM to process transactions and maintain the blockchain's state. This distributed design is what makes the system decentralized and secure.

When you send a transaction to a smart contract, every node runs the same computation through its EVM. They all check that the transaction is valid and compute the new state. This consensus ensures that the contract's execution is deterministic and verifiable, no matter where in the world you are. The EVM is the engine that transforms the blockchain from a simple database into a dynamic, interactive platform.

To write a program for the EVM, you need a specialized programming language. The two most prominent are Solidity and Vyper. They offer different approaches to achieving the same goal: creating secure, reliable smart contracts.

Solidity is by far the more popular of the two. It's a high-level, statically-typed language with a syntax similar to JavaScript or C++. This familiarity makes it accessible to a large pool of developers. It's feature-rich, giving developers a lot of flexibility to build complex applications.

Vyper, on the other hand, prioritizes security and simplicity. It has a cleaner, Python-like syntax and intentionally omits certain features found in Solidity to reduce the potential for bugs and vulnerabilities. The philosophy is that simpler, more readable code is easier to audit and harder to get wrong, which is crucial when code is handling valuable assets.

Once a contract is written, it isn't deployed in its human-readable form. It must first be compiled into bytecode, which is the low-level machine code that the EVM can actually execute.

Running code on a global, decentralized computer isn't free. Every single operation, from adding two numbers to storing a piece of data, requires computational resources from the network's nodes. To pay for this, Ethereum uses a concept called gass.

Gas is the unit used to measure the computational effort required to execute a transaction. Simple operations cost a small amount of gas, while complex ones or those that store a lot of data cost much more. This pricing mechanism prevents bugs like infinite loops from bogging down the entire network and stops spam transactions.

When you initiate a transaction, you specify a gas price in a small unit of ether called Gwei. This is the price you're willing to pay per unit of gas. The total transaction fee is the amount of gas consumed multiplied by the gas price you set.

A smart contract has a distinct lifecycle, from its creation to its permanent residence on the blockchain.

Once deployed, a smart contract is generally immutable. This means its code cannot be altered. This is a powerful security feature—you know the rules won't change unexpectedly. However, it also means that bugs are permanent. Developers have created patterns like proxy contracts to allow for upgrades, but the core principle of immutability remains.

The contract's variables and their current values are known as its state. For example, a contract for a token would store a list of addresses and their balances. When a user sends a transaction that successfully calls a function to transfer tokens, the contract's state is updated. This state change is permanently recorded on the blockchain for everyone to see.

Understanding this lifecycle is key to grasping how decentralized applications function. They are not just static pieces of data but living programs whose logic is enforced by the consensus of a global network.