Function (computer programming) facts for kids

In computer programming, a function (also called a subroutine or procedure) is like a mini-program inside a bigger program. It's a set of instructions that does a specific job. You can use this mini-program many times in different parts of your main program.

Imagine you have a recipe for baking a cake. The whole recipe is your main program. If you often need to mix ingredients, you could write a smaller, separate recipe just for "mixing." This "mixing" recipe would be your function. You can then use it whenever you need to mix things, without writing all the steps again.

Functions can be part of your main program or stored in special collections called libraries. These libraries can be used by many different programs. In some programming languages, functions might be called "routines," "subprograms," or "methods." Even though these names can be a bit different, they all refer to a block of code that you can call to do a task.

A function is designed so it can be used multiple times. It can even be called from other functions! When a function finishes its job, it "returns" to where it was called from. It then continues the main program from that point.

The idea of functions was first thought of by John Mauchly and Kathleen Antonelli in the 1940s. Later, Maurice Wilkes, David Wheeler, and Stanley Gill helped make the idea more formal. Even Alan Turing had similar ideas around the same time.

Functions are a very powerful tool in programming. Using them wisely helps make big programs easier to build and fix. They also make programs more reliable. Functions are often grouped into libraries, which helps programmers share and reuse code. In object-oriented programming, functions are called "methods" and are linked to specific "objects."

What are Functions?

The main part of a function is its "body." This is the actual code that runs when you "call" or "invoke" the function.

Giving Information to Functions

Functions often need some information to do their job. This information is called parameters or arguments. When you call a function, you give it specific values for these parameters. For example, a function that adds two numbers would need two numbers as parameters.

Different programming languages have different ways of giving these values to functions:

• Passing by Value: The function gets a copy of the value. If the function changes this copy, it doesn't change the original value outside the function.
• Passing by Reference: The function gets a direct link to the original value. If the function changes this value, the original value outside the function also changes.

Function Side Effects

Sometimes, a function does more than just return a value. It might also change things in the computer's memory. Or it might read from or write to a device like a printer. These extra actions are called "side effects."

For example, a function that generates a random number will give you a different number each time you call it. This is a side effect. Functions with side effects are common in languages that focus on step-by-step instructions.

Functions Calling Themselves

A cool thing about functions is that they can sometimes call themselves. This is called "recursion." It's like a set of Russian nesting dolls, where each doll contains a smaller version of itself. Recursion is useful for solving problems that can be broken down into smaller, similar parts.

Functions for Yes/No Questions

A function that only answers a "yes" or "no" question is sometimes called a "predicate." For example, a function that checks if a number is even would be a predicate.

Functions That Don't Return Values

A function that doesn't give back a specific value (or returns a "null" value) is often called a "procedure." Procedures usually change their arguments or do something else, like printing text on the screen.

Why Use Functions?

Breaking a program into smaller functions has many benefits:

• Simplifies Complex Tasks: You can break down a big, tricky problem into smaller, easier-to-manage steps.
• Reduces Repeated Code: Instead of writing the same code many times, you write it once in a function and reuse it.
• Code Reuse: Functions can be used in many different programs, saving time and effort.
• Teamwork: Large programming projects can be divided among different programmers, with each person working on specific functions.
• Hides Details: Functions can hide the complicated details of how they work. You just need to know what the function does, not how it does it.
• Easier to Read: Giving a function a good, descriptive name makes your code much easier to understand.
• Easier to Fix Bugs: If something goes wrong, it's easier to find the problem in a small function than in a huge block of code.

Challenges with Functions

Calling a function takes a tiny bit of extra time and effort for the computer. This is called "computational overhead." The computer needs to do some "housekeeping" tasks, like remembering where to return to after the function finishes.

How Functions Evolved

The idea of functions developed over time. Early computers didn't have special instructions for functions. Programmers had to manually set up the steps to call and return from a function.

Konrad Zuse's Z4 computer in 1945 had some early forms of subroutines. Alan M. Turing also talked about similar ideas in 1945. John Mauchly and Kathleen Antonelli worked on these concepts for the ENIAC computer during World War II. They used functions to help calculate missile paths.

Over time, computers got special instructions to make calling functions easier and faster. This helped programmers use functions more often.

Libraries of Functions

Even in the early days, functions were very useful. They allowed programmers to reuse code. Since computer memory was very limited, functions helped save space by avoiding repeated code.

Early computers often loaded programs from punched paper tapes or punched cards. Each function could be on its own piece of tape or set of cards. This meant the same function tape could be used in many different programs. This is where the idea of a "subroutine library" came from – a collection of tapes or cards with useful functions.

The Call Stack

Most modern computers use something called a "call stack" to manage functions. Imagine a stack of plates. When you call a function, a new "plate" (called a "stack frame") is added to the top of the stack. This plate holds all the function's private information, like its parameters and where to return to.

When the function finishes, its plate is removed from the stack. This system is great because it saves memory. It also allows functions to call themselves (recursion) because each call gets its own separate "plate" of information.

Examples of Functions

Let's look at how functions are written in some popular programming languages.

C and C++

In C and C++, functions are simply called "functions." If a function doesn't give back a value, we use the word `void`.

void SayHello() {
  // This function just prints a message
  printf("Hello, world!\n");
}

To use this function, you would just type `SayHello();`.

int AddNumbers(int num1, int num2) {
  // This function adds two numbers and returns the total
  return num1 + num2;
}

You could use this function like this: `int sum = AddNumbers(5, 3);` (which would make `sum` equal to 8).

BASIC Dialects

Microsoft Small Basic

CallGreeting() ' This calls our function

Sub CallGreeting ' This is where we define the function
    TextWindow.WriteLine("Welcome to Small Basic!")
EndSub           ' This marks the end of the function

Visual Basic (classic)

In Visual Basic (classic), you can have `Function` (which returns a value) or `Sub` (which doesn't).

Private Sub ShowMessage()
    ' This function just displays a message
    MsgBox "Hello from Visual Basic!"
End Sub

You would call this like: `ShowMessage`.

Private Function GetSquare(ByVal number As Integer) As Integer
    ' This function calculates the square of a number
    GetSquare = number * number
End Function

You could use this like: `Dim result As Integer = GetSquare(7)` (result would be 49).

Python

In Python, you use the keyword `def` to define a function. The code inside the function must be indented.

def greet(name):
    # This function prints a personalized greeting
    print("Hello, " + name + "!")

greet("Alice")
# Output: Hello, Alice!

def calculate_area(length, width):
    # This function calculates the area of a rectangle
    area = length * width
    return area

room_area = calculate_area(10, 5)
print(room_area)
# Output: 50

Local Variables and Recursion

Functions often need a temporary space to store information while they are running. This space holds "local variables." These variables only exist inside that function and are forgotten when the function finishes.

When a function calls itself (recursion), each new call gets its own fresh set of local variables. This means one call won't mess up the variables of another call that's waiting to finish. This is very important for recursion to work correctly.

Function Overloading

Sometimes, you might want to have several functions with the same name, but they do slightly different things based on the type or number of inputs they receive. This is called "function overloading."

For example, you might have an `Area` function that calculates the area of a rectangle (taking length and width) and another `Area` function that calculates the area of a circle (taking a radius). The computer knows which `Area` function to use based on the information you give it.

#include <iostream>

// Function to find the area of a rectangle
double Area(double height, double width) {
  return height * width;
}

// Function to find the area of a circle
double Area(double radius) {
  return radius * radius * 3.14;
}

int main() {
  double rectangle_area = Area(3, 4); // Calls the rectangle Area function
  double circle_area = Area(5);       // Calls the circle Area function

  std::cout << "Area of a rectangle is " << rectangle_area << std::endl;
  std::cout << "Area of a circle is " << circle_area << std::endl;
}

Good Programming Habits for Functions

Programmers have developed some good habits for writing functions:

• Clear Naming: A function's name should describe what it does. If it performs an action, its name might be a verb (like `calculate_total`). If it asks a question, it might be an adjective (like `is_valid`).
• One Job Per Function: Many programmers believe a function should do only one specific task. If a function starts doing too many things, it's often better to split it into smaller, more focused functions. This makes the code easier to understand and maintain.
• Independent Functions: Functions should rely as little as possible on other parts of the code. For example, using too many global variables (variables that can be accessed anywhere) can make functions less independent. It's often better to pass necessary information to a function through its parameters.