# Blockchain development roadmap
Like in many sub-domains in computer science and software engineering, there are usually two ways to approach learning: bottom-up or top-down (and, of course, a mix of the two).
Bottom-up, or what I'm calling here, the foundational approach (or first-principles approach) is all about first understanding the foundational science and engineering that lies at the bottom (i.e. the foundation) of a certain topic.
The top-down I see more as a hands-on / practical approach, where one starts by _using_ higher-level abstractions and constructs in a certain topic, then start drilling down to understand more foundational aspects.
For example, consider a traditional web2 development domain. In the foundational approach one could:
1. Learn how computers work at a low-level abstraction
2. Digital circuits design and organization;
3. Computer organization in general: storage disks, memory, CPU, ALU, registers, etc;
4. Assembly languages;
5. "Low-level" programming languages such as C and how it ties back to assembly. Manual memory management, binary data encoding, etc;
2. Learn foundational ideas in computer science
1. Classic algorithms design and implementation;
2. Computational complexity, halting problem, etc;
3. Learn how operating systems work, especially around threads, processes, inter-process communication, sockets;
4. Learn about computer networks and protocols: TCP, IP, UDP, HTTP;
5. Learn how to build web servers that will operate over HTTP;
6. Learn basics software engineering principles;
7. With all that in hands, learn how it all ties together when using modern programming languages (e.g. Node JS, Go, Rust) with their respective web development abstractions and building interfaces with HTML, CSS, client-side JS. At this point, one would have a solid understanding of what's going on below the web development's abstractions and be able to build products using this paradigm.
On the other hand, the top-down approach would be similar to the list above, but instead of going 1 through 7, it would be the opposite: 7 through 1. With the big difference that, when starting at the highest layer, 7, one wouldn't have any understanding of what's going on below... and that's fine in some contexts!
There are clear advantages and disadvantages between the two approaches and there are many advocates for one or the other. In my experience, both are valid approaches, but one will be better than the other depending on one's circumstances and personal preferences.
Why go with the top-down approach first:
- You may find boring or demotivating to focus too much on theoretical aspects of a domain without getting your hands dirty;
- You may need to learn how to do X quickly to be productive in a company and only _later_ learn the details;
- You just don't care about the details, just wanna get shit done;
Why go with the bottom-up, foundational approach first:
- You wanna have a deeper understanding of what's going on underneath, which will help you, when, say debugging something that requires understanding of how HTTP-based network calls work, or some core-dump in hex showed up and you need to understand why, or why you need a consensus mechanism when storing data across multiple nodes, or why you may want mutexes when sharing data across threads (after spending a whole week trying to figure out a weird bug that now you know it's a data race);
- You have both the time and energy to take it slow. This approach is definitely slower at the beginning, but the compounded results are huge later.
I'm a big fan of the foundational approach, but sometimes I just have to go top-down. Sometimes I go both ways: top-down quickly enough to be productive, bottom-up when I have more time to understand things at a slower pace.
If you have the time and energy, I recommend the bottom-up approach. Otherwise, top-down. That's usually my rule of thumb.
Unsurprisingly, the same applies to Web3, cryptocurrency, and blockchain development. Don't even get me started on how vague the term Web3 is, but for all intents and purposes, let's just assume it's building web-based products with smart contracts and blockchains at the foundation.
## The foundational approach
The foundational approach here assumes that you have a solid foundational understanding of what comes before blockchain: computers, programming, and computer science in general.
This approach is all about understanding what blockchains are and why they're so goddamn amazing and revolutionary from a computer science perspective.
To understand this, you have to understand all these other sub-domains needed by blockchains: some data structures (e.g. merkle trees), some cryptography, and some distributed systems theory.
At the end of the day, _blockchains_ are nothing more than a data structure with some fancy cryptography. _Blockchain "the Technological Platform"_, goes way, way beyond that, including slapping a whole freaking virtual machine inside _blockchains_, turning _blockchains_ into an actual computer that trades-off speed for trust, and these virtual machines (e.g. EVM) running inside blockchains are programmable using what we (mis)call smart contracts, which are neither smart nor contracts. Just think of them as regular programs written in a special programming language.
1. Foundation
1. Merkle trees, core data structure used across blockchain
1. [Merkle trees original paper](http://www.merkle.com/papers/Protocols.pdf)
2. [A certified digital signature](http://www.merkle.com/papers/Certified1979.pdf)
3. [1994, Nick Szabo on Smart Contracts](https://www.fon.hum.uva.nl/rob/Courses/InformationInSpeech/CDROM/Literature/LOTwinterschool2006/szabo.best.vwh.net/smart.contracts.html)
4. [Understanding merkle trees](https://www.codeproject.com/Articles/1176140/Understanding-Merkle-Trees-Why-use-them-who-uses-t)
5. Digital signatures and related cryptographic techniques
1. [Chaum anonymous communication](http://www.lix.polytechnique.fr/~tomc/P2P/Papers/Theory/MIXes.pdf)
2. [Security without identification: transaction systems to make big brother obsolete](https://www.cs.ru.nl/~jhh/pub/secsem/chaum1985bigbrother.pdf)
3. [Zero knowledge proofs: an illustrated primer](https://blog.cryptographyengineering.com/2014/11/27/zero-knowledge-proofs-illustrated-primer/)
4. One of the best video-based resources out there: [Foundations of Blockchain course](https://www.youtube.com/playlist?list=PLEGCF-WLh2RLOHv_xUGLqRts_9JxrckiA)
2. Consensus
1. Byzantine generals problem
1. [Leslie's paper on BGP](https://lamport.azurewebsites.net/pubs/byz.pdf)
2. [Practical Byzantine generals algorithm](https://pmg.csail.mit.edu/papers/osdi99.pdf)
2. Classical distributed system result: [Paxos](https://lamport.azurewebsites.net/pubs/paxos-simple.pdf)
3. [Tendermint: Consensus without mining](https://tendermint.com/static/docs/tendermint.pdf)
4. [Consensus in the age of blockchain](https://arxiv.org/pdf/1711.03936.pdf)
3. Bitcoin and proof-of-work. Biggest breakthrough on solving the Byzantine generals problem with all its gnarly details (double spending):
1. [Bitcoin paper](https://bitcoin.org/bitcoin.pdf)
2. [Bitcoin's academic pedigree](https://queue.acm.org/detail.cfm?id=3136559)
3. [The sybil attack](https://www.freehaven.net/anonbib/cache/sybil.pdf)
4. Ethereum, building on top of Bitcoin's work by adding smart contracts and more
1. [Ethereum paper](https://ethereum.org/en/whitepaper/)
2. [Arbitrum](https://www.usenix.org/system/files/conference/usenixsecurity18/sec18-kalodner.pdf)
5. Blockchain scalability. Blockchains up to this point are slow, surprise surprise!
1. [Building Scalable Decentralized Payment Systems](https://arxiv.org/pdf/1904.06441.pdf)
2. [Ethereum smart contracts in L2: Optimistic Rollup](https://medium.com/plasma-group/ethereum-smart-contracts-in-l2-optimistic-rollup-2c1cef2ec537)
3. [Overview of layer 2 approaches](https://near.org/blog/layer-2/)
4. [Almost everything you need to know about optimistic rollup](https://research.paradigm.xyz/rollups)
6. Fraud proofs
1. [Fraud and Data Availability Proofs: Maximizing Light Client Security and Scaling Blockchains with Dishonest Majorities](https://arxiv.org/pdf/1809.09044.pdf)
7. Philosophy
1. [Why decentralization matters](https://onezero.medium.com/why-decentralization-matters-5e3f79f7638e)
2. [Control as liability](https://vitalik.ca/general/2019/05/09/control_as_liability.html)
3. [The meaning of decentralization](https://medium.com/@VitalikButerin/the-meaning-of-decentralization-a0c92b76a274)
4. [Crypto reading list](https://danromero.org/crypto-reading/)
Nice overview of bitcoin and cryptocurrencies: https://www.youtube.com/playlist?list=PLUl4u3cNGP63UUkfL0onkxF6MYgVa04Fn
More lists:
- https://thecontrol.co/crypto-reading-list-c54da8cab26a
- https://github.com/decrypto-org/blockchain-papers
- [Foundations of Blockchain](https://www.youtube.com/playlist?list=PLEGCF-WLh2RLOHv_xUGLqRts_9JxrckiA)
## The top-down, dApp development approach (solidity focused)
dApp == decentralized app. This approach is similar to learning traditional web development by learning a web framework and some client-side JS, CSS, HTML.
Solidity is the language used to write smart contracts, which will live inside the Ethereum blockchain. Then you're gonna use something like [ethers.js](https://docs.ethers.io/v5/getting-started/) in your frontend to interact with the contracts that were deployed to Ethereum using something like [hardhat](https://hardhat.org/) or [Foundry](https://github.com/foundry-rs/foundry).
If you start here, you may be able to build decentralized apps on a blockchain, but you'll have no idea how the underlying blockchain tech works. And that's probably fine depending on your goals.
1. [Solidity, Blockchain, and Smart Contract Course – Beginner to Expert Python Tutorial](https://www.youtube.com/watch?v=M576WGiDBdQ&ab_channel=freeCodeCamp.org)
2. [MASTER Solidity for Blockchain Step-By-Step (Full Course)](https://www.youtube.com/watch?v=YJ-D1RMI0T0&t=17s&ab_channel=DappUniversity)
3. [Cryptozombies course](https://cryptozombies.io/)
4. [The complete guide to full stack ethereum development](https://www.youtube.com/watch?v=a0osIaAOFSE&ab_channel=NaderDabit)
Sign in with Wallet
Connect another wallet