Name binding

In programming languages, name binding is the association of entities (data and/or code) with identifiers. An identifier bound to an object is said to reference that object. Machine languages have no built-in notion of identifiers, but name-object bindings as a service and notation for the programmer is implemented by programming languages. Binding is intimately connected with scoping, as scope determines which names bind to which objects – at which locations in the program code (lexically) and in which one of the possible execution paths (temporally). Use of an identifier in a context that establishes a binding for is called a binding (or defining) occurrence. In all other occurrences (e.g., in expressions, assignments, and subprogram calls), an identifier stands for what it is bound to; such occurrences are called applied occurrences. Static binding (or early binding) is name binding performed before the program is run. Dynamic binding (or late binding or virtual binding) is name binding performed as the program is running. An example of a static binding is a direct C function call: the function referenced by the identifier cannot change at runtime. An example of dynamic binding is dynamic dispatch, as in a C++ virtual method call. Since the specific type of a polymorphic object is not known before runtime (in general), the executed function is dynamically bound. Take, for example, the following Java code: public void foo(java.util.List list) { list.add("bar"); } List is an interface, so list must refer to a subtype of it. list may reference a LinkedList, an ArrayList, or some other subtype of List. The method referenced by add is not known until runtime. In C, such an instance of dynamic binding may be a call to a function pointed to by a variable or expression of a function pointer type whose value is unknown until it is evaluated at run-time. Rebinding should not be confused with mutation. Rebinding is a change to the referencing identifier. Mutation is a change to the referenced entity.

About this result

This page is automatically generated and may contain information that is not correct, complete, up-to-date, or relevant to your search query. The same applies to every other page on this website. Please make sure to verify the information with EPFL's official sources.

Related publications (20)

Related units (1)

Related concepts (16)

Related courses (2)

Related lectures (23)

Object-oriented programming

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code. The data is in the form of fields (often known as attributes or properties), and the code is in the form of procedures (often known as methods). A common feature of objects is that procedures (or methods) are attached to them and can access and modify the object's data fields. In this brand of OOP, there is usually a special name such as or used to refer to the current object.

Variable (computer science)

In computer programming, a variable is an abstract storage location paired with an associated symbolic name, which contains some known or unknown quantity of data or object referred to as a value; or in simpler terms, a variable is a named container for a particular set of bits or type of data (like integer, float, string etc...). A variable can eventually be associated with or identified by a memory address. The variable name is the usual way to reference the stored value, in addition to referring to the variable itself, depending on the context.

Anonymous function

In computer programming, an anonymous function (function literal, lambda abstraction, lambda function, lambda expression or block) is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function.

CS-108: Practice of object-oriented programming

Les étudiants perfectionnent leurs connaissances en Java et les mettent en pratique en réalisant un projet de taille conséquente. Ils apprennent à utiliser et à mettre en œuvre les principaux types de

CS-101: Advanced information, computation, communication I

Discrete mathematics is a discipline with applications to almost all areas of study. It provides a set of indispensable tools to computer science in particular. This course reviews (familiar) topics a

Combination of dielectrophoretic and hydrodynamic traps for the controlled contact between cells or beads and application to adhesion assays

Clémentine Sophie Sarah Lipp

Multicellular organisms require very well organized and finely balanced cell-cell communication, adhesion and coordination to ensure the organisms homeostasis. These functions rely on specialized receptors placed at the cells membrane whose binding to thei ...

EPFL2023

Effects of item distinctiveness on the retrieval of objects and object-location bindings from visual working memory

Yury Markov

Visual working memory (VWM) is prone to interference from stored items competing for its limited capacity. Distinctiveness or similarity of the items is acknowledged to affect this competition, such that poor item distinctiveness causes a failure to discri ...

2022

The Unstoppable Rise of Computational Linguistics in Deep Learning

James Henderson

In this paper, we trace the history of neural networks applied to natural language understanding tasks, and identify key contributions which the nature of language has made to the development of neural network architectures. We focus on the importance of v ...

Association for Computational Linguistics2020

Class Hierarchies CS-210: Functional programming

Covers abstract classes, class extensions, object definitions, companion objects, and dynamic binding in Scala.

Predicate Logic: More on Quantifiers CS-101: Advanced information, computation, communication I

Explores quantifiers with finite domains, uniqueness quantifier, composite statements, variable binding, and validity in logic.

The Future: Computational Linguistics and Deep Learning

Explores the influence of computational linguistics on deep learning architectures, covering grammar formalisms, connectionism, variable binding, and future directions.