The 'call-by-name' parameter passing technique re-evaluates the actual parameter every time it is accessed during execution. The advantage of call-by-name is that it defers computation until the expression is needed, which can lead to performance benefits in some scenarios. However, this can also be a disadvantage as it may lead to repeated computations if the parameter is accessed multiple times. A notable issue is that assigning to a formal parameter that is passed by name should be avoided if the actual parameter is an expression, as this may lead to runtime errors .

Nested scopes in block-structured languages allow for a more modular and hierarchical arrangement of code, promoting encapsulation and reuse. This contrasts with languages like Cobol, where all data items are visible throughout the entire program, potentially leading to conflicts and issues with maintaining state across large programs. Nested scopes limit the visibility of variables to the block they are declared in, and potentially inner blocks, which reduces the likelihood of unintended interactions and side effects compared to global scope visibility .

Eager evaluation techniques, such as 'call-by-value' and 'call-by-reference', involve evaluating parameters before a function call is executed, which can simplify the execution flow and reduce overhead at the cost of potentially unnecessary computations. In contrast, lazy evaluation techniques, like 'call-by-name' and 'call-by-need', defer parameter evaluation until the value is actually needed, improving performance in cases where parameters are not always used. However, lazy evaluation can introduce additional complexity in managing and storing computations, and may be less intuitive for developers familiar with imperative evaluation models .

Block-structured languages use a system of nested scopes for variable visibility, where a variable declared in a block is visible within that block and all inner blocks, unless overshadowed by another declaration of the same name in those inner blocks. This contrasts with static binding, which determines variable bindings at compile-time based on lexical structure regardless of execution flow. In static binding scenarios, once an identifier is bound to a declaration, it remains fixed during the execution, usually within a fixed scope determined lexically .

'Call-by-copy-restore', also known as 'call-by-value-result' or 'copy-in-copy-out', combines elements from both 'call-by-value' and 'call-by-reference'. It involves copying the actual parameter's value into the procedure ('copy-in') at the start and then copying the modified value back to the actual parameter ('copy-out') once the procedure finishes. This method is beneficial in scenarios where you want the efficiency of 'call-by-reference' for large data structures, but without allowing the procedure to change the original parameter during execution. It ensures that any changes made within the procedure are reflected outside, but only once the procedure is completed .

Block structured programming languages, such as Algol, Pascal, C, and Java, organize code into blocks that can contain nested blocks. A block consists of a sequence of statements, and it starts with the declaration of variables. Variables declared in a block are visible throughout that block and any nested blocks unless another declaration with the same name exists within a nested block. In such cases, the inner block's declaration takes precedence within that block, while the outer block's declaration is in effect outside it. This nested scope is a contrast to the scope in languages like Fortran, where variables are local to a subprogram or global to several program units if declared as COMMON .

The implementation of 'call-by-name' using thunks is significant because thunks encapsulate the expression to be evaluated, allowing for deferred and repeated execution. By capturing the expression in an anonymous function (or thunk), the evaluation context is preserved, which simplifies delayed evaluations. This approach has implications for language design and efficiency: while it provides flexibility and can optimize resources, it can also add complexity to both implementation and execution, especially if expressions frequently change or involve side effects .

'Call-by-need', an optimization of 'call-by-name', improves program execution efficiency by avoiding repeated evaluations of parameters. Instead of re-evaluating parameters upon every use, 'call-by-need' evaluates the parameter the first time it is needed and caches this result for subsequent uses. This lazy evaluation technique minimizes computation overhead and can lead to significant performance improvements, especially in cases with expensive or resource-intensive calculations .

In block-structured languages, properties of an identifier can be either static or dynamic. Static properties are defined at compile-time and remain unchanged during execution, such as the type of a variable or the body of a function. Dynamic properties, however, are determined at run-time and include the current value of a variable or the number of iterations a loop executes. Static properties are related to the lexical scoping of variables, whereas dynamic properties are often associated with the program's run-time behavior .

In 'call by value', the actual parameter's value is copied and passed to the function, meaning changes to the parameter within the function do not affect the original argument. In 'call by reference', instead of copying, a reference or address of the actual parameter is passed, allowing the function to modify the original argument. The fundamental difference lies in the ability of the function to alter the original data: 'call by reference' allows this, while 'call by value' does not .