In computer programming, eager evaluation or greedy evaluation is the evaluation strategy used by most traditional programming languages. In eager evaluation, an expression is evaluated as soon as it is bound to a variable. An alternative to eager evaluation is lazy evaluation, where expressions are evaluated only when a dependent expression is evaluated.[clarification needed]
One advantage[clarification needed] of eager evaluation is that it eliminates the need[clarification needed] to track and schedule the evaluation of expressions. It also allows the programmer to dictate the order of execution, making it easier to control when sub-expressions (including functions) within the expression will be evaluated, as these sub-expressions may have side effects that will affect the evaluation of other expressions.
Disadvantages of eager evaluation[clarification needed] are that it forces the evaluation of expressions that may not be necessary at run time, and it may delay the evaluation of expressions that have a more immediate need. In imperative languages, it also forces the programmer to organize the source code for optimal order of execution. Conversely, it allows the programmer to order the source code to control the order of execution.
Many modern compilers are capable of re-ordering execution to better optimize processor resources and can often eliminate unnecessary expressions from being executed entirely, if it can be determined that the results of the expressions are not visible to the rest of the program. Therefore, the notions of purely eager or purely lazy evaluation may not be applicable in practice.[clarification needed]