Exercise-driven course to Node.js
operating principles.

Asynchronous calls - the #1 roadblock when learning Node.js

You know how Node.js seems great until you have to write an asynchronous call. Dabbling through Stack Overflow posts doesn't give you much insight. Callbacks look counterintuitive and messy.

Reading the official docs makes you no wiser.

  • When are callbacks run?
  • Who runs them?
  • Are they run in parallel, no?
  • How do worker threads fit into this?

You're starting to have a hunch that there's something happening outside of your code. What is it? Programming something you can't see is as easy as solving Rubik's cube blindfolded.

It's easier to give up on Node.js and go back to good old PHP and shell scripts, maybe even Java.

Asynchronous call tree

You're not interested in reading through half of Github to "get" Node.js

How come there's no single good resource on the operating principles? There are bits and pieces scattered across #node.js, Slack and discussion forums.

It looks like it takes five months and reading through half of Github to "get" callbacks, asynchronicity and worker threads.

You know using JavaScript both on the front and back-end has benefits but looks like Node just wasn't meant for you.

But what if you could turn any spec into working code?

Imagine orchestrating your next Node app so it calls three web APIs, posts to Twitter and scrapes two other pages all at the same time using asynchronous calls.

Imagine having the surgical moves to modify existing asynchronous code base. You could make calls fly after each other instead of at the same time. You could bend Node to your will.

You'd be using technology stack that's from this decade. And you'd be hot stuff on the job market, too.

It's true, asynchronicity can scare off people from learning Node, but it doesn't have to.

Learn the right mental model to write Node apps

The operating principles of Node are simple and straightforward when you zoom out from the level of individual statements and for-loops. When you focus on the system that operates outside user code, you'll grasp the right mental model for writing Node programs.

Looking at the whole system that operates when you return from a top level JavaScript block is the key to “getting” Node. And that’s exactly what you'll learn in this course.

Learn exactly what happens behind the scenes

Knowing exactly what happens when you return from a top level JavaScript function is comforting. As a result, you'll write programs that work the system.

A clear mental model allows you to approach Node programs the right way. The course shows you a glimpse of the engine room while still keeping Kernighan & Ritchie on the bookshelf.

Theory-only courses are long gone, and in this course, you'll get to practice your new skills early on. In fact, you’ll be writing your first app in 30 minutes. Home assignments include meaningful programs such as a stress relief exercise, an MD5 file hasher, a Twitter bot, and a news aggregator.

You’ll learn

  • the execution model of Node that’s based on events and associated pieces of JavaScript
  • the triad that’s the role of a Node programmer - to start operations, register callbacks and let control back
  • to read asynchronous code and see the execution order of code lines
  • mental model for node operation
  • when callbacks are run
  • nextTick, setImmediate,
  • caring for other computations
  • and much more

Learn to write Node.js programs that work the system

Lay yourself hurricane-proof foundations for Node.js and learn to write asynchronous programs

Asynchronous call tree

Tick 3 Week Course

Tick 21 Emails

Tick 5 Home Assignments

Tick All-in-one PDF

Tick Source Code


Callbacks Are Counterintuitive

“Coming from traditional programming background, I always thought callbacks are a little counterintuitive. “

- Java programmer, new to JavaScript -


Documentation Is Scattered

“One thing that always surprised me was there was no single good resource on the operating principles.“

- Developer for 8 years, new to Node.js -

Course Contents

  • mental model how to approach writing Node programs
  • system outside of user code
  • timers, setTimeout()
  • 🏆 Breathing Relaxation App
  • system calls initial user code
  • pseudo-code of the system
  • 🏆 Common Stack Overflow Question
  • knows callbacks are not run in parallel
  • can read files
  • asynchronous call starts immediately and returns without results
  • function is called when results are in
  • can use error argument
  • 🏆 MD5 File Hasher
  • can use streams
  • can calculate hashes
  • can read asynchronous code
  • knows difference between function arguments passed to forEach() and setTimeout()
  • can visualize program execution and outstanding operations
  • can put dependent logic inside callback
  • can make HTTP calls
  • 🏆 Twitter Weather Bot
  • can make use of waiting time
  • can start multiple calls right away or after each other
  • knows about worker threads
  • 🏆 News Aggregator
  • can care for other computations
  • can use setImmediate()
  • 🏆 Prime Number Calculator
  • knows about externalizing cpu-heavy calculation to own process
  • knows about process.nextTick()
  • knows in detail how the system outside user code operates

Q & A

Should I know JavaScript before taking the course?

You should know entry level JavaScript and have some previous experience in programming. You don't need in-depth experience with Node. All advanced Node topics are introduced with links to additional material.

Do you offer refunds?

Yes. If you're not happy with the course, hit us an email within 30 days and you'll get a full refund.

Does the course teach async-library, Promises, generators or async/await?

No. This course is for learning the operating principles behind Node.js. We'll use callbacks and plain Node. Learning async-library, Promises, generators and async/await is much easier after you've learned the basics, though.

Does the course use ES6?

The examples use ES5 version of JavaScript. ES6 is worth learning, but you should learn only one new thing at a time so the course sticks to ES5.

How much time should I allocate for the course?

You should allocate 30-60 minutes a day for the course. Each lesson is bite-sized in length and is digestible in one session.

How long does it take to finish the course?

If you submit each homework assignments within a few days, you'll finish the course in three weeks.

Can I work at my own pace?

The course pauses on homework assignments, and you can take as long as you need. The course continues when you submit your answer.

What format is the course in?

The course is delivered through email. You'll receive one email a day. And at the end, you'll have access to all-in-one PDF with all the lessons and a ZIP of all source code.

Are the exercises mandatory?

Yes. The course pauses until you submit your answer. The answers are kept private and are first and foremost for yourself.

Get free sample lesson and short email course on Node asynchronicity

Your email address

Write Asynchronous Programs course is brought to you by Byte Archer. On this site you'll learn JavaScript, Node.js and TypeScript so you can be at home in today's all-JS web development world.