Weeks 1–2: Rust Foundation (Both Tracks)
- Variable declaration and type inference
- Integer, float, boolean, char types
- Type annotations and conversion
- Mutability and constants
- Functions, parameters, return values
- if, else, match expressions
- for, while, loop constructs
- Control flow patterns
- Vectors: creation and manipulation
- Iterators and their methods
- Tuples and arrays
- HashMaps and their usage
- Ownership rules and scope
- Memory safety principles
- References and borrowing
- Understanding lifetimes
- Custom struct definitions
- Enum variants and data
- Pattern matching techniques
- Method implementations
- Trait definitions and implementations
- Generic types and functions
- Trait bounds and constraints
- Code reusability patterns
- Result and Option types
- Error propagation
- Custom error types
- Error handling patterns
- File reading and writing
- Directory manipulation
- Path handling
- File system operations
- Unit test structure
- Integration tests
- Test organization
- Mocking and test helpers
Weeks 3–4: Track A — Backend with Rust
- Introduction to HTTP & Hyper
- HTTP protocol essentials
- Hyper framework core concepts
- Building simple HTTP server
- Basic request/response flow
- Routing & Request Handling
- Route definitions
- HTTP methods implementation
- Parameter handling
- Response construction
- Request logging
- Authentication flows
- Middleware chain setup
- Error middleware
- Custom error types
- Logging implementation
- Error response handling
- Debugging strategies
- Tokio runtime basics
- Async/await patterns
- Backend benchmarking
- Framework comparisons
- Version management
- Integration tests
- API documentation
- Testing patterns
- SQL fundamentals
- PostgreSQL basics
- Database design
- Admin tool usage
- ORM setup
- Model definitions
- Basic CRUD
- Entity relationships
- Advanced Database Operations
- Complex queries
- Relationship mapping
- Transaction handling
- Query optimization
- JWT implementation
- Authorization flows
- Token management
- Security patterns
- Pagination setup
- Index management
- Query performance
- Monitoring setup
- Docker setup
- Environment config
- Deploy strategies
- Production readiness
Weeks 3–4: Track B — Solana with Rust
- Account model: owner, lamports, data, executable
- Rent and account lifecycle
- Transaction anatomy: instructions, signers, blockhash
- Program deployment and upgrades
- Workspace setup, project structure
- declare_id!, #[program], Context<T>
- Basic account constraints: init, mut, Signer
- Build and deploy first Anchor program
- PDAs & Advanced Constraints
- PDA derivation, bump seeds, canonical bumps
- Constraints: seeds, bump, has_one, constraint, close
- Account discriminators, space calculation
- Zero-copy accounts for large state
- Token Program: mint, token account, authority
- Associated Token Accounts
- CPI mechanics: CpiContext, signer seeds
- Build token vault with deposit/withdraw
- Missing signer checks, reinitialization attacks
- PDA collisions, arithmetic overflow
- Anchor protections vs manual checks
- Audit and patch vulnerable programs
- Token Vaults & Share Accounting
- Proportional shares: deposit/withdraw math
- Fee models and yield accrual patterns
- Share token minting and burning
- Implement vault with share tokens
- AMM Design & Implementation
- Constant product invariant (x * y = k)
- Swap math, price impact, slippage
- Add/remove liquidity, LP tokens
- Impermanent loss, concentrated liquidity
- Staking & Reward Distribution
- Staking pool architecture
- Reward-per-token math (Synthetix model)
- Time-weighted accrual, claim mechanics
- Lockups, multipliers, vesting patterns
- Lending Protocol Architecture
- Collateralization ratios, health factors
- Interest rate models (utilization curves)
- Liquidation mechanics
- Build mini lending market
- eBPF origins: Linux kernel, tracing, networking
- Solana sBPF: constraints, stack limits
- BPF instruction set, registers, memory regions
- Syscalls