Skip to content

Programming

258 topics

Writing code step by step: Python, C++, JavaScript, SQL and more. All topics of the subject on YourAIZone. Open a topic to read the beginning of the lesson.

Grade 3 3 topics

  1. Why Learn to Code? What Programmers Do
  2. What Is a Computer?
  3. Computers Are Literal: Being Clear and Precise

Programming Foundations 25 topics

  1. What Is a Program?
  2. What Is a Programming Language?
  3. Algorithms: Step-by-Step Thinking
  4. Sequencing and Program Flow
  5. Block-Based Coding: Your First Program Without Typing
  6. Staying Safe and Kind Online as a Young Coder
  7. Variables: Storing Information
  8. Making Decisions: Conditions
  9. Repetition: Loops
  10. Events: When Something Happens, Do Something
  11. Input and Output
  12. Comments: Leaving Notes in Your Code
  13. Bugs and Debugging
  14. Reading and Understanding Error Messages
  15. Putting It Together: Combining the Building Blocks
  16. How Code Becomes a Running Program
  17. Data Types and Values
  18. Introduction to Functions
  19. Binary: How Computers Store Data
  20. Introduction to Data Structures
  21. Problem Decomposition and Pseudocode
  22. What Makes Code Good? Readability and Style
  23. Introduction to Version Control (Git)
  24. Algorithmic Efficiency: Fast vs Slow
  25. What Is Next: Your Programming Journey

Python 23 topics

  1. Getting Started with Python: Your First Program
  2. Variables and Data Types in Python
  3. Numbers and Arithmetic
  4. Getting Input from the User
  5. Comments and Readable Code in Python
  6. Working with Text (Strings)
  7. Making Decisions: if / elif / else
  8. Loops: for and while
  9. Finding and Fixing Mistakes in Python
  10. Lists
  11. Dictionaries and Sets
  12. Functions in Python
  13. Handling Errors (try / except)
  14. Working with Files
  15. Modules and the Standard Library
  16. Introduction to Object-Oriented Python
  17. Building a Small Project: Quiz Game
  18. Python for Data: First Steps
  19. Tuples and Unpacking
  20. Mastering Text Formatting with f-strings
  21. Randomness and Chance: The random Module
  22. Drawing with Code: Turtle Graphics
  23. Building a Text Adventure Game

Python — Intermediate 26 topics

  1. Setting Up: Virtual Environments and pip
  2. List, Dict and Set Comprehensions
  3. Functions Deep Dive: *args, **kwargs, defaults
  4. Lambda, map, filter, reduce
  5. Iterators and Generators
  6. Decorators
  7. Object-Oriented Python: Inheritance and super()
  8. Magic (Dunder) Methods
  9. Properties and Encapsulation
  10. Exceptions in Depth
  11. Working with JSON and CSV
  12. Regular Expressions
  13. Dates and Times
  14. Modules and Packages
  15. Unit Testing with pytest
  16. Calling Web APIs with requests
  17. Intermediate Project: CLI Task Manager
  18. Logging
  19. Working with Paths and the Filesystem
  20. Command-Line Arguments and Building CLI Tools
  21. The collections Module
  22. Enumerations with enum
  23. Thinking Recursively: Recursion in Python
  24. Sorting, Searching, and Big-O Intuition
  25. Web Scraping with Beautiful Soup
  26. Building Desktop Apps with tkinter

Python — Advanced 22 topics

  1. Type Hints and Static Typing
  2. Dataclasses and namedtuples
  3. Context Managers
  4. Advanced Decorators
  5. Functional Programming Patterns
  6. Concurrency: Threads and the GIL
  7. Concurrency: Multiprocessing
  8. Asynchronous Python: asyncio
  9. Design Patterns in Python
  10. Metaclasses and ABCs
  11. Descriptors and Attribute Magic
  12. Performance and Profiling
  13. Packaging and Publishing
  14. Databases and ORMs
  15. The Data Stack: NumPy and pandas (overview)
  16. Advanced Project: Async API Service
  17. Testing in Depth: Mocking and Fixtures
  18. Mutability, Copying, and the Object Model
  19. Dynamic Programming and Memoization
  20. Memory Management and Garbage Collection
  21. Cryptography Basics: Hashing and Secure Randomness
  22. Network Programming with Sockets

C++ 20 topics

  1. Getting Started with C++: Your First Program
  2. Variables and Data Types in C++
  3. Input and Output with cin and cout
  4. Operators and Expressions
  5. Conditions: if / else / switch
  6. Loops: for, while, do-while
  7. Functions in C++
  8. Arrays and Strings
  9. Introduction to Pointers
  10. References and Dynamic Memory
  11. Introduction to OOP: Classes and Objects
  12. Inheritance and Polymorphism
  13. The Standard Template Library (STL)
  14. File Handling in C++
  15. Building a Console Project
  16. Recursion
  17. Debugging: Reading Compiler Errors and Fixing Bugs
  18. Doing Math in C++: The cmath Library and Number Pitfalls
  19. Searching and Sorting: Your First Algorithms
  20. Random Numbers, Dice and Games of Chance

C++ — Intermediate 22 topics

  1. References and const-correctness
  2. Function and Class Templates
  3. The STL Containers in Depth
  4. STL Algorithms and Iterators
  5. Operator Overloading
  6. Smart Pointers
  7. RAII and Resource Management
  8. Exceptions and Error Handling
  9. Namespaces and Code Organization
  10. Lambdas and Function Objects
  11. Enums, Structs and Unions
  12. Introduction to Move Semantics
  13. Header/Source Organization and Compilation
  14. Files and Streams in Depth
  15. Intermediate Project: A Small Library
  16. Copy Semantics and the Rule of Five
  17. Type Conversions and Casting
  18. Vocabulary Types: optional, variant and tuple
  19. Building Data Structures: Linked Lists, Stacks and Queues
  20. Testing Your Code: Unit Tests and Assertions
  21. Text Processing: Strings, Streams and Regular Expressions
  22. Working with Dates and Times: The chrono Library

C++ — Advanced 20 topics

  1. Move Semantics in Depth
  2. Perfect Forwarding
  3. Template Metaprogramming
  4. Variadic Templates
  5. SFINAE and Constraints
  6. Concepts (C++20)
  7. Multithreading
  8. Atomics and the Memory Model
  9. Async, Futures and Promises
  10. Custom Memory Management
  11. Design Patterns in C++
  12. Ranges and Views (C++20)
  13. Coroutines (C++20)
  14. Performance Optimization
  15. Advanced Project: A Generic Container
  16. Compile-Time Programming with constexpr
  17. Algorithmic Complexity and Dynamic Programming
  18. The Curiously Recurring Template Pattern (CRTP) and Static Polymorphism
  19. Type Erasure: std::function, std::any and Building Your Own
  20. Concurrency Patterns: Thread Pools and the Producer-Consumer Problem

Node.js 17 topics

  1. What Is Node.js? Running JavaScript Outside the Browser
  2. JavaScript Essentials for Node
  3. Your First Node Program and the REPL
  4. Modules and npm
  5. Asynchronous JavaScript: Callbacks, Promises, async/await
  6. Reading and Writing Files (fs module)
  7. Building a Simple Web Server
  8. Introduction to Express.js
  9. Working with JSON and APIs
  10. Connecting to a Database (Intro)
  11. Building a Small Web API Project
  12. Debugging Node.js Programs
  13. The Command Line and the process Object: Building a CLI
  14. Working with Text: Strings and Regular Expressions
  15. Numbers, Math, and Randomness: Building a Guessing Game
  16. Working with Dates and Times
  17. Build a To-Do List CLI with File Storage

Node.js — Intermediate 20 topics

  1. Express in Depth: Routing and Middleware
  2. Designing a RESTful API
  3. Databases: SQL with Node
  4. Databases: MongoDB and Mongoose
  5. Authentication with JWT
  6. Validation and Error Handling
  7. Environment Config and Secrets
  8. File Uploads and Serving Static Files
  9. Testing Node APIs
  10. Streams in Depth
  11. Events and the EventEmitter
  12. Consuming Third-party APIs
  13. Intermediate Project: A REST API with a Database
  14. How Node.js Works: The Event Loop and Non-Blocking I/O
  15. Authorization and Access Control (RBAC)
  16. Data Structures in Practice: Stacks, Queues, and Big-O Intuition
  17. Scheduling Tasks and Background Jobs with node-cron
  18. Sending Email from Node with Nodemailer
  19. Building a Web Scraper with Cheerio
  20. Cookies and Sessions 4

Node.js — Advanced 19 topics

  1. TypeScript with Node.js
  2. Performance and Clustering
  3. Worker Threads
  4. Real-time with WebSockets
  5. Caching with Redis
  6. Message Queues (intro)
  7. Microservices Architecture
  8. Security Best Practices
  9. GraphQL APIs
  10. Logging and Observability
  11. Dockerizing a Node App
  12. CI/CD and Deployment
  13. Advanced Project: Real-time Microservice
  14. Building Resilient Services: Timeouts, Retries, and Graceful Shutdown
  15. Diagnosing Memory Leaks and Profiling Performance
  16. Algorithms in Node: Recursion, Trees, and Graph Traversal
  17. Publishing Your Own npm Package
  18. Real-Time Updates with Server-Sent Events (SSE)
  19. Design Patterns for Node.js Applications

SQL 14 topics

  1. What Is a Database? Tables, Rows and Columns
  2. Your First Query: SELECT and FROM
  3. Filtering Rows with WHERE
  4. Sorting and Limiting: ORDER BY and LIMIT
  5. DISTINCT, Aliases and Expressions
  6. Understanding NULL
  7. Aggregate Functions: COUNT, SUM, AVG, MIN, MAX
  8. Grouping Data: GROUP BY and HAVING
  9. Creating Tables: CREATE TABLE and Data Types
  10. Changing Data: INSERT, UPDATE, DELETE
  11. Primary Keys and Foreign Keys
  12. Joining Tables: INNER JOIN
  13. LEFT JOIN and Missing Data
  14. Beginner Project: A School Library Database

SQL — Intermediate 14 topics

  1. Database Design: Entities, Relationships and ER Diagrams
  2. Normalization: 1NF, 2NF and 3NF
  3. Multi-Table Joins and Self-Joins
  4. Set Operations: UNION, INTERSECT and EXCEPT
  5. Subqueries: Scalar, IN, EXISTS and Correlated
  6. Common Table Expressions (WITH)
  7. CASE Expressions and Conditional Logic
  8. String, Date and Number Functions
  9. Views: Saved Queries as Virtual Tables
  10. Constraints and Data Integrity
  11. Indexes: How They Work and When to Use Them
  12. Transactions and ACID
  13. SQL in Applications: Parameterized Queries and SQL Injection
  14. Intermediate Project: An Online Store Database

SQL — Advanced 13 topics

  1. Window Functions: OVER, PARTITION BY and Ranking
  2. Window Frames, LAG/LEAD and Running Totals
  3. Recursive CTEs and Hierarchical Data
  4. Advanced Grouping: ROLLUP, CUBE and Pivoting Data
  5. Reading Execution Plans and Optimizing Queries
  6. Advanced Indexing Strategies
  7. Transactions in Depth: Isolation Levels and Locking
  8. Stored Procedures and Functions
  9. Triggers and Events
  10. Working with JSON in SQL
  11. Security and Access Control: Users, Roles, GRANT and REVOKE
  12. Analytics and Data Warehousing: OLTP vs OLAP, Star Schema
  13. Advanced Project: Sales Analytics Database

Learn every topic step by step

Lessons, examples, tests and an AI tutor adapt to each student. Start as a guest without registration.

Continue as a guest Create an account Log in