Learning Solidity, in Public
Tags: solidity, ethereum, blockchain, tutorial
Published: 2021-05-23 16:22:11

A couple of weeks ago, I finished reading [The Sovereign Individual](https://www.nateliason.com/notes/sovereign-individual). Written in the late 90s, it talks about the ground-breaking changes that are coming to our society. Things like the Internet and computer technology will radically change our societies.

What struck me most profoundly, was the fact that the authors predicted blockchains. Of course, I am not talking about the technology, but rather the principle. They predicted the coming of permissionless, decentralized exchange of information and value.

After finishing the book, I had quite a few things to reflect upon. The most important question was about my place in a world where winner-takes-all effects are becoming the norm. I concluded, amongst other things, that I had to give the whole blockchain domain a second chance. The first chance was back in 2017-2018, when I invested time researching not-so-great[ blockchain projects.](https://scholar.google.gr/citations?user=LFNHtTgAAAAJ&hl=en)

Being familiar with the basic principles of blockchain, I opted to start with a practical aspect of the space. After consuming a couple of books and podcasts, Solidity seemed the obvious start. It is one of the first languages for running on a general application blockchain. That blockchain is [Ethereum](https://en.wikipedia.org/wiki/Ethereum). In Solidity, you create programs that run on the Ethereum blockchain itself. That means that these __smart contracts, __as we called them, run on [ethereum full node](https://ethereum.org/en/developers/docs/nodes-and-clients/).

The language is [Turing-complete](https://simple.wikipedia.org/wiki/Turing_complete#:~:text=Turing%20complete%20is%20a%20term,programming%20languages%20are%20Turing%2Dcomplete.), so we can write programs about a great number of use-cases. From running decentralized exchanges ([dex](https://academy.binance.com/en/articles/what-is-a-decentralized-exchange-dex)), to defining the rules of an organization ([DAO](https://academy.binance.com/en/articles/decentralized-autonomous-organizations-daos-explained)). Once we launch these programs on the blockchain, it is impossible for others to censor or stop them.  These "decentralized applications" run on **every **Ethereum miner node.

Let's take a moment to reflect on this unique characteristic.

We can define a system, where: 
- the inner workings of the system are completely transparent 
- everyone abides by a pre-defined set of rules
- all the rules are visible to everyone and known from the start 

Moreover, the smart-contract code is open-source by default. This is because nobody will take part in a system that hasn't shared the source code. Once the source code is shared, it is trivial to verify it.

This means that we have a groundbreaking way to create software and design systems. A way that is open source and fair, with limited asymmetry of information (no hidden rules).

[Naval Ravikant](https://twitter.com/naval), also known as the philosopher investor, has said about Ethereum:

> So if Bitcoin is a shared ledger, then Ethereum is a shared computer for the entire world to run its most important applications. [Source](https://tim.blog/2021/03/09/vitalik-buterin-naval-ravikant-transcript/)

## Perspective

With that in mind, one can see why people are falling in love with Ethereum and Solidity. It is true though, that there are limitations (e.g the Network can support up to [20 transactions/second](https://blockchair.com/ethereum/charts/transactions-per-second)). Currently, there are many interesting projects,  such as DeFi (Decentralized Finance). DeFi is one of the few use-cases that actually make sense to use a blockchain. Always remember that a blockchain is a very expensive way for counter-parties to agree on something.

## Learning Solidity in Public

While learning Solidity, I decided to start another project, called [[Learning in Public intro post]]. In that project, I share my learnings about different subjects as I learn them.

Thus, I decided to share my learnings of Solidity.

Think about it. Why spend hours on the internet chasing down the same answers as I did?

Follow the guide that I have compiled and the insights will cover most of the questions that you may have. **The goal is to greatly accelerate your learning process**. Thus, it is not about creating original content, but rather curating the already available content. 

I will simply lay the material for you, as I did for myself.

## Outline 

### Insights from [Cryptozombies](https://cryptozombies.io/) Solidity path lesson 1-5
- `_variable` means that the variable is a function's argument. It's a convention to make the code more readable. 
- Storing a string in Memory vs Storage
- When to use memory keyword?
- uint variable types:
- Ethereum gas cost considerations.
- When defining a Solidity Struct you don't have to remember the order. There are different ways to call a specific attribute.
- What are events?
- String comparison
- Function Modifiers
- Internal Transactions
- Transactions vs Calls
- Function Visibility internal, external, public and private
- Interfaces
- calldata variable storage
- What is abi.encodepacked?
- Assert vs Require
- What is contract inheritance? 
- Import contract
- Security Considerations

📍 Sounds simple enough? Then, [Enter the rabbit hole](https://roamresearch.com/#/app/Symposium/page/_QiKXQKiD).