4.1.2. Unit Summary

So, basically as we have told that procedure is a self-contained computer program which is a part of a larger program. So, whenever a procedure is called basically it invokes a jump to the memory location or where the first instruction of the procedure is placed. So, it is some form of an unconditional jump.

This chunk introduces the idea of a procedure in programming. A procedure is like a mini-program that performs a specific task within a larger program. When we want to use this mini-program, we call it, which means the computer jumps to a specific location in memory where this procedure begins. This jump is generally unconditional, meaning it happens without conditions—it's straightforward.

Think of a procedure as a recipe in a cookbook. When you want to make a dish, you turn to the recipe (the specific procedure) and start following it. Just like you jump to that page in the book, the computer jumps to the memory location when calling a procedure.

But sometimes you can also have a procedure whose call may be depending on some condition. In that case, you have to call the procedure based on some conditional instruction.

While most procedure calls are unconditional, meaning they always happen, there are situations where a procedure's call can depend on specific conditions being met. For example, if a certain variable equals zero, the program might call a specific procedure; otherwise, it will skip it. This introduces the concept of conditional jumps.

Imagine you're deciding whether to go for a jog. If it’s sunny, you choose to jog; if it’s raining, you decide to stay inside. Similarly, in programming, the computer decides whether to call a procedure based on certain conditions.

when you are leaving your main program then; obviously, you want after executing the procedure you have to come back to the main program and start executing from that point. So, you have the save the context of the program when you are jumping to a subroutine.

Before calling a procedure, the computer saves the current context of the main program. This includes the current values of variables and registers, so that once the procedure completes, the program can resume exactly where it left off. This process of saving the context often involves using a stack.

Think of this as marking your place in a book before putting it down to tackle an errand. When you finish your errand and come back, you can easily find the exact page you left off.

the whole context of the program has to be saved in a stack. So, very very important components of the stack are basically we call it as the program status word which will have all the values of the flags, which will have the value of the program counter or in other words the context of the current program has to be stored in a stack when you are calling a procedure.

A stack is a special type of storage that helps organize the information needed when a procedure is called. This stack holds all kinds of important data such as the program counter (which tells where in the code you are), status flags, and register values that may change during the procedure's execution. When returning from the procedure, all this information is retrieved from the stack.

Imagine a stack of trays in a cafeteria. Each tray might hold a different meal. When a visitor wants to serve themselves, they take the top tray. When they finish, they return the tray to the top of the stack. Similarly, as the computer calls and returns from procedures, it stacks and retrieves context information like a cafeteria worker handling trays.

when you are returning to the returning from the procedure all the values of the context like the value of the program counter, the value of the registers etcetera are fed back to the corresponding registers and the program and the program counter so that you gain the real context from what I have left in the main program and you can start re executing.

After a procedure completes its task, the values of the program counter and registers which were saved earlier are restored. This allows the main program to continue executing right where it left off, as if the procedure was simply a pause in the main program's flow.

This is similar to temporarily stepping out of a meeting to take a phone call and then returning to the meeting. You would pick up exactly from where you left off without missing a beat.

if they are nested procedure as we will see in an example, so procedure a will call procedure b, procedure b will call procedure c and at every call the context of the calling procedure will be stored in a stack.

In programming, it's common to have procedures call other procedures, creating a hierarchy of calls—this is called nesting. Each time a procedure calls another, the context of the calling procedure needs to be saved in the stack. This ensures that when the innermost procedure finishes and returns, control goes back to the correct calling procedure, maintaining the order and context of execution.

Think of a nested sequence of events like making a layered cake. You might need to bake one layer at a time and stack them on top. Each layer represents a procedure called, and you must ensure not to lose track of which layers are already done so you can complete the cake correctly.

--