Static Call vs Dynamic Call in Cobol with example

Static Call vs Dynamic Call in COBOL: Key Differences, Examples, and Best Practices

Understanding static vs dynamic calls in COBOL is essential for COBOL developers who want to build efficient, maintainable, and high-performing applications.We can identify program calls by looking into the CALL statement in the code. Let’s explore the difference between static and dynamic calls, and understand when and why to use each.

---

1. Static Call in COBOL

In a static call, the compiler binds the calling and called program modules together during compile/link time. The programs maintain this fixed relationship until a developer changes one of them, requiring the entire set to be recompiled and relinked.

Example:

CALL 'PGM1'.

Here, the program PGM1 is directly referenced in the CALL statement.

Characteristics of Static Calls

Single Load Module

All programs are combined into one load module.

Example:

• PGM-A statically calls PGM-B
• PGM-A statically calls PGM-C

Result:

• One load module contains PGM-A, PGM-B, and PGM-C.

Faster Execution

The compiler resolves the program reference during compilation. Consequently, the application does not need to perform a runtime lookup.

Larger Memory Footprint

All linked programs load together when the application starts. Therefore, static calls generally consume more storage and virtual memory.

Higher Maintenance Effort

When developers modify a called program, they usually need to recompile and relink the entire application. As a result, maintenance can become more time-consuming in large systems.

Advantages of Static Calls

• Faster execution performance
• Simple implementation
• Suitable for tightly coupled applications

---

2. Dynamic Call in Cobol

In contrast, a dynamic call allows the application to determine the target program at runtime. Instead of resolving the program name during compilation, the runtime environment resolves it when the CALL statement executes..

Example:

01 WS-PGM PIC X(08).  *> Working storage variable
MOVE 'PGM1' TO WS-PGM
CALL WS-PGM

Here, WS-PGM is a working-storage variable populated with the name of the program to call at runtime.

Characteristics of Dynamic Calls

Separate Load Modules

Developers maintain each program as a separate load module. For example, PGM-A can dynamically call PGM-B and PGM-C. Consequently, the application uses three independent load modules.

Example:

• PGM-A dynamically calls PGM-B
• PGM-A dynamically calls PGM-C

Result:

• Three separate load modules are maintained.

Greater Flexibility

Applications can call different programs based on business logic or configuration values.

Reduced Memory Usage

The system loads only the programs required for execution.

Easier Maintenance

Individual programs can be compiled and deployed independently.

Advantages of Dynamic Calls

• Easier program maintenance
• Smaller main load modules
• Better modularity and flexibility
• Independent program deployment

---

3. Choosing Between Static and Dynamic Calls

• Static call: Best for small, simple programs where execution speed is critical.
• Dynamic call: Better for larger or complex programs, or when incremental maintenance is desired.

Summary Table:

Feature	Static Call	Dynamic Call
Binding	Compile/link time	Runtime
Load modules	Combined into one	Separate
Execution speed	Faster	Slightly slower
Disk/virtual space	Larger	Smaller
Maintenance	Must recompile all if one changes	Individual program can be recompiled
Use case	Small programs, performance-critical	Large programs, maintainability

---

4. Compiler Options

• NODYNAM
  • CALL 'PGM-A' → Static call
  • CALL WS-VARA → Dynamic call
• DYNAM
  • CALL 'PGM-A' → Dynamic call
  • CALL WS-VARA → Dynamic call

---

✅ Key Takeaways:

• Use static calls for fast execution and tightly coupled small programs.
• Use dynamic calls for flexibility, smaller main modules, and easier maintenance.
• Compiler options can override default behavior, so always check your environment.