Functions are the workhorses of programming. They allow you to encapsulate a specific task and reuse it. To perform their task, functions often need input data from the part of the code that calls them. The way this data is transferred to the function's parameters is crucial because it dictates whether the function can modify the original data or just work with a copy.

1. Pass by Value (The Immutability of a Copy):
2. Core Principle: When a parameter is passed by value, the actual value of the argument at the time of the function call is copied into a new, separate memory location specifically created for that parameter within the called function's private workspace (its activation record).
3. Mechanism:
   • At the call site (where the function is invoked), the value of the actual argument expression is computed.
   • This computed value is then physically copied onto the runtime stack (or into a register, depending on optimization and calling conventions) as part of setting up the called function's environment.
   • Inside the called function, the parameter essentially becomes a new local variable, initialized with this copied value.

• Behavior and Implications:
  • Local Modification Only: Any modifications made to the parameter within the function are applied only to this local copy. The original variable in the calling scope remains completely unchanged. This provides strong isolation; the function cannot inadvertently alter the caller's data.
  • Safety and Predictability: This is considered the safest parameter passing mechanism because it prevents side effects on the caller's variables. It makes functions easier to reason about and debug.

• Overhead for Large Data: For very large data structures (like a huge array or a complex object), copying the entire structure can be computationally expensive and consume significant memory.
  • Default for Many Languages: Many popular languages (e.g., C for primitive types, Java for primitive types and object references, Python for all types) use pass-by-value as their default or only mechanism. Even when passing objects in Java, it's the reference to the object that's passed by value (meaning the copy is of the memory address, not the object itself), allowing modifications to the object through that copied reference.

• Example (C-like Language):

void modifyValue(int num) { // 'num' is a local copy
 num = num * 2;
 printf("Inside modifyValue: num = %d\\n", num); // Prints the modified copy
}
int main() {
 int originalNum = 10;
 modifyValue(originalNum); // originalNum's value (10) is copied to 'num'
 printf("Outside modifyValue: originalNum = %d\\n", originalNum); // originalNum is still 10
}

1. Pass by Reference (The Direct Access/Alias):
2. Core Principle: Instead of copying the value, the function receives a direct reference (essentially, the memory address or a pointer) to the original variable in the caller's memory. Both the formal parameter inside the function and the actual argument in the caller now refer to the exact same memory location.

• Mechanism:
  • At the call site, the memory address of the actual argument is determined.
  • This memory address is then passed (often by value, meaning the address itself is copied) to the called function.
  • Inside the called function, whenever the formal parameter is accessed, the compiler generates code to "dereference" this address, accessing the original memory location.

• Behavior and Implications:
  • Direct Modification: Any changes made to the parameter inside the function directly modify the original variable in the calling scope. The parameter acts as an alias for the original variable.
  • Efficiency for Large Data: This method is highly efficient for passing large data structures because only a small memory address (typically 4 or 8 bytes) is copied, not the entire structure.

• Potential for Side Effects: Because functions can modify caller's data, it requires careful programming to avoid unintended side effects, which can make debugging more challenging.
  • Common in C++, C (with pointers), Pascal, C# (ref/out), Swift (inout): These languages explicitly support pass-by-reference to allow functions to modify arguments.

• Example (C++-like Language with reference parameter):

void modifyReference(int #_ref) { // num_ref is a reference to an int
 num_ref = num_ref * 2;
 printf("Inside modifyReference: num_ref = %d\\n", num_ref); // Prints the modified original
}
int main() {
 int originalNum = 10;
 modifyReference(originalNum); // originalNum itself is passed by reference
 printf("Outside modifyReference: originalNum = %d\\n", originalNum); // originalNum is now 20
}

1. Pass by Name (The "Macro-like" Substitution - Historical Context):
2. Core Principle: This mechanism (most famously used in Algol 60) doesn't pass a value or a fixed reference. Instead, it effectively passes an expression (a "thunk" or "closure") that represents the actual argument. Every time the formal parameter is accessed within the called function, the actual argument expression is re-evaluated in the caller's environment (scope).

• Mechanism:
  • Instead of computing a value or an address at the call site, the compiler generates a small piece of code (often called a "thunk") that, when executed, will compute the value of the actual argument.
  • This "thunk" (and the environment in which it should be evaluated) is passed to the called function.
  • Inside the called function, whenever the formal parameter is used, this "thunk" is invoked, causing the original actual argument expression to be evaluated again.

• Behavior and Implications:
  • Delayed Evaluation & Side Effects: This leads to a "call-by-need" or "lazy evaluation" semantic. The argument is only evaluated when it's actually used. More importantly, if the actual argument expression involves variables that change between different evaluations, the parameter's "value" will also change dynamically within the function. This is the source of its power and its notorious complexity.

• Complexity and Predictability Issues: The dynamic re-evaluation makes it extremely difficult to reason about and debug, especially when side effects are involved. It can lead to surprising and subtle bugs.
  • Performance Overhead: Repeated re-evaluation of complex expressions can be less efficient than evaluating them once and passing the result.
  • Rarity in Modern Languages: Due to its complexity and the availability of clearer alternatives (like explicit closures, lambda functions, or specialized lazy evaluation constructs), pass-by-name is almost never the default or primary mechanism in modern mainstream programming languages.

• Conceptual Example (Illustrating a "Jensen's Device" scenario):
  Imagine a function sum(index_var, expression):

   real procedure sum (i, expr);
   value n;
   integer i, n;
   real expr;
   begin
   real S;
   S := 0;
   for i := 1 step 1 until n do S := S + expr;
   sum := S;
   end;
   // Call:
   begin
   integer k;
   real A[1:10]; // Assume A is initialized
   ...
   print (sum(k, A[k] * k)); // k is passed by name, A[k]*k is passed by name
   end;