Late binding

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Late binding" – news · newspapers · books · scholar · JSTOR (January 2011) (Learn how and when to remove this message)

Late binding^[1] is the act or mechanism of binding two software entities at runtime as opposed to early binding which occurs before the program starts – such as design or build times. The implementation of late binding differs by context. The term dynamic binding is sometimes used for the same concept,^[2] but is more commonly refers to dynamic scope.

The term "late binding" dates back to at least the 1960s, where it can be found in Communications of the ACM. The term was widely used to describe calling conventions in languages like Lisp, though usually with negative connotations about performance.^[3]

In the 1980s, Smalltalk popularized object-oriented programming (OOP) and with it late binding. Alan Kay once said, "OOP to me means only messaging, local retention, and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I'm not aware of them."^[4]

In the 1990s, COM was commonly used. It provided both a binary, early binding as well as a late binding based on name lookup.

In 2000, Alex Martelli coined the term duck typing to refer to a form of polymorphism that leveraged the same kind of name lookup as COM late binding. A runtime supports duck typing if it is interpreted or if it supports type introspection.

In C++, late binding (also called "dynamic binding") refers to what normally happens when the virtual keyword is used in a method's declaration. Typically, a call requires a lookup via a virtual table.

In Component Object Model (COM), a late-bound method call is performed via the IDispatch interface. This is performed by calling GetIDsOfNames() to look up a method by name and then Invoke to execute the method. Some contexts provide ease-of-use support for calling this interface.^[5] For example, in Visual Basic 6, methods are called late-bound for a variable declared as Object. In contrast, with early binding, the compiler fixes types of variables and expressions.^[6]

The primary advantage of using late binding in COM programming is that one is not required to reference the providing library at compile time. This makes the compilation process more resistant to version conflicts, in which the class's v-table may be accidentally modified. This is not an issue in just-in-time compilation runtimes such as .NET and Java, because the v-table is created at runtime.^[7]

In .NET, late binding refers to overriding a virtual method like C++ or implementing an interface. The compiler builds virtual tables for every virtual or interface method call which is used at run-time to determine the implementation to execute.

Also like COM and Java, the Common Language Runtime provides reflection APIs that can make late binding calls. The use of these calls varies by language.

With C# 4, the language also added the "dynamic" pseudo-type. This would be used in place of the Object type to indicate that late binding is desired. The specific late binding mechanism needed is determined at runtime using the Dynamic Language Runtime as a starting point.

Visual Basic uses them whenever the variable is of type Object and the compiler directive "Option Strict Off" is in force. This is the default setting for a new VB project. Prior to version 9, only .NET and COM objects could be late bound. With VB 10, this has been extended to DLR-based objects.

There are three definitions for late binding in Java.

Early documents on Java discussed how classes were not linked together at compile time. While types are statically checked at compile time, different implementations for classes could be swapped out just prior to runtime simply by overwriting the class file. As long as the new class definition had the same class and method names, the code would still work. In this sense it is similar to the traditional definition of late binding.

Currently, it is popular to use the term late binding in Java programming as a synonym for dynamic dispatch. Specifically, this refers to Java's single dispatch mechanism used with virtual methods.

In most dynamically-typed languages (such as JavaScript), the list of methods on an object can be altered at runtime. This requires late binding.

In Lisp, late bound global function calls are efficiently looked up at runtime via a symbol's function cell. These function bindings are mutable.

Example using an interactive Clozure Common Lisp session:

? (defun foo ()
    (bar pi))   ; a still undefined function BAR gets called
;Compiler warnings :
;   In FOO: Undefined function BAR
FOO

? (defun bar (x)   ; now we define it
    (* x 2))
BAR

? (foo)    ; calling foo and it uses the recent definition of BAR
6.283185307179586D0

? (defun bar (x)   ; now we redefine BAR
    (* x 1000))
BAR

? (foo)    ;  FOO now calls the new function, there is no need to recompile/link/load FOO
3141.592653589793D0

? (type-of 'bar)   ;  BAR is a symbol
SYMBOL

? (symbol-function 'bar)  ; the symbol BAR has a function binding
#<Compiled-function BAR #x302000D1B21F>

When using early binding between Ada and a database-stored procedure, a timestamp is checked to verify that the stored procedure has not changed since the code was compiled. This allows for faster executions and prevents the application from running against the wrong version of a stored procedure.^[8]

When using late binding the timestamp check is not performed, and the stored procedure is executed via an anonymous PL/SQL block. While this can be slower, it removes the need to recompile all of the client applications when a stored procedure changes.

This distinction appears to be unique to PL/SQL and Ada. Other languages that can call PL/SQL procedures, as well as other database engines, only use late binding.

Dynamic linking (and related dynamic linkage) is a form of late binding for importing a code library.

This section may contain original research. Please improve it by verifying the claims made and adding inline citations. Statements consisting only of original research should be removed. (July 2019) (Learn how and when to remove this message)

This "criticism" or "controversy" section may compromise the article's neutrality. Please help integrate negative information into other sections or remove undue focus on minor aspects through discussion on the talk page. (May 2024)

Late binding has poorer performance than an early bound method call. Under most implementations, the correct method address must be looked up by name with each call, requiring relatively expensive dictionary search and possibly overload resolution logic. In most applications, the extra compute and time required is negligible on modern computers.

For some compilers, late binding may prevent the use of static type checking. When making a late bound call, the compiler has to assume that the method exists. This means a simple spelling error can cause a run-time error to be thrown. Modern compilers avoid this by ensuring that every possible call must have an implementation during compilation.

Late binding may prevent forms of static analysis needed by an integrated development environment (IDE). For example, an IDE's "go to definition" feature may not function on a late-bound call, if the IDE has no way to know which class the call may refer to. A modern IDE easily solves this especially for object-oriented languages since a late-bound method always specifies an interface or base class, which is where "go to definition" leads, and "find all references" can be used to find all implementations or overrides.^[9]

• Binding time
• Name binding