Blog · Jul 10, 2026
Hot language hands-on tutorials (TypeScript, Rust, Go, and more)
Multi-day hands-on courses for the languages teams actually hire for, each with a daily task and a capstone — plus SQL, Zig, and Bash.
We published a full Languages hub with hands-on, day-by-day sprints — not reference manuals you skim once and forget, but courses built around a task you complete each day.
What “hands-on” actually means
Every course in the hub follows the same structure: a short code-along that introduces the day’s concept, a concrete task you complete yourself using that concept, and a capstone project at the end that forces you to combine everything from the earlier days. There’s no day that’s just “read about generics” with nothing to run afterward — if a day doesn’t produce code you executed and checked, it’s not in the course.
As an example, Go in 10 Days spends day one on goroutines and channels conceptually, then has you build a small concurrent worker pool that fetches a list of URLs in parallel and reports which ones failed — a task that only “works” if you actually understood the concurrency primitives, not just read about them.
The full list
- TypeScript — 10 days
- JavaScript — 10 days
- Rust — 10 days
- Go — 10 days
- Java — 10 days
- Kotlin — 10 days
- Swift — 10 days
- C++ — 10 days
- C# — 10 days
- Ruby — 10 days
- PHP — 10 days
- SQL — 10 days
- Zig — 7 days
- Bash — 7 days
- Python in 10 Days — already on the site
How to actually pick one
Don’t pick based on hype alone — match the language to what you’re trying to build next:
| If you’re aiming at | Start with |
|---|---|
| Frontend or full-stack web work | TypeScript, then JavaScript if you skipped it |
| Systems, performance-critical services | Rust or Go |
| Backend services at a large company | Java, Kotlin, or C# |
| iOS/macOS apps | Swift |
| Data plumbing, scripting, gluing tools together | Bash, SQL |
| Embedded or resource-constrained targets | Zig or C++ |
If you genuinely don’t know, Go or TypeScript are the safest defaults — both have large hiring markets, both are approachable in under two weeks, and both show up constantly in the backend/frontend split that most teams use.
Common footguns when learning a new language this way
- Course-hopping instead of finishing — starting three 10-day courses in the same week means finishing none of them; the daily tasks build on each other, and losing the thread halfway through is worse than not starting.
- Copy-pasting the code-along instead of typing it — you’ll pass the day’s task without understanding it, then stall on the capstone, which deliberately doesn’t hand you the pattern.
- Skipping the capstone — it’s the only part of each course that tests whether you can combine ideas from multiple days, which is the actual skill you’re building, not any single day’s syntax.
- Treating 10 days as “fluent” — these courses get you to “can read the language, can build something small and working, knows where to look next.” That’s the honest bar; real fluency takes shipping real code over months, not a sprint.
- Ignoring the language’s own tooling — every course leans on the language’s standard formatter/linter/test runner (
gofmt,cargo test,rustfmt, etc.) rather than fighting it; skipping that step means fighting style debates with yourself for months afterward.
You know a course is actually done when…
- You completed the capstone without re-reading the day-by-day code-alongs from scratch
- You can write the “hello world” equivalent from memory, with correct syntax, no lookup
- You know the language’s standard way to run tests and format code, and have actually run both at least once
- You can explain the one or two concepts that felt hardest on day one, in your own words, without the course’s explanation in front of you
- You’ve pushed the capstone to a Git repo — see Getting Started with Git if that step itself is the unfamiliar part
Each course has daily code-alongs, a concrete task, and a capstone. Start at the hub and pick one language this week.