Binding (computer science)

In computer science, binding is associating objects and implementations with names in programming language so that those objects and implementtions can be accessed by the names. Objects' names are said to be "bound" to them.

Deep binding and shallow bindings are not kinds of binding, but ways to implement binding.

The simplest example is defining subprograms:

def sum (x, y)
 x + y
end

sum (2, 3)

In this Ruby programming language code, an implementation returning the sum of given two inputs is bound to a name, sum.

Binding time

Because objects in computer programs are usually resident in the computer memory, binding time is almost the same as the time of allocation of memory space for objects. Bind can be done either at compile-time or link-time (static binding) or at run-time (dynamic binding). Also, scope rules might define binding time of objects. Local variables, for example, are usually bound at run-time while global variables at compile-time.

For example,

static int n;
int main ()
{
 n = 12;
 return n;
}

In this C code, a global variable n is bound to certain location in the memory of the computer.

Dynamic binding for polymorphism

In object-oriented programming, an object can respond to the same message with a different implementation. Dynamic binding is a common solution for this problem.

For example there may be an object that contains the name (data) 'Socrates', and which is of the class (or type) Person.

Now suppose all Persons are mortal. In object oriented programming, we can say that the Person class must implement the Mortal interface, which contains the method die().

Persons and Plants die in different ways, for example Plants don't stop breathing. Dynamic binding is the practice of figuring out which method to invoke at runtime. For example, if we write

void kill(Mortal m) {
  m.die();
}

it's not clear whether m is a Person or a Plant, and thus whether Plant.die() or Person.die() should be invoked on the object. With dynamic binding, the m object is examined at runtime, and the method corresponding to it's actual class is invoked. (This implies that the actual representation of an object in memory is just its data and doesn't include the methods.)