Main program/
Subroutine
FOR REFERENCE ONLY
•In programming, a main program and a
subroutine (also called a function,
procedure, or method, depending on the
language) work together to structure a
program efficiently. They help improve
code organization, reusability, and
readability.
•The main program is the central part of
a software application that controls the
overall flow of execution. It is where the
execution starts and typically
coordinates the use of subroutines.
Key Characteristics of a Main
Program
• Entry Point: The execution of the program starts
from the main program.
• Controls Flow: It calls subroutines when needed.
• Manages Data Flow: It may pass data to subroutines
and handle returned values.
• Often Minimal Logic: Ideally, the main program
should not contain complex logic but should delegate
tasks to subroutines.
Example of a Main Program (Python)
• def add_numbers(a, b): # Subroutine
• return a + b
• def main(): # Main Program
• num1 = 10
• num2 = 20
• result = add_numbers(num1, num2) # Calling subroutine
• print("The sum is:", result)
• if __name__ == "__main__":
• main() # Execution starts here
Subroutine(Function/Procedure)
• A subroutine is a block of code that performs a
specific task. It is designed to be reusable and can be
called multiple times from different parts of the
program.
• Types of Subroutines
• Functions: Return a value after execution.
• Procedures (Void Functions): Perform an action but
do not return a value
Key Characteristics of a Subroutine
•Encapsulation: Groups related code into a single unit.
•Reusability: Can be called multiple times to
perform a task.
•Modularity: Helps in breaking down a large
program into smaller parts.
•Parameter Passing: Can accept input values
(arguments) and return results.
Example of a Subroutine (Python)
• def multiply_numbers(x, y): # Function with return value
• return x * y
• result = multiply_numbers(5, 4) # Calling the function
• print("Multiplication result:", result)
Example of a Subroutine (C++)
• #include <iostream>
• using namespace std;
• int multiply(int a, int b) { // Function with return value
• return a * b;
• }
• int main() {
• int result = multiply(5, 4); // Calling the function
• cout << "Multiplication result: " << result << endl;
• return 0;
• }
Thinks to remember….
• The main program is the entry point and controls
the overall execution.
• Subroutines help structure the program by
breaking it into smaller, reusable blocks.
• Using subroutines makes programs modular,
efficient, and maintainable.
Java Virtual Machine (JVM)
architecture
Class Loader
• Loads class files into the JVM.
• Responsible for linking classes and preparing them for execution.
Method Area
• Stores class metadata, including method code and runtime constants.
Heap
• Stores objects created during execution.
• Shared among all threads.
Java Stacks
• Each thread has its own stack.
• Stores frames that contain method calls, local variables, and partial
results.
PC (Program Counter) Registers
• Keeps track of the current instruction being executed by each thread.
Native Method Stacks
• Stores native method information, which is used when Java interacts
with native code (e.g., C, C++).
• Execution Engine
-Core of the JVM, responsible for executing bytecode.
-Works with memory areas (heap, stack, method area, etc.).
• Controller (Inside Execution Engine)
-Directs the execution of bytecode instructions.
• Instructions (A, B, C, Z, etc.)
-Represents different bytecode instructions being executed by the
engine.
Overall Flow
• Class files are loaded by the Class Loader.
• The loaded classes are stored in the Method Area.
• Objects are created and managed in the Heap.
• Each thread has its own Java Stack and PC Register.
• The Execution Engine fetches and executes instructions.
• If required, Native Method Stacks handle native code
execution.
