# CÓDIGO BRAZUCA ACADEMY - POLKADOT JOURNEY

- [Introduction to Coding Logic and Algorithms (24 hours)](#Introduction-to-Coding-Logic-and-Algorithms-24-hours)
- [Basic Data Structures](#Basic-Data-Structures)
- [Classic Algorithms](#Classic-Algorithms)
- [Advanced Algorithms](#Advanced-Algorithms)
- [Problem-solving](#Problem-solving)
- [Java Script (48 Hours)](#Java-Script-48-Hours)
- [Introduction to JavaScript](#Introduction-to-JavaScript)
- [JavaScript Fundamentals](#JavaScript-Fundamentals)
- [Advanced JavaScript Concepts](#Advanced-JavaScript-Concepts)
- [Web Development with JavaScript](#Web-Development-with-JavaScript)
- [Client-Side Web Development Frameworks](#Client-Side-Web-Development-Frameworks)
- [Modern JavaScript Features](#Modern-JavaScript-Features)
- [Advanced Web Development Techniques](#Advanced-Web-Development-Techniques)
- [Final Project](#Final-Project)
- [TypeScript (48 Hours)](#TypeScript-48-Hours)
- [Introduction to TypeScript](#Introduction-to-TypeScript)
- [TypeScript Features](#TypeScript-Features)
- [TypeScript Concepts](#TypeScript-Concepts)
- [TypeScript Techniques](#TypeScript-Techniques)
- [TypeScript and JavaScript Interoperability](#TypeScript-and-JavaScript-Interoperability)
- [Advanced TypeScript Topics](#Advanced-TypeScript-Topics)
- [Advanced TypeScript Projects](#Advanced-TypeScript-Projects)
- [Final Project](#Final-Project)
- [Web3 (48 hours)](#Web3-48-hours)
- [Economics](#Economics)
- [Introduction to Blockchain](#Introduction-to-Blockchain)
- [Blockchain Fundamentals](#Blockchain-Fundamentals)
- [Web3 Development Tools and Libraries](#Web3-Development-Tools-and-Libraries)
- [Drex](#Drex)
- [Final Project](#Final-Project)
- [Introduction To Polkadot Ecosystem (8 Hours)](#Introduction-To-Polkadot-Ecosystem-8-Hours)
- [What is Polkadot?](#What-is-Polkadot)
- [Practical](#Practical)
- [Tech Stack](#Tech-Stack)
- [Polkadot Infrastructure & Tooling (48 Hours)](#Polkadot-Infrastructure-&-Tooling-48-Hours)
- [Linux for Blockchains Setup](#Linux-for-Blockchains-Setup)
- [Building a local Blockchain](#Building-a-local-Blockchain)
- [Tooling](#Tooling)
- [Getting Started with Substrate](#Getting-Started-with-Substrate)
- [Build a Parachain](#Build-a-Parachain)
- [Final project](#Final-project)
- [Rust I (96 hours)](#Rust-I-96-hours)
- [Introduction to Rust and Development Environment](#Introduction-to-Rust-and-Development-Environment)
- [Basic Rust Concepts](#Basic-Rust-Concepts)
- [Ownership and References](#Ownership-and-References)
- [Basic Data Structures](#Basic-Data-Structures)
- [Enums and Pattern Matching](#Enums-and-Pattern-Matching)
- [Error Handling](#Error-Handling)
- [Programming in Rust](#Programming-in-Rust)
- [Basic Concurrency](#Basic-Concurrency)
- [File Handling and Input/Output](#File-Handling-and-Input/Output)
- [Object-Oriented Programming in Rust](#Object-Oriented-Programming-in-Rust)
- [Safe and Efficient Programming](#Safe-and-Efficient-Programming)
- [Rust for Command Line Application (CLI) Development](#Rust-for-Command-Line-Application-(CLI)-Development)
- [Testing and Documentation](#Testing-and-Documentation)
- [Package Publishing and Dependency Management](#Package-Publishing-and-Dependency-Management)
- [Rust and Performance](#Rust-and-Performance)
- [Integration with Other Languages](#Integration-with-Other-Languages)
- [Final Project](#Final-Project)
- [Rust II - Advanced Rust (64 Hours)](#Rust-II---Advanced-Rust-64-Hours)
- [Rust for Parallel and Distributed Computing](#Rust-for-Parallel-and-Distributed-Computing)
- [Advanced Concurrency](#Advanced-Concurrency)
- [Advanced Traits and Generics](#Advanced-Traits-and-Generics)
- [Metaprogramming with Macros](#Metaprogramming-with-Macros)
- [Advanced Error Handling](#Advanced-Error-Handling)
- [Advanced I/O and Asynchronous Programming](#Advanced-IO-and-Asynchronous-Programming)
- [Unsafe Rust](#Unsafe-Rust)
- [Advanced Testing and Benchmarking](#Advanced-Testing-and-Benchmarking)
- [Final Project](#Final-Project)
- [Sustrate/Polkadot SDK I (60 hours)](#Sustrate/Polkadot-SDK-I-60-hours)
- [Introduction to Blockchain Development and Substrate](#Introduction-to-Blockchain-Development-and-Substrate)
- [Substrate Runtime Development](#Substrate-Runtime-Development)
- [Customizing Substrate Chains](#Customizing-Substrate-Chains)
- [Substrate Networking and Consensus](#Substrate-Networking-and-Consensus)
- [Substrate Frontend Development](#Substrate-Frontend-Development)
- [Governance and Upgrades](#Governance-and-Upgrades)
- [Substrate Ecosystem and Community](#Substrate-Ecosystem-and-Community)
- [Substrate/Polkadot SDK II (40 hours)](#Substrate/Polkadot-SDK-II-40-hours)
- [Building and Deploying a Real-World Substrate Project](#Building-and-Deploying-a-Real-World-Substrate-Project)
- [Final Project](#Final-Project)

## Introduction to Coding Logic and Algorithms (24 hours)
- Definition of an algorithm
- Importance of algorithms in computerscience
- Characteristics of good algorithms
### Basic Data Structures
- Arrays and lists
- Stacks and queues
- Trees and graphs
- Hash tables
### Classic Algorithms
- Binary search
- Quicksort
- Insertion sort
- Dijkstra’s algorithm for shortest path
- Kruskal’s algorithm for minimum spanning tree
### Advanced Algorithms
- Backtracking algorithms
- Maximum flow algorithms
- Pattern matching algorithms
- Probabilistic algorithms
### Problem-solving
- Implementation of algorithms in popular programming languages
- Project development using learned algorithms

## Java Script (48 Hours)
### Introduction to JavaScript
- Understanding the basics of JavaScript: history, purpose, and features.
- Setting up the development environment: Nodejs and nvm
- Writing your first JavaScript code:
- Exploring JavaScript in the browser: DOM manipulation and event handling.

### JavaScript Fundamentals
- Control flow and loops: if statements, switch statements, and loops (for, while, do-while).
- Functions in JavaScript: declaration, parameters, return values, and scope.
- Understanding arrays: creating, accessing, and manipulating arrays.
- Working with objects: object literals, properties, methods, and constructors.

### Advanced JavaScript Concepts
- Closures and lexical scope
- Prototypes and inheritance
- Asynchronous JavaScript: callbacks, promises, and async/await for handling asynchronous operations.
- Error handling in JavaScript
- Most common pitfalls in async error handling

### Web Development with JavaScript
- Introduction to HTML and CSS
- Manipulating the DOM
- Event delegation and bubbling
- Introduction to AJAX and Fetch API: making synchronous requests to fetch data from a server.

### Client-Side Web Development Frameworks
- Introduction to popular JavaScript frameworks/libraries: React, Svelte, Angular and Vue.js.
- Setting up a project with React: creating components, state management, and routing.
- Exploring Angular: components, modules, services, and dependency injection.
- Vue.js fundamentals: data binding, directives, and computed properties.

### Modern JavaScript Features
- ES6 and beyond: arrow functions, template literals, destructuring, spread/rest operators, and classes.
- Modules in JavaScript: importing and exporting modules using ES6 module syntax.
- Working with the Document Object Model (DOM) API
- Introduction to Web APIs: Geolocation API, Local Storage API, and Fetch API.

### Advanced Web Development Techniques
- Responsive web design: media queries and flexbox for creating responsive layouts.
- Introduction to CSS preprocessors: Sass and Less for writing efficient CSS code.
- Tailwind and styled components.
- Building interactive web applications: implementing form validation and client-side form submission.
- Optimizing web performance: minimizing render-blocking resources, lazy loading, and code splitting.

### Final Project
Assestment exam

## TypeScript (48 Hours)
### Introduction to TypeScript
- history, features, and benefits.
- Setting up the development environment: tsserver
- TypeScript basics: syntax, variables, data types, and type annotations.

### TypeScript Features
- Functions in TypeScript: parameters, return types, arrow functions, optional and default parameters.
- TypeScript Enums: defining and using enums, string enums, enums with associated values.
- TypeScript Interfaces: defining interfaces, optional properties, readonly properties, index signatures.

### TypeScript Concepts
- Generics in TypeScript: understanding generics, generic functions, generic classes, and constraints.
- Advanced type manipulation: union types, intersection types, type guards, discriminated unions.
- Working with Modules: importing and exporting modules, namespace vs. module, ambient modules.

### TypeScript Techniques
- Type inference and type compatibility: understanding how TypeScript infers types and enforces type compatibility.
- Advanced error handling with TypeScript: nullable types, strict null checks, handling null and undefined.
- Asynchronous programming with TypeScript: async/await syntax, promises with TypeScript, error handling in async functions.
- Functional vs object-oriented programming

### TypeScript and JavaScript Interoperability
- Using JavaScript libraries with TypeScript: typings, declaration files, and type definitions.
- Introduction to TypeScript decorators: class decorators, method decorators, property decorators.
- Migrating existing JavaScript codebases to TypeScript: gradual adoption, refactoring strategies, and best practices.

### Advanced TypeScript Topics
- Advanced TypeScript tooling and ecosystem: frameworks for testing, development, linting, and deploying.
- TypeScript compiler options, tsconfig.json, custom transformers.
- Exploring advanced TypeScript features and experimental proposals: conditional types, template literal types, etc.

### Advanced TypeScript Projects
- Working on advanced TypeScript projects: building real-world applications, implementing complex features.
- Code reviews and feedback sessions: reviewing and providing feedback on peers’ projects.
- Assessing the understanding and proficiency of students in TypeScript concepts and techniques.

### Final Project
- Assestment exam

## Web3 (48 hours)
- Introduction to Web3
- Evolution from Web 1.0 to Web 3.0
- Key concepts: decentralization, blockchain, smart contracts, and decentralized applications (dApps)

### Economics
- The evolution of Money
- 1929 Crisis
- Bretton Woods System
- 1971 Dollar Transition
- 1973 Oil Crises
- 2008 Crisis
- Bitcoin

### Introduction to Blockchain
- Origins
- Key Concepts
- How a Blockchain Works
- Basic concepts
- Centralized Systems x Decentralized Systens
- Types of Blockchain
- Blockchain Trillema
- Blockchain Layers
- Consensus Algorithms (POW, POS, BFT, POA)
- Hash
- Ledger
- Wallet
- Nodes
- Mainnet and Testnets
- Forks
- Blockchain Explorers
- Bitcoin Blockchain
- Introduction to Ethereum blockchain
- Ethereum Virtual Machine (EVM)
- Solidity and smart contracts
- Deploying a Token in a EVM blockchain

### Blockchain Fundamentals
- Understanding transactions, blocks, and the distributed ledger
- Decentralized Applications (dApps)
- Overview of decentralized application architecture
- Most relevant dapps
- Decentralized Finance (DeFi)
- Overview of DeFi protocols and applications
- Decentralized exchanges (DEX), lending, platforms, and yield farming, Non-Fungible Tokens (NFTs)
- Introduction to NFTs and their use cases
- Creating and trading NFTs on Ethereum and other blockchain platforms
- Standards such as ERC-721 and ERC-1155 Decentralized Identity and Governance
- Self-sovereign identity and decentralized identity solutions
- Decentralized autonomous organizations (DAOs) and their governance mechanisms
- Voting mechanisms and decentralized decision-making processes

### Web3 Development Tools and Libraries
- Introduction to Truffle Suite, Remix, and Hardhat
- Web3.js and ethers.js: libraries for interacting with Ethereum and other blockchains
- IPFS (InterPlanetary File System) and its role in decentralized web development

### Drex
- What is it?
- Importance of Drex
- Implementations
- Brazil and Drex

### Final Project
- Assestment exam

## Introduction To Polkadot Ecossystem (8 Hours)

### What is Polkadot?
- Origins
- The DOT token
- Governance (Gov1 and OpenGov)
- Community
- Archicture
- Relay Chains
- Parachains and Parathreads
- Bridges
- XCM
- Validators
- Nominators
- Collators

### Practical
- Wallet
- Creating an account
- Testnets
- Faucets

### Tech Stack
- Dev Tools
- Polkadot API
- Tooling
- Telemetry
- Rust
- Substrate

## Polkadot Infrastructure & Tooling (48 Hours)

### Linux for Blockchains Setup
- Preparing the enviroment
- Good Practices
- Docker x Local Enviroment

### Building a local Blockchain
- Type of Nodes
- Setup a substrate node template
- Starting a Local Network
- Add Trusted Nodes
- Prometheus
- Zombienets

### Tooling
- How to use Polkadot JS Apps
- Querying chain state through the UI
- Signing extrinsics through the UI
- Polkadot API
- Queries using TypeScript
- Decoding results and mapping types
- Signing extrinsics using TypeScript
- Using Chopsticks

### Getting Started with Substrate
- Anatomy of a Substrate blockchain: runtime, consensus, and networking
- Building your first Substrate blockchain using the Substrate Node Template
- Compiling, running, and interacting with a Substrate node

### Build a Parachain
- Setup a relay chain
- Connect a local parachain
- Acquire a testnet slot
- Operations

### Final project
- Assestment exam
- Creating An Archive Node in the wild

## Rust I (96 hours)

### Introduction to Rust and Development Environment
- Introduction to Rust: history, features, and usage.
- Rust installation and development environment setup.
- Hello World in Rust: writing and running the first program.

### Basic Rust Concepts
- Variables, constants, and data types in Rust.
- Operators and expressions.
- Control flow: if, else, loops, match.
- Working with functions: definition, parameters, return, and scope.

### Ownership and References
- Ownership and borrowing.
- References and mutability.
- Slices in Rust.

### Basic Data Structures
- Vectors and slices.
- Strings in Rust.
- Working with tuples and structs.

### Enums and Pattern Matching
- Defining and using enums.
- Pattern matching in Rust.

### Error Handling
- Error handling in Rust: Result and Option.
- Throwing and catching errors with Result and Option.

### Programming in Rust
- Higher-order functions.
- Iterators and functional programming.
- Closures in Rust.

### Basic Concurrency
- Introduction to concurrency in Rust.
- Threads and basic concurrency.
- Communication between threads using channels.

### File Handling and Input/Output
- Reading and writing files in Rust.
- Working with stdin/stdout.
- Handling input/output errors.

### Object-Oriented Programming in Rust
- Basic object-oriented programming concepts in Rust.
- Defining methods in structs.
- Traits in Rust.

### Safe and Efficient Programming
- Basic security in Rust.
- Memory management without garbage collection.
- Safe usage of pointers and references.

### Rust for Command Line Application (CLI) Development
- Developing command line applications in Rust.
- Command line arguments and CLI parsing.
- Useful packages and tools for CLI development in Rust.
- Working with the standard error system.

### Testing and Documentation
- Writing unit tests and integration tests in Rust.
- Documentation in Rust using Rustdoc.
- Best practices for testing and documentation in Rust.

### Package Publishing and Dependency Management
- Preparing a Rust project for publication.
- Using Cargo to manage dependencies.
- Publishing packages on crates.io.

### Rust and Performance
- Code optimization in Rust.
- Profiling tools in Rust.
- Strategies for improving code performance in Rust.

### Integration with Other Languages
- Integrating Rust with other programming languages.
- Rust as a language extension for other languages.

### Final Project
- Practical Project I
- Practical Project II

## Rust II - Advanced Rust (64 Hours)
Rust for Parallel and Distributed Computing
- Parallel and distributed computing in Rust.
- Libraries and tools for parallel and distributed programming in Rust.

### Advanced Concurrency
- Advanced multi-threading with the `std::sync` module
- Concurrent data structures: `Mutex`, `RwLock`, `Atomic`
- Async/await syntax and programming with `async`/`await` in Rust

### Advanced Traits and Generics
- Associated types and default type parameters
- Higher-kinded types and trait objects
- Implementing advanced trait bounds and constraints

### Metaprogramming with Macros
- Procedural macros: `derive`, `attribute`, and
`function-like` macros
- Implementing custom procedural macros
- Advanced macro use cases and best practices

### Advanced Error Handling
- Custom error types and error chaining
- Advanced use of `Result` and `Option`
- Error handling patterns in complex applications

### Advanced I/O and Asynchronous Programming
- Advanced file I/O with `tokio` and `async-std`
- Building network services with asynchronous programming
- Integrating asynchronous programming with existing synchronous code

### Unsafe Rust
- Understanding `unsafe` blocks and operations
- Interfacing with C code using `unsafe`
- Writing safe abstractions around unsafe code

### Advanced Testing and Benchmarking
- Property-based testing with `proptest`
- Benchmarking with `criterion`
- Fuzz testing and improving code robustness

### Final Project

## Sustrate/Polkadot SDK I (60 hours)
### Introduction to Blockchain Development and Substrate
- Understanding blockchain technology and its applications
- Introduction to Substrate: features, benefits, and use cases
- Setting up the development environment for Substrate

### Substrate Runtime Development
- Understanding the Substrate runtime: FRAME, pallets, and storage
- Writing custom pallets for your Substrate runtime
- Testing and debugging custom pallets using Substrate’s development tools

### Customizing Substrate Chains
- Configuring and customizing the Substrate Node Template
- Adding custom features and functionalities to your Substrate chain
- Building and deploying a customized Substrate chain

### Substrate Networking and Consensus
- Understanding Substrate networking: roles, peers, and protocols
- Customizing networking behavior in a Substrate node
- Exploring different consensus mechanisms in Substrate

### Substrate Frontend Development
- Introduction to Substrate Frontend Development using Polkadot.js
- Building a simple frontend application to interact with a Substrate chain
- Integrating custom UI components with a Substrate chain

### Governance and Upgrades
- Understanding Substrate governance: council, voting, and proposals
- Managing chain upgrades and runtime upgrades in Substrate
- Implementing on-chain governance mechanisms in a Substrate chain

### Substrate Ecosystem and Community
- Exploring the Substrate ecosystem: parachains, bridges, and interoperability
- Engaging with the Substrate community: forums, events, and resources
- Contributing to the Substrate ecosystem: projects, libraries, and documentation

## Substrate/Polkadot SDK II (40 hours)
### Building and Deploying a Real-World Substrate Project
- Working on a real-world Substrate project from start to finish
- Collaborative project work, code reviews, and feedback sessions

### Final Project
- Deploying the final project on a testnet
- Assestment exam