An example of talking through your code

In my last email, I recommended an exercise to practice talking about code. Talking through your file line by line will quickly expose the holes in your understanding or vocabulary. Today, I thought I'd show you an example of what I mean. Let's take just this simple JavaScript module and describe it:

export const average = (...args) => {
  return sum(...args) / args.length

export const sum = (...args) => {
  return args.reduce((a, b) => a + b)

Your first attempt at this exercise might sound something like this:

This is a module which exports two functions, average and sum. Line 12 defines the average function, which takes a variable number of arguments. In line 13, I'm returning the sum of those arguments divided by the number of arguments (ie. the average.)

On line 16, I'm defining the sum function, which is used in the average function. sum takes a variable number of arguments. On line 17, I call reduce on the array of those arguments to get their sum and return that value.

That's more detail than you would probably use to describe this code to a coworker, but not actually enough to be helpful in this exercise.

We want to go deeper. Much deeper.

Try something like this:

This is an ES6 module using named exports but no default export. The two named exports are average and sum, which are defined as arrow functions instead of traditional functions. Arrow functions differ from traditional functions in that they [...go look it up...].

On line 12, I declare my first arrow function and assign it to a const, so that I can export it. I'm using the rest operator as an easy way to assign a variable number of arguments to the array called args. In the body of my function on line 13, I'm calculating the average by summing the arguments using a function I've defined below and dividing that sum by the length of the args array. Because sum accepts the same signature as average (a variable number of arguments) I have to spread the args array when I pass it into sum. The rest and spread operators look exactly the same, but [...go look up how they differ...] This function assumes that all arguments are numbers. It will not gracefully handle non-numeric input.

On line 16, I'm declaring the sum function and assigning it to an exported const. Again, this takes a variable number of arguments and I use the rest operator to assign them to the array called args. In the body of my function I reduce that array by passing a simple callback that returns the result of adding the accumulator a to the current value b. This is a very simple callback that makes use of a number of defaults and developer conveniences built into the reduce method. A more verbose version of this callback would look like [... go look up all the things you could do with reduce ...].

Both of these arrow functions could even be reduced to one-liners by making use of implicit return. Implicit return works by [... go look up implicit return so you can articulate it in detail ...]

I could go on. In fact, I challenge you to go on, using just the two functions above. What details can you describe that I haven't covered here, and more importantly, what holes in your understanding or vocabulary have you uncovered by trying?

Seriously, email me back. I want to know.

Did you like this?

I send a daily email with tips and ideas like this one. Join the party!