Callback (computer programming)

For a discussion of callback with computer modems, see callback (telecommunications).

In computer programming, a callback is a reference to 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 callback is often back on the level of the original caller.

Use

Callbacks have a wide variety of uses. For example, imagine a function that reads a configuration file and associates values with options. If the options are identified by a hash, then writing the function so that it takes a callback makes it more flexible: its user can choose whatever hashing algorithm is desired and the function will continue to work, since it uses the callback to turn option names into hashes; thus, callbacks allow the user of a function to fine-tune it at runtime. Another use is in error signaling. A Unix program, for example, might not want to terminate immediately when it receives SIGTERM; to make sure things get taken care of, it would register the cleanup function as a callback.

Callbacks may also be used to control whether a function acts or not: Xlib allows custom predicates to be specified to determine whether a program wishes to handle an event. The following code in C demonstrates the use of callbacks to display two numbers.

#include <stdio.h>
#include <stdlib.h>
 
/* The calling function takes a single callback as a parameter. */
void PrintTwoNumbers(int (*numberSource)(void)) {
    printf("%d and %d\n", numberSource(), numberSource());
}
 
/* A possible callback */
int overNineThousand(void) {
    return (rand() % 1000) + 9001;
}
 
/* Another possible callback. */
int meaningOfLife(void) {
    return 42;
}
 
/* Here we call PrintTwoNumbers() with three different callbacks. */
int main(void) {
    PrintTwoNumbers(rand);
    PrintTwoNumbers(overNineThousand);
    PrintTwoNumbers(meaningOfLife);
    return 0;
}

This should provide output similar to:

 125185 and 89188225
 9084 and 9441
 42 and 42

Note how this is different from simply passing the output of the callback function to the calling function, PrintTwoNumbers() - rather than printing the same value twice, the PrintTwoNumbers calls the callback as many times as it requires. This is one of the two main advantages of callbacks.

The other advantage is that the calling function can pass whatever parameters it wishes to the called functions (not shown in the above example). This allows correct information hiding: the code that passes a callback to a calling function does not need to know the parameter values that will be passed to the function. If it only passed the return value, then the parameters would need to be exposed publicly.

This information hiding means that callbacks can be used when communicating between processes or threads, or through serialised communications and tabular data.

Callback Design

There are two types of callbacks: blocking callbacks (also known as synchronous callbacks or just callbacks) and deferred callbacks (also known as asynchronous callbacks). These two design choices differ in how they control data flow at runtime. While blocking callbacks are invoked before a function (in the example above: main) returns, deferred callbacks may be invoked after a function returns. The above is an example of a blocking callback. Deferred callbacks are often used in the context of I/O operations or event handling. While deferred callbacks imply the existence of multiple threads, blocking callbacks are often (but not always) relying on a single thread. Therefore blocking callbacks are no common cause for synchronization.

Implementation

The form of a callback varies among programming languages.

• C, C++ and Pascal allow function pointers as arguments to other functions. Other languages, such as JavaScript, Python, Perl and PHP, simply allow the name of a function or a function literal (lambda expression) to be passed through.
• The .NET Framework, used in languages such as C# and VB.NET, provides a type-safe encapsulating reference, a 'delegate', to define well-typed function pointers. These can be used as callbacks.
• Events and event handlers, as used in .NET languages, provide generalized syntax for callbacks.
• Functional languages generally support first-class functions, which can be passed as callbacks to other functions, stored as data or returned from functions.
• Some languages, such as Algol 68, Perl, Smalltalk, newer versions of C# and VB.NET as well as most functional languages, allow unnamed blocks of code (lambda expressions) to be supplied instead of references to functions defined elsewhere.
• In some languages, e.g. Scheme, ML, JavaScript, Perl, Smalltalk, PHP (since 5.3.0), and many others, such functions can be closures, i.e. they can access and modify variables locally defined in the context in which the function was defined.
• In object-oriented programming languages without function-valued arguments, such as Java, callbacks can be simulated by passing an instance of an abstract class or interface, of which the receiver will call one or more methods, while the calling end provides a concrete implementation. Such objects are effectively a bundle of callbacks, plus the data they need to manipulate. They are useful in implementing various design patterns such as Visitor, Observer, and Strategy.
• C++ allows objects to provide their own implementation of the function call operation. The Standard Template Library accepts these objects (called functors), as well as function pointers, as parameters to various polymorphic algorithms

See also

• Continuation-passing style
• Signals and slots
• Event loop
• Event-driven programming
• libsigc++, a callback library for C++
• Implicit invocation
• User exit
• Inversion of control

External links

• Style Case Study #2: Generic Callbacks
• C++ Callback Solution
• Basic Instincts: Implementing Callback Notifications Using Delegates
• Implement Script Callback Framework in ASP.NET
• Implement callback routines in Java
• Interfacing C++ member functions with C libraries