A1Learner teaches programming in short, clear lessons. Every lesson explains one idea in plain words, shows it in a real example, and ends with one exercise question. No experience needed — start at lesson one and keep going.
1660 lessons across 21 courses · Rust, Python and the web · 0 completed by you
Every lesson follows the same pattern, in every course. Once you know the pattern, you can stop thinking about the page and just learn.
Step 1
One idea per lesson, defined in everyday words at the very start. Short sentences, no jargon piles.
Step 2
Real code appears within the first screen. Small examples nail one piece at a time, then one full program brings the pieces together.
Step 3
Every lesson has a box where you edit the code and run the idea yourself. Change something and see what happens.
Step 4
Each lesson ends with one question that checks the idea landed. Answer it, mark the lesson complete, and move on.
fn main() {
println!("Hello, World!");
}A real example from the first Rust course. Every lesson pairs code like this with the output it really gives.
21 courses across three paths. The Rust, Python and web paths are independent — pick the one you want, start at its Beginner course if you are new, and follow the lessons in order.
Rust · Beginner
Start Rust from zero — syntax, ownership, data and errors.
The friendly on-ramp: install Rust, write your first programs, and master the ideas every Rust developer uses daily — ownership and borrowing, structs and enums, collections, and error handling with Option and Result.
142 lessons · 51 topics · 0/142 completed
Rust · Intermediate
Generics, traits, iterators and real project skills.
Level up from the basics: generics and traits in depth, lifetimes without fear, closures and iterators, serde and SQLite, then modules, testing, documentation and building command-line tools like a professional.
149 lessons · 45 topics · 0/149 completed
Rust · Advanced
Networking, smart pointers, concurrency and the deep end.
Go deep: networking, dates, logging and publishing craft; Box, Rc, Arc and interior mutability; threads, channels and shared state without data races; then unsafe Rust, FFI, macros and advanced patterns.
149 lessons · 47 topics · 0/149 completed
Rust · Advanced
Async Rust and the Tokio runtime, properly understood.
Async from first principles — futures, pinning and executors — then the Tokio runtime in depth: tasks, channels, sync primitives, timeouts, streams, and building real networked services.
45 lessons · 25 topics · 0/45 completed
Python · Beginner
Your first programming language, taught the friendly way.
Start coding from zero with Python: variables, strings, lists, loops, functions and files — short lessons, real examples and an exercise in every lesson.
116 lessons · 33 topics · 0/116 completed
Python · Advanced
Decorators, generators, concurrency and Python internals.
The deep end of Python: decorators and descriptors, generators, async/await, concurrency, metaclasses, performance work and the internals that make Python tick.
102 lessons · 47 topics · 0/102 completed
Python · Beginner
Tensors, autograd and your first trained models.
Meet PyTorch the friendly way: tensors and shapes, autograd, modules, losses and optimizers, the training loop and data handling — finishing with a trained classifier and a capstone program. Assumes basic Python; no ML background needed.
79 lessons · 19 topics · 0/79 completed
Python · Intermediate
Training discipline, CNNs, sequences and transfer.
Training done properly: splits and metrics, schedules, regularization and normalization, losses, images and CNNs, embeddings and text, RNNs, transfer learning and data engineering — ending in a full-pipeline capstone. Builds on PyTorch Beginner.
87 lessons · 19 topics · 0/87 completed
Python · Advanced
Custom autograd, transformers, generation and export.
Worked by hand: custom autograd and gradcheck, attention and transformers, distributions, VAEs, GANs and diffusion, export and quantization, FX graphs, distributed honestly and distillation — ending in an export capstone. Builds on PyTorch Intermediate.
71 lessons · 17 topics · 0/71 completed
Python · Advanced
A tiny GPT, built by hand — tokens to text.
Build a small GPT by hand: character tokens, embeddings with position, self-attention and transformer blocks, a training loop, then generation, sampling and a tiny BPE — ending in a trained capstone. Builds on PyTorch Intermediate.
53 lessons · 15 topics · 0/53 completed
Python · Beginner
Complexity, arrays, hash maps, trees, graphs and first DP.
Python-first interview foundations: Big-O counted in code, arrays, strings, hash maps, two pointers, stacks, linked lists, trees, graphs, and a first taste of dynamic programming.
100 lessons · 18 topics · 0/100 completed
Python · Intermediate
Patterns, heaps, tries, graphs and the DP ladder.
Pattern recognition for real interviews: monotonic stacks, heaps, backtracking, tries, union-find, Dijkstra, greedy and the dynamic programming ladder — plus an LRU cache and a mini search engine capstone.
112 lessons · 20 topics · 0/112 completed
Python · Advanced
Hard problems, proofs and from-scratch structures.
The hard canon: median of two sorted arrays, segment trees, interval DP, string algorithms, MST and shortest paths in depth, LFU and design problems — ending in a timed mock-interview gauntlet.
93 lessons · 17 topics · 0/93 completed
HTML · Beginner
Build webpages from zero — structure, text, links, forms and layout.
The language of webpages: documents and elements, text, links and images, lists and tables, forms, semantic layout and media. Every example runs live in your browser.
50 lessons · 12 topics · 0/50 completed
CSS · Beginner
Style webpages from zero — colours, layout, flexbox and grid.
The language that styles webpages: selectors and colours, the box model, text and fonts, flexbox and grid layout, effects, and responsive design. Every example runs live in your browser.
54 lessons · 14 topics · 0/54 completed
JavaScript · Beginner
Make webpages act — variables, functions, arrays, events and the DOM.
The language that makes webpages act: output and variables, functions, objects and arrays, conditions and loops, classes, JSON and the DOM. Every example runs live in your browser.
55 lessons · 16 topics · 0/55 completed
TypeScript · Beginner
JavaScript with types — mistakes caught before the code runs.
JavaScript plus a type layer: annotations and inference, interfaces and unions, generics, narrowing and utility types. Every example is checked by the real TypeScript compiler.
33 lessons · 12 topics · 0/33 completed
SQL · Beginner
Ask the database questions — select, filter, join and build.
The language of databases: asking questions with SELECT, filtering and sorting rows, joining tables, grouping totals, and building tables of your own. Every result comes from a real database engine.
43 lessons · 11 topics · 0/43 completed
Java · Beginner
Programs, classes and objects — the write-once, run-anywhere language.
The write-once, run-anywhere language: programs and variables, methods and classes, inheritance and interfaces, collections and exceptions. Every example is compiled and run with the real Java compiler.
48 lessons · 12 topics · 0/48 completed
C# · Beginner
Apps, games and the web — classes, properties and clean types.
The language of apps and games: programs and variables, methods and classes, inheritance and interfaces, lists and exceptions. Every example is compiled and run with the real C# compiler.
41 lessons · 12 topics · 0/41 completed
Go · Beginner
Small, fast and concurrent — one way to do things, done well.
The small, fast language of servers and tools: programs and variables, slices and maps, structs and interfaces, errors as values, and a first look at goroutines. Every example is run with the real Go toolchain.
38 lessons · 13 topics · 0/38 completed
Every example was run before it reached this page, and the output shown is the output it really gives. No made-up results.
Lessons are short and focused. You are never asked to learn five things at once, and most lessons take just a few minutes.
Each lesson starts by saying plainly what the topic is. The main idea is then shown in examples, so it gets two chances to land.
Courses start from zero and build in order. If a lesson uses an idea, an earlier lesson in the same course taught it.
Reading is not the same as knowing. One question at the end of every lesson tells you honestly whether the idea landed.
Completed lessons are saved in your browser automatically. Leave whenever you like — when you come back, you pick up where you stopped.
1
Rust if you want a powerful language for serious programs, Python if you want the friendliest first language, HTML if you want to build webpages. All start from zero.
2
Read the short explanation, try the code in the box, and answer the exercise. That is a complete lesson.
3
Your progress is saved, so tomorrow starts exactly where today ended. Lesson by lesson, the course gets finished.
Your first lesson takes a few minutes. Pick a language and begin at lesson one.