CSC/ECE 517 Fall 2007/wiki1 2 pk

Callbacks

A callback is executable code that is passed as an argument to other code. It allows a lower-level software layer to call a subroutine (or function) defined in a higher-level layer. A callback can be used as a simpler alternative to polymorphism and generic programming, in that the exact behavior of a function can be dynamically determined by passing different (yet compatible) function pointers or handles to the lower-level function. This can be a very powerful technique for code reuse.

Normally a callback uses such a parameter as a pointer to application data outside its own scope. This feature is necessary only in a statically scoped language like C or C++ . Dynamically scoped languages (like Ruby and Small Talk) can provide access to application data automatically via closures.

Closures are functions which are evaluated in an environment containing bound variables. They are blocks of code which meets three criteria:

• They can be passed around as a value and
• They can be executed on demand
• They can refer to variables from the context in which it was created

Closures were initally developed in the 1960s in a language called Scheme and later adopted in other languages including Ruby and Smalltalk.

Examples

Assume, we have list of employees and we want to find the list of employees who are managers. The following ruby code shows how this can be done with closures.

def managers(emps)
  return emps.select {|e| e.isManager}
end

However, the biggest advantage of closures is that they can refer to the variables which were visible at the time they were defined. An small example using closures is shown below, where we pick the employees who have a salary greater than a thershold.

def highPaid(emps)
  threshold = 150
  return emps.select {|e| e.salary > threshold}
end

Closures can also refer to the arguments of the function in which it is defined. For example, conside the ruby code snippet below.

def paidMore(amount)
  return Proc.new {|e| e.salary > amount}
end

The binding to amount argument remains even after