What is a callback function?

Question

Developers are often confused by what a callback is because of the name of the damned thing.

A callback function is a function which is:

• accessible by another function, and
• is invoked after the first function if that first function completes

A nice way of imagining how a callback function works is that it is a function that is "called at the back" of the function it is passed into.

Maybe a better name would be a "call after" function.

This construct is very useful for asynchronous behaviour where we want an activity to take place whenever a previous event completes.

Pseudocode:

// A function which accepts another function as an argument
// (and will automatically invoke that function when it completes - note that there is no explicit call to callbackFunction)
funct printANumber(int number, funct callbackFunction) {
    printout("The number you provided is: " + number);
}

// a function which we will use in a driver function as a callback function
funct printFinishMessage() {
    printout("I have finished printing numbers.");
}

// Driver method
funct event() {
   printANumber(6, printFinishMessage);
}

Result if you called event():

The number you provided is: 6
I have finished printing numbers.

The order of the output here is important. Since callback functions are called afterwards, "I have finished printing numbers" is printed last, not first.

Callbacks are so-called due to their usage with pointer languages. If you don't use one of those, don't labour over the name 'callback'. Just understand that it is just a name to describe a method that's supplied as an argument to another method, such that when the parent method is called (whatever condition, such as a button click, a timer tick etc) and its method body completes, the callback function is then invoked.

Some languages support constructs where multiple callback function arguments are supported, and are called based on how the parent function completes (i.e. one callback is called in the event that the parent function completes successfully, another is called in the event that the parent function throws a specific error, etc).

Opaque Definition

A callback function is a function you provide to another piece of code, allowing it to be called by that code.

Contrived example

Why would you want to do this? Let's say there is a service you need to invoke. If the service returns immediately, you just:

1. Call it
2. Wait for the result
3. Continue once the result comes in

For example, suppose the service were the factorial function. When you want the value of 5!, you would invoke factorial(5), and the following steps would occur:

1. Your current execution location is saved (on the stack, but that's not important)

2. Execution is handed over to factorial

3. When factorial completes, it puts the result somewhere you can get to it

4. Execution comes back to where it was in [1]

Now suppose factorial took a really long time, because you're giving it huge numbers and it needs to run on some supercomputing cluster somwhere. Let's say you expect it to take 5 minutes to return your result. You could:

1. Keep your design and run your program at night when you're asleep, so that you're not staring at the screen half the time

2. Design your program to do other things while factorial is doing its thing

If you choose the second option, then callbacks might work for you.

End-to-end design

In order to exploit a callback pattern, what you want is to be able to call factorial in the following way:

factorial(really_big_number, what_to_do_with_the_result)

The second parameter, what_to_do_with_the_result, is a function you send along to factorial, in the hope that factorial will call it on its result before returning.

Yes, this means that factorial needs to have been written to support callbacks.

Now suppose that you want to be able to pass a parameter to your callback. Now you can't, because you're not going to be calling it, factorial is. So factorial needs to be written to allow you to pass your parameters in, and it will just hand them over to your callback when it invokes it. It might look like this:

factorial (number, callback, params)
{
    result = number!   // i can make up operators in my pseudocode
    callback (result, params)
}

Now that factorial allows this pattern, your callback might look like this:

logIt (number, logger)
{
    logger.log(number)
}

and your call to factorial would be

factorial(42, logIt, logger)

What if you want to return something from logIt? Well, you can't, because factorial isn't paying attention to it.

Well, why can't factorial just return what your callback returns?

Making it non-blocking

Since execution is meant to be handed over to the callback when factorial is finished, it really shouldn't return anything to its caller. And ideally, it would somehow launch its work in another thread / process / machine and return immediately so that you can continue, maybe something like this:

factorial(param_1, param_2, ...)
{
    new factorial_worker_task(param_1, param_2, ...);
    return;
}

This is now an "asynchronous call", meaning that when you call it, it returns immediately but hasn't really done its job yet. So you do need mechanisms to check on it, and to obtain its result when its finished, and your program has gotten more complex in the process.

And by the way, using this pattern the factorial_worker_task can launch your callback asynchronously and return immediately.

So what do you do?

The answer is to stay within the callback pattern. Whenever you want to write

a = f()
g(a)

and f is to be called asynchronously, you will instead write

f(g)

where g is passed as a callback.

This fundamentally changes the flow-topology of your program, and takes some getting used to.

Your programming language could help you a lot by giving you a way to create functions on-the-fly. In the code immediately above, the function g might be as small as print (2*a+1). If your language requires that you define this as a separate function, with an entirely unnecessary name and signature, then your life is going to get unpleasant if you use this pattern a lot.

If, on the other hand, you language allows you to create lambdas, then you are in much better shape. You will then end up writing something like

f( func(a) { print(2*a+1); })

which is so much nicer.

How to pass the callback

How would you pass the callback function to factorial? Well, you could do it in a number of ways.

1. If the called function is running in the same process, you could pass a function pointer

2. Or maybe you want to maintain a dictionary of fn name --> fn ptr in your program, in which case you could pass the name

3. Maybe your language allows you to define the function in-place, possible as a lambda! Internally it is creating some kind of object and passing a pointer, but you don't have to worry about that.

4. Perhaps the function you are calling is running on an entirely separate machine, and you are calling it using a network protocol like HTTP. You could expose your callback as an HTTP-callable function, and pass its URL.

You get the idea.

The recent rise of callbacks

In this web era we have entered, the services we invoke are often over the network. We often do not have any control over those services i.e. we didn't write them, we don't maintain them, we can't ensure they're up or how they're performing.

But we can't expect our programs to block while we're waiting for these services to respond. Being aware of this, the service providers often design APIs using the callback pattern.

JavaScript supports callbacks very nicely e.g. with lambdas and closures. And there is a lot of activity in the JavaScript world, both on the browser as well as on the server. There are even JavaScript platforms being developed for mobile.

As we move forward, more and more of us will be writing asynchronous code, for which this understanding will be essential.

The Callback page on Wikipedia explains it very well:

In computer programming, a callback is a reference to executable code, or a piece of executable code, that is passed as an argument to other code. This allows a lower-level software layer to call a subroutine (or function) defined in a higher-level layer.

A layman response would be that it is a function that is not called by you but rather by the user or by the browser after a certain event has happened or after some code has been processed.

A callback function is one that should be called when a certain condition is met. Instead of being called immediately, the callback function is called at a certain point in the future.

Typically it is used when a task is being started that will finish asynchronously (ie will finish some time after the calling function has returned).

For example, a function to request a webpage might require its caller to provide a callback function that will be called when the webpage has finished downloading.

Let's keep it simple. What is a call back function?

Example by Parable and Analogy

I have a secretary. Everyday I ask her to: (i) drop off the firm's outgoing mail at the post office, and after she's done that, to do: (ii) whatever task I wrote for her on one of those sticky notes.

Now, what is the task on the sticky-note? The task varies from day to day.

Suppose on this particular day, I require her to print off some documents. So I write that down on the sticky note, and I pin it on her desk along with the outgoing mail she needs to post.

In summary:

1. first, she needs to drop off the mail and
2. immediately after that is done, she needs to print off some documents.

The call back function is that second task: printing off those documents. Because it is done AFTER the mail is dropped off, and also because the sticky note telling her to print the document is given to her along with the mail she needs to post.

Let's now tie this in with programming vocabulary

• The method name in this case is: DropOffMail.
• And the call back function is: PrintOffDocuments. The PrintOffDocuments is the call back function because we want the secretary to do that, only after DropOffMail has run.
• So I would "pass: PrintOffDocuments as an "argument" to the DropOffMail method. This is an important point.

That's all it is. Nothing more. I hope that cleared it up for you - and if not, post a comment and I'll do my best to clarify.

Callbacks are most easily described in terms of the telephone system. A function call is analogous to calling someone on a telephone, asking her a question, getting an answer, and hanging up; adding a callback changes the analogy so that after asking her a question, you also give her your name and number so she can call you back with the answer.

-- Paul Jakubik, "Callback Implementations in C++"