Functions 1: Introduction to Compiled and Interpreted Code

Introduction to Functions

• Functions are "self-contained" modules of code that accomplish a specific task.
• Functions take in data, process it, and return a result.
• Functions can be called from the inside of other functions.

Why Write Functions?

• Functions allow us to break down a program into smaller sub-steps.
• Functions enable code reuse instead of rewriting it.
• Functions keep the variable namespace clean by limiting local variables to the function's scope.
• Functions allow testing small parts of a program in isolation.

Steps to Write a Function

• Understand the purpose of the function.
• Define the data that comes into the function from the caller (in the form of parameters).
• Define the data variables needed inside the function to accomplish its goal.
• Decide on the set of steps to accomplish the function's goal (the algorithm).

Pure and Impure Functions

Pure Functions

• A pure function's return value is based only on the passed arguments and not on any other outside state.
• The function does not modify its arguments or any global variables (i.e., there are no side effects).
• For the same input, the function will always produce the same output.

Example of Pure Function

• A simple function sum(a, b) where a and b are numbers.
• The return value is the sum of a and b.
• The function is pure because it depends only on the input values, doesn't change any state, and doesn't produce side effects.

Impure Functions

• An impure function is a function that has side effects or doesn't always return the same output when given the same input.
• Side effects can include modifying a global variable, changing the state of an object, or making a network request.
• Impure functions are harder to reason about and test because they have hidden dependencies and can produce different outputs for the same input.

Example of Impure Function

• A function updateMyName(newName) that modifies an external state (myNames).
• The function is impure because it contains code that mutates an external state, giving it side effects.

Benefits of Pure Functions

• No Side Effects: The function doesn't change anything in the program's state.
• Parallel Execution Capability: Multiple instances can be executed simultaneously on different cores without conflicts.