about / langfor.dev

A second language is the easiest one you'll ever learn — if it's taught for the developer you already are.

langfor.dev is a small library of directional language tracks for senior developers. We teach Rust to Python developers, Go to JS developers, TypeScript to Pythonistas — by mapping new ideas onto the ones you already trust.

principles

Six rules we keep.

If a lesson breaks one of these, it goes back in the queue.

  1. 01

    You already know how to code.

    We don't reteach loops, conditionals, or what a function is. Every lesson assumes you've shipped real systems and treats your existing language as the prior — not as something to be unlearned.

  2. 02

    Every concept maps to one you have.

    Result is what try/except wishes it was. A trait is an interface that found composition. We name the bridge before we name the destination, so new ideas land on familiar ground.

  3. 03

    Code first, prose second.

    If a concept can be shown in 12 lines of code, we don't write 12 paragraphs. Every lesson opens with the source-language code, then the target, then a short note on why the compiler made you change it.

  4. 04

    Idiom over syntax.

    Knowing how to write a for-loop in five languages is trivia. Knowing when an experienced Rust developer reaches for an iterator chain — and why — is the actual job. We optimise for the latter.

  5. 05

    Capstones, not quizzes.

    Every track ends with a small but real piece of software you'd be willing to ship. If the capstone is forgettable, the track was too.

  6. 06

    Drafts ship in the open.

    Lessons are marked draft, next-up, and open. You can read drafts; we just won't pretend they're done. The changelog is the source of truth, not a marketing surface.

method

How a track actually works.

  1. step 01

    Pick a from → to

    Choose where you're starting from and where you want to land. Tracks are directional on purpose — Python → Rust is not the same lesson as Rust → Python.

  2. step 02

    Read the bridge

    Each lesson opens with the code you'd write today and the code you'll write tomorrow, side-by-side.

  3. step 03

    Run the diff

    Every lesson has a runnable repo. Clone it, break things, watch the compiler complain. The complaint is the lesson.

  4. step 04

    Build the capstone

    End the track with a small CLI, library, or service. Real code, real tests, real CI.

who it's for

  • Senior engineers who can already ship in one or two languages.
  • Developers picking up a second language for a real project, not a tutorial high.
  • Tech leads choosing the next language for their team and wanting calibrated reps.
  • Anyone who'd rather read 200 lines of working code than 20 pages of metaphors.

who it isn't for

  • ×First-time programmers — there are better resources for your zero-to-one.
  • ×Teams looking for certification PDFs to add to a procurement form.
  • ×Anyone hoping a quiz at the end will tell them they're senior in a new language.

voice

Plainspoken, opinionated, runnable.

"try/except isn't a control flow primitive — it's a poor man's sum type with a stack trace attached. Once you've written Result<T, E> a few times, you stop missing it."
— from python → rust, lesson 03.01

We don't pretend Rust is friendly, that Python is "just slow JS", or that any language is the right one for every job. We tell you what each language is good at, where it gets in your way, and what to write first when it does.

no metaphors about restaurantsno boot-camp energyno quizzes

ready?

Pick a starting language and the one you want to learn.

Browse the 13 tracks