Solidity (J10)

It was first introduced in August 2014, and its stable version has been evolving ever since.

Solidity takes inspiration from other programming languages:

JavaScript for its flexibility (used for building websites).

C++ for its strict structure and speed (great for complex apps).

Python for its readability and beginner-friendly vibe.

But let’s be real—while Solidity aims to be easy to learn, it’s still a bit of a challenge for most beginners!

If you already know a bit of JavaScript, C++, or Python, you’ll find Solidity feels a little familiar.

That’s why it’s a good idea to start with one of those languages before diving into Solidity.

Oh, and one more thing…

Solidity files are saved with a .sol extension.

Just like Word documents are saved as .docx, Solidity’s got its own style!

When you save a Solidity program, it’s saved with a .sol extension.

For example:

If you’re working on a smart contract to manage payments, you might save it as “PaymentContract.sol”

If it’s an NFT-related program, you could name it “MyNFT.sol”

Now, let’s talk about Solidity’s license.

Solidity is licensed under the GNU General Public License (GPL) v3.0.

What does that mean?

In simple terms:

Solidity is open source, so anyone can view and modify its code.

This ensures that developers can freely improve Solidity without needing anyone’s permission.

It also means you can trust the code—no sneaky tricks or hidden backdoors.

Here’s a fun fact:

Under the GPL v3.0, any modifications to Solidity’s code must also stay open and available for public use.

So, when you download Solidity (including any updates), you’re getting all improvements too!

Latest Version of Solidity

Solidity, like any software, gets updated regularly to fix bugs, add new features, and make it better overall.

The latest stable release is version 0.8.28, which came out on October 9, 2024.

As a developer, it’s always a good idea to keep your tools up to date to avoid bugs and enjoy all the latest features.

Where to Get Solidity

Your ultimate Solidity resource is its official website: www.soliditylang.org

Here’s what you’ll find there:

Beginner-friendly tutorials to kick off your learning.

The latest version of Solidity to download.

Detailed documentation for advanced users who want to dive deeper.

Bookmark it—it’s the perfect place to start and grow your Solidity journey!

Let’s talk about Solidity’s programming paradigm—specifically, the imperative paradigm.

Don’t worry, we’ll break it down step by step!

What’s a Paradigm?

A paradigm is just a fancy word for the way a programming language organizes and executes its code.

Think of it as the “style” or “approach” of the language.

What’s the Imperative Paradigm?

The imperative paradigm is like writing a recipe.

You give the computer a step-by-step guide:

1. Add 1 cup of water.

2. Toss in 2 pounds of meat.

3. Simmer for 30 minutes.

Every single step is listed in detail, and the computer follows them one by one to achieve the final result.

Because of this, the imperative paradigm is also called algorithmic programming—you’re essentially creating a detailed set of instructions (an algorithm) for the computer to execute.

Key Characteristics

Step-by-step instructions: The computer does exactly what you tell it, in the exact order you specify.

Machine-oriented: This style aligns closely with how computers “think,” focusing on every small action needed to get the job done.

Imperative Programming and Solidity

To write Solidity code effectively, you’ll need to understand how computers work internally.

Solidity’s imperative nature is similar to languages like C, C++, Java, Pascal, Fortran, and Assembly.

Other Paradigms

There are different “styles” of programming paradigms, just like there are different ways to cook a meal:

1. Procedural Paradigm: Groups instructions into reusable blocks (like following a recipe for different dishes).

2. Object-Oriented Paradigm (OOP): Focuses on organizing data and actions into objects.

For example, the Move language, used for coding Sui and Aptos, is object-oriented.

3. Functional Paradigm: Solves problems by applying functions and avoiding changing data directly.

4. Declarative Paradigm: Instead of writing out steps, you just describe the desired result, and the computer figures out the steps on its own (like saying, “I want cake,” and letting a chef handle the rest).

Why Paradigms Matter

Each paradigm offers a different way to think about and organize programming tasks.

Solidity uses the imperative paradigm because it focuses on giving computers detailed instructions to execute smart contracts effectively.

So, whether you’re coding payments, NFTs, or DAOs, you’re essentially writing the computer’s “recipe” to follow step by step!

A lil bit of technicals

Solidity is a statically typed programming language designed for developing smart contracts that run on the Ethereum Virtual Machine (EVM) or compatible virtual machines (like Hyperledger Fabric).

Vending Machine Analogy

Think of learning Solidity like learning to drive.

Just as learning to drive requires practice, patience, and understanding the manual to avoid accidents, Solidity requires practice, the right documentation, and the patience to master its complexities.

Solidity allows you to build smart vending machines that handle digital money.

These smart contracts interact with the blockchain to process transactions, similar to how a vending machine accepts coins to dispense drinks.

Key Features and Syntax

Solidity Syntax vs. ECMAScript

Solidity syntax is inspired by ECMAScript (European Computer Manufacturers Association Script), the standard that forms the basis for JavaScript, but with significant differences.

It is a statically typed language, meaning you must specify the data types (e.g., integer, string, etc.) before using them in your code.

Unlike JavaScript, Solidity also supports variadic return types, which allows a function to return multiple values of different types.

Vending Machine Analogy

Imagine you are building a vending machine using Solidity.

The machine accepts different types of inputs (coins) and gives out products (soda, snacks) in return.

Just like when you're programming a vending machine, you need to define what types of inputs (money, coin denominations) it will accept and what types of outputs (soda, snacks) it will give out.

In ECMAScript (European Computer Manufacturers Association Script), the vending machine might allow any input without specifying the exact type, but in...

...Solidity, you must be very explicit about the types of inputs—whether it's a specific coin denomination (integer) or a particular snack (string or identifier).

Solidity’s static typing ensures that it doesn’t mistakenly accept faulty coins (incorrect data types), and it will always return the correct item based on the input.

Data Structures and Inheritance

Solidity supports complex data structures, such as mappings and structs, to organize data in smart contracts.

It also supports inheritance, which allows new contracts to be based on existing ones, enhancing reusability and modularity.

Contracts in Solidity can inherit from others, enabling multiple inheritance with C3 linearization.

Vending Machine Analogy

With Solidity, you can build complex systems like tracking who bought which drinks and scheduling deliveries.

The inheritance feature allows you to build on existing vending machine models, so instead of starting from scratch each time, you can tweak and customize an existing recipe (contract).

Think of it like adjusting a family’s soda recipe but maintaining its base structure.

Solidity introduces the concept of an Application Binary Interface, which is a set of rules that allow smart contracts to communicate with each other and with external systems.

The ABI ensures that data passed between contracts and the blockchain is type-safe.

The ABI is like a secure communication line between the vending machine and the bank, ensuring that the transaction (payment) is valid and processed correctly.

When you use Solidity to write the contract, it ensures that when money is inserted into the vending machine, the correct soda is dispensed, and the transaction is recorded securely.

Solidity allows developers to add natural language documentation within the code itself, ensuring that the functionality of smart contracts is easily understood by humans.

This is particularly helpful for other developers or auditors who need to review the contract’s functionality.

Think of comments in code as notes inside the vending machine explaining how it works.

For example, a note could say, If this coin is inserted, dispense a soda.

This is similar to how comments in Solidity help developers understand the purpose and function of each part of the contract, ensuring transparency and clarity.

While Solidity is powerful, it is not perfect.

The language has faced criticisms regarding its security flaws and design challenges.

Security properties in smart contracts are difficult to reason about, and automated tools for contract verification often miss critical violations or generate false positives.

The complexity of Solidity contracts makes them similar to complicated vending machines that require precise configuration to avoid failures.

Just as small mistakes in vending machine instructions can lead to faulty operations or be exploited (e.g., vending a free drink), a poorly written...

... Solidity contract can be vulnerable to hacks.

A famous example is the DAO hack of 2016, where Solidity’s vulnerabilities were exploited, resulting in a loss of millions of dollars.

Design Challenges and Learning Curve

Solidity's syntax, while familiar to JavaScript developers, can still be confusing for beginners.

The language’s rigid structure and the need for additional tools make it challenging, especially when dealing with complex blockchain-specific tasks.

Idea limit reached 🥲. Access the full ideas here➡️ Telegra.ph link

Thank you 🙏 😅