Learn a new programming language in 2 weeks (if you already know one).

You already know JavaScript. Or Python. Or Java. Or whatever your "main" language is. Now your new job uses Go, or your team migrated to Rust, or you want to learn Elixir for fun. The bookstores have a thousand 400-page books. The online courses are 30 hours each. You don't have 30 hours.

You don't need them. If you already know one language, you can be productive in a new one in two weeks. Not "expert". Not "fluent". Productive. Shipping useful code.

The trick is to not start from scratch. Most of programming generalizes. Your first language was 70% language + 30% programming concepts. Your second language is 30% new language + 70% mapping to what you already know.

Here's how to compress the timeline.

The 14-day plan

Day	Focus	Output
1	Setup + Hello World	Toolchain works. You can compile/run.
2-3	Syntax-to-syntax mapping	You can read most code in the new language.
4-5	Idioms unique to this language	You know what's different from your main one.
6-7	The standard library	You know where the common stuff lives.
8-10	One small real project	~200 lines of code that does something useful.
11-12	Read other people's code	You've absorbed the style.
13-14	Slightly bigger project	~500 lines. You're now productive.

Day 1: Setup, ruthlessly

Don't pick the cool new package manager. Don't tune your editor. Don't read the book. Pick the standard toolchain the language's official docs recommend. Get Hello World to compile and run. End of day 1.

If you spend 4 hours on day 1, something has gone wrong. Standard tools, official docs, simplest possible setup. The goal of day 1 is to remove the activation energy for day 2.

Day 2-3: Map syntax to syntax

This is the step every book skips and every fast learner does first. Make a single page that maps the new language's syntax to your existing language's syntax.

JavaScript → Go
const x = 5  →  x := 5
function f()  →  func f()
[1, 2, 3]    →  []int{1, 2, 3}
{a: 1}       →  map[string]int{"a": 1}
async/await  →  goroutines + channels

By the end of day 3, you should be able to read most code in the new language by mental translation. You won't be writing fluently. You'll be reading effectively. That's the bigger half.

Day 4-5: Find the idioms

Every language has 5-10 idioms that are different from your main language and that you'll need every day. In Go, it's "errors as values" (not exceptions) and goroutines. In Rust, it's ownership and borrowing. In Python, it's list comprehensions. In Elixir, it's pattern matching.

Find your new language's idiom list. Read short pieces of code that demonstrate each. Don't memorize — recognize. You're building pattern recognition, not vocabulary.

The single best resource for this for any major language is a "[language] for [your existing language] developers" guide, which exists for almost every common pairing. 4-6 hours total, across days 4 and 5.

The acceleration trick

Don't try to learn the new language's everything. Learn its differences. 70% of programming generalizes. Your second language only requires you to learn the 30% that doesn't transfer. That's why 14 days is enough — you're not learning a language, you're learning a delta.

Day 6-7: The standard library

Where do strings live? How do I read a file? How do I make an HTTP request? Where's the JSON parsing? How do I deal with dates?

Read through (or scan) the standard library docs for the 8-10 most-used modules. You don't need to memorize the API. You need to know "the thing exists, here's where to find it, here's the shape of the function".

This is the day people skip and the day that pays off most. Knowing the standard library is what separates "I can write code in this language" from "I can actually ship things in this language".

Day 8-10: A real project

Pick something small but real. A CLI tool. A simple API. A script that does something for your actual life. Build it. Make it work. Don't make it pretty. Don't refactor. Ship it.

The project is where the syntax mapping, the idioms, and the standard library knowledge collapse into actual skill. Until you've built something, the language is theoretical.

Day 11-12: Read other people's code

Open the GitHub repos of well-known open-source projects in the new language. Read the code. Notice the style. Notice the idioms that show up over and over. Notice the patterns that surprise you.

This is the day your code starts to sound like the new language, instead of sounding like your old language with new keywords. The shift is real and noticeable.

Day 13-14: A bigger project

Now build something a little harder. 500 lines instead of 200. Use the idioms you saw. Use the standard library moves you learned. Make something you'd be willing to show another engineer.

At the end of day 14, you're not an expert. You're productive. You can take a real ticket in the new language and ship it, with the docs open, in roughly the same time as a senior engineer on a slightly off day.

That's the destination. Two weeks. Not 30-hour courses. Not 400-page books. Build the delta. Use the patterns. Ship the project. Repeat.