Introduction

Programming becomes messy when everything is written in one giant block. To avoid chaos, programmers break a big program into smaller, meaningful pieces.
This idea is called Modular Programming.

In modular programming:

• A big program is divided into modules (small blocks).
• Each module performs a specific task.
• There is always one main module and many optional sub-modules.
• A module is also called a procedure.
• This makes programs easier to read, understand, test and reuse.

Advantages of Modular Programming

1. Different programmers can work on different modules at the same time.
2. Errors are easier to find and fix.
3. Same module can be used again in other parts of the program.
4. The program becomes clear and easier to read.
5. Designing, modifying and updating code becomes simple.

Main Module and Sub-Modules

Main Module: The starting part of the program.

Sub Modules: Smaller blocks created to perform special tasks (like calculating, printing, checking, etc.)

Diagram:

Modular Programming in QBASIC

QBASIC supports modular programming in 2 ways:

1. Sub-procedure (SUB…END SUB)
2. Function-procedure (FUNCTION…END FUNCTION)

A) SUB-PROCEDURE

What is a Sub-procedure?

A sub-procedure is a small part of a program that performs a task but does NOT return any value to the main module.

Written as:

A sub-procedure must be:

Declared

Defined

Called

1. Declaration Part

Before using a sub-procedure, we declare it using DECLARE SUB.

Syntax:

2. Definition Part

This is the block where we write the actual code for the sub-procedure.

Syntax:

3. Calling the Sub-Procedure

We use CALL from the main module.

Syntax:

Example:

Complete Example (Sum of Two Numbers)

Call by Reference and Call by Value

1. Call by Reference (Default)

The memory address of the variable is passed.

Changes in sub-module affect main-module.

Example Output: 15 10

2. Call by Value

Only the value is sent.

1. Changes inside sub-module DO NOT affect main module.
2. Done by using double parentheses.
3. Example Output: 5

Formal Parameter vs Actual Parameter

Formal Parameters:
Variables used in the DECLARE and SUB/FUNCTION definition.

Actual Parameters:
Real values passed during CALL (from main program).

Local and Global Variables

Local Variable

Declared inside a module.

Only works inside that module.

Global Variable

Can be used in all modules.

Declared using:

1. COMMON SHARED (main module)
2. DIM SHARED (main module)
3. SHARED (inside sub-module)

Examples of Sub-Procedures

Area of Circle

Multiplication Table

Odd/Even Check

First 10 Natural Numbers

Palindrome Check

Area and Volume of Room

(These are already included above; rewritten explanations available if needed.)

B) FUNCTION-PROCEDURE

Functions are like small machines that:

Take input (parameters)

Perform calculation

Always return a value

Written as:

Declaration of Function

Calling a Function

Two ways:

1. Assign to variable

2. Print directly

Example (Area of Rectangle)

Examples of Function Procedures

1. Simple Interest
2. Circumference
3. Smallest Number
4. Vowel Count
5. Sum of Digits
6. Reverse String
7. Area and Volume

Summary (Exam-Focused Points)

• Modular programming means writing programs in multiple modules.
• Two kinds of modules in QBASIC:
• Sub-Procedure (no return value)
• Function-Procedure (returns value)
• DECLARE SUB and CALL are used for sub-procedures.
• DECLARE FUNCTION and assignment/PRINT are used for functions.
• Sub-procedure uses SUB…END SUB.
• Function uses FUNCTION…END FUNCTION.
• Formal parameters: used during declaration/definition.
• Actual parameters: used during CALL.
• Local variables: work only inside the module they are declared.
• Global variables: accessible from all modules using SHARED.