• Articles
  • Tutorials
  • Interview Questions
  • Webinars

COBOL Interview Questions and Answers

Reviewed and fact-checked by
career-aspirant learners have read this article
Reviewed and fact-checked by
Akash Pushkar
Principal Data Scientist


Introduction to COBOL

A computer programming language that was purpose-built for business is Common Business-Oriented Language (COBOL). Since its creation in 1959, COBOL has played a transformative and indispensable role in supporting businesses worldwide. It is responsible for efficiently, reliably, and securely handling the day-to-day operations of the global economy, often working behind the scenes without drawing much attention. COBOL is extensively used for processing critical data, and many of its programs have undergone decades of enhancements, encompassing improvements in business logic, performance, programming paradigms, and integration with various application program interfaces, transaction processors, data sources, and the Internet.

In this blog, we are going to be laser-focused on the interview questions asked by the top recruiters in COBOL. These questions can help you to learn from basic to advanced.

This blog post is divided into three sections, covering all the concepts of COBOL that you are expected to face while sitting in the hot seat.

1. Basic Cobol Interview Questions and Answers for Freshers

2. Intermediate COBOL Interview Questions and Answers

3. Advanced COBOL Interview Questions

Firstly, let’s discuss some entry-level questions that you can expect during an interview. These questions are easy and can be answered if you have basic knowledge of the topics.

Basic Cobol Interview Questions and Answers for Freshers

1. What is COBOL? What are the main features of COBOL?

COBOL stands for Common Business-Oriented Language. It was developed in the late 1950s as a programming language specifically designed for business applications.

The main features of COBOL are the following:

  • English-Like Syntax: COBOL’s syntax is designed to resemble English, making it easy for programmers to understand and write code.
  • Data Handling: COBOL is well-suited for handling large volumes of data, which is crucial for business applications dealing with extensive datasets.
  • Arithmetic Operations: It provides robust capabilities for performing complex arithmetic calculations, which are essential for financial and scientific computations.
  • Report Generation: COBOL supports the generation of formatted reports, enabling a clear and organized presentation of data.
  • Compatibility: COBOL is designed to be compatible with various hardware and software platforms, ensuring versatility and adaptability.

2. How would you declare variables in COBOL?

In COBOL, variables can be declared using either the level-number or picture clause methods. The level-number method assigns a specific hierarchy to each variable based on its usage within the program, while the picture clause method allows you to define specific rules about what type of data can be stored in each variable.

Get 100% Hike!

Master Most in Demand Skills Now!

3. How can COBOL be used in business?

COBOL, or Common Business Oriented Language, has been a staple programming language in the business industry for over 60 years. It was designed specifically to handle large-scale data processing and is therefore widely used in industries such as banking, finance, insurance, and government.

One of the main ways COBOL is used in business is for legacy systems. Many businesses still rely on older computer systems that were developed using COBOL. These systems are often too expensive or risky to replace entirely, so businesses continue to use them while updating certain parts with newer technologies.

4. How can you implement multi-threading in COBOL programs?

COBOL does not have built-in support for multi-threading. However, if your COBOL program runs under a supporting environment (such as IBM’s z/OS), you can utilize Language Environment (LE) features like Language Environment User-Managed Threads (UMTs) or Asynchronous Concurrency support to achieve multi-threading. These features allow multiple threads of execution within a single COBOL program, enabling concurrent processing and improved performance.

5. What is the difference between CALL and LINK statements in COBOL?

The CALL statement is used to invoke a subprogram or a program at runtime. It transfers control to the called program, and control returns to the calling program after the called program completes execution. On the other hand, the LINK statement establishes direct program-to-program communication and transfers control to the linked program. The control does not automatically return to the calling program after the linked program completes execution, so an explicit RETURN statement is needed to transfer control back.

6. How can you perform dynamic memory allocation in COBOL?

COBOL supports dynamic memory allocation through the CEEGTST and CEEBRK routines, which are part of the Language Environment (LE) services. These routines allow you to dynamically allocate and deallocate memory during program execution. You can call these routines using the CALL statement to allocate memory and retrieve a pointer to the allocated memory area.

7. How can you handle exceptions and errors in COBOL?

COBOL provides the ON EXCEPTION and NOT ON EXCEPTION phrases for handling exceptions and errors. The ON EXCEPTION phrase is used to specify a section of code to execute when an exception occurs, while the NOT ON EXCEPTION phrase defines a section to execute when no exception occurs. Additionally, COBOL provides the FILE STATUS clause to handle file-related errors and the USE AFTER EXCEPTION phrase to handle exceptional conditions for a specific record.

8. What is a COBOL paragraph?

A COBOL paragraph is a user-defined or predefined name followed by a period. It consists of zero or more sentences. It is the subdivision of a “Section” or “Division.”

Example 1. Division -> paragraph -> sentences

COBOL paragraph

9. Mention any three Divisions of COBOL.

  1. Identification Division: The IDENTIFICATION DIVISION identifies the program with a name and, optionally, gives other identifying information, such as the Author’s name, the program compiled date (last modified), etc.
  2. Environment Division: The Environment Division describes the aspects of your program that depend on the computing environment, such as the computer configuration and the computer inputs and outputs.
  3. Data Division: The Data Division is where the characteristics of data are defined in one of the following sections:
  • File Section:

It defines data used in input-output operations.

  • Linkage Section:

It describes data from another program when defining data developed for internal processing.

  • Working-Storage Section:

It is the storage allocated and remaining for the life of the program.

  • Local-Storage Section:

Storage is allocated each time a program is called and de-allocated when the program ends.

10. How do you load a table dynamically in COBOL?

To load a table dynamically, we need to use the PERFORM statement with either subscripting or indexing.

Proper data management is of utmost importance to maintain data within the allocated table space, mitigating the risks associated with data overflow or exceeding capacity.

  1. Determine Table Size: Calculate the size of the table you want to create dynamically based on the data it will hold and the number of records it needs to accommodate.
  2. Allocate Memory: Use appropriate language-specific or system-specific functions to dynamically allocate memory for the table. In COBOL, you can achieve this through techniques like “Working-Storage Section” or “Linkage Section” with POINTER data types.
  3. Read Data: Retrieve the data from an external source (e.g., a file, database, or user input) that you want to load into the table.
  4. Populate the Table: As you read the data, dynamically store it in the memory space allocated for the table. Ensure that you handle the data correctly based on the table’s structure and format.

11. How is COBOL code used for sequential handling?

COBOL code used for sequential file handling involves the following steps:


– SELECT clauses

– ASSIGN clauses


– FD statements


– OPEN statements

– CLOSE statements

– READ INTO statement

– WRITE FROM statement

12. What are datasets, records, and fields?

  • Datasets: Datasets are logical or physical collections of data records. They serve as containers that hold related information, structured in a way that facilitates efficient data access and management. Datasets can represent files stored on disk or datasets maintained within a database system.
  • Records: Records are individual units of data within a dataset. Each record contains a set of related information, representing a single entity or data entry. In a database context, records are equivalent to rows in a table, with each record holding specific attributes or fields.
  • Fields: Fields are the smallest components within a record and represent individual data elements. They store the actual data values corresponding to specific attributes of the entity represented by the record. Fields can be data types like text, numbers, dates, or other formats, depending on the nature of the data they hold.

Understanding datasets, records, and fields is crucial for effective data management and manipulation in various applications, including database systems, file processing, and programming in languages like COBOL.

13. How do COBOL programming techniques read and write records sequentially?

While reading records, the program must initially verify if there are any records left to read. If a record exists, its fields populate variable names as defined by the FD clause. COBOL utilizes a PERFORM statement for iteration. In computer programming, “iterative” refers to a scenario where a sequence of instructions or statements can be executed multiple times. Each pass through the sequence is known as an iteration, and this process is also commonly referred to as a loop. In other programming languages, “DO” or “FOR” statements are employed for iterative execution.


The process of READ-NEXT-RECORD involves continuously executing READ-RECORD and WRITE-RECORD until the last record is reached. Once the last record is encountered, the program proceeds to execute CLOSE-STOP, effectively stopping the program.

14. What are the Arithmetic expression precedence rules?

Order of operation rules have been hammered into your head throughout the years of learning mathematics; remember the classic PEMDAS (parentheses, exponents, multiply, divide, add, subtract)? Arithmetic expressions in COBOL are not exempt from these rules and often use parentheses to specify the order in which elements are to be evaluated.

15. What is an intrinsic function?

Intrinsic functions are effectively re-usable code with simple syntax implementation. Intrinsic functions enable desired logic processing with a single line of code. They also have capabilities for manipulating strings and numbers. Because the value of an intrinsic function is derived automatically at the time of reference, you do not need to define these functions in the DATA DIVISION.

16. What are the categories of intrinsic functions?

The intrinsic functions possess a classification into six distinct categories, which are determined by the nature of the services they provide. They are mathematical, date/time, statistical, character-handling, financial, and general.

In COBOL, intrinsic functions cater to alphanumeric, national, numeric, and integer data items, each belonging to specific classes and categories. Here’s an overview of these functions:

  • Alphanumeric Functions: Belonging to the alphanumeric class and category, these functions return values with an implicit usage of DISPLAY format. The number of character positions in the returned value is determined by the function definition.
  • National Functions: Falling under the national class and category, these functions return values with an implicit usage of NATIONAL format, represented in national characters (UTF-16). The number of character positions in the returned value is determined by the function definition.
  • Numeric Functions: Classified under the numeric category, these functions always return values considered to have an operational sign, resulting in a numeric intermediate result.
  • Integer Functions: Also part of the numeric category, integer functions return values with an operational sign and are treated as integer intermediate results. The number of digit positions in the returned value is determined by the function definition.

By utilizing these intrinsic functions correctly, COBOL programmers can manipulate data more effectively and efficiently, adhering to specific usage and representation requirements based on the function category.

17. Why does ABEND happen?

Unlike your normal workstation, the mainframe utilizes an instruction set architecture called the z/Architecture. This instruction set describes what instructions can be executed at the lower machine code level. In the case that the system encounters an instruction that is not permitted under the instruction set, an ABEND will happen. This can happen during the compilation, link-edit, or execution of your COBOL program.

18. What are the best practices to avoid ABEND?

To avoid ABEND, we can do something called defensive programming. It is a form of programming where we defensively design our code to ensure that it is still running under unforeseen circumstances. By doing defensive programming, we can reduce the number of bugs and make the program more predictable, regardless of the inputs.

Listed below are a few things we can do to avoid ABEND in COBOL:

  • INITIALIZE Fields at the Beginning of a Routine: By using the INITIALIZE statement, you can set all fields to their default initial values, ensuring they start with the correct data at the beginning of the program. However, when using this statement, it’s essential to exercise caution and verify that any flags or accumulators dependent on specific initial values are appropriately initialized to avoid potential errors during program execution.
  • I/O Statement Checking: Implementing I/O statement checking is crucial to handle potential issues related to file operations. This can be achieved by using FILE STATUS variables, which provide information about the success or failure of file-related operations. Before proceeding with any further I/O operation, you should check these FILE STATUS variables to ensure the previous I/O operation was successful.
  • Numeric Field Checking: A general policy would be to not trust a numeric field we are doing math on. Assume that the input is invalid. It would be recommended to use the ON OVERFLOW and ON SIZE ERROR phrases to catch invalid or abnormal data. Special care should be taken when we need to do rounding, as truncation can occur in some cases.
  • Consistent Use of Scope Terminators: It would be best practice to explicitly terminate a scope using scope terminators such as END-IF, END-COMPUTE, or END-PERFORM.
  • Testing, Checking, and Peer-Review: Proper tests and peer review can be conducted to catch possible errors that may have slipped through your program. Additionally, we can also ensure that the business logic is correct.

19. Explain the differences between static and dynamic calls in COBOL.

In COBOL, static and dynamic calls are two different methods of invoking subprograms or procedures. The main differences between them are as follows:

  1. Static Call
  • A static call is resolved at compile time.
  • The target subprogram or procedure is known and specified in the program code during compilation.
  • The linkage editor or binder is used to create a load module that contains the addresses of all called subprograms.
  • The load module is then used at runtime, and the addresses of called subprograms are fixed.
  • Static calls are faster than dynamic calls but provide less flexibility.
  • Static calls are typically used when the program structure is fixed and known at compile time.
  1. Dynamic Call
  • A dynamic call is resolved at runtime.
  • The target subprogram or procedure is determined and specified during program execution.
  • The address of the target subprogram is not known until runtime, and it is looked up dynamically.
  • Dynamic calls provide more flexibility as the target can be determined based on conditions or input data.
  • Dynamic calls are slower than static calls due to the additional runtime address resolution.
  • Dynamic calls are typically used when the program structure is not known at compile time or when flexibility is required.

Learn new Technologies

20. What is the purpose of the INSPECT verb in COBOL, and what are some common scenarios where it is used?

The “INSPECT” verb in COBOL is used to manipulate and transform data within a given data item or group of data items. It provides a powerful set of string and data manipulation functions. Here are some common scenarios where the “INSPECT” verb is often used:

  1. String Manipulation
  • COBOL developers frequently turn to the “INSPECT” verb for its efficient handling of strings, enabling operations such as string concatenation, character replacement, text insertion, and deletion. With its adaptable nature and high effectiveness, the “INSPECT” verb proves indispensable for data transformation tasks in COBOL programming.
  1. Data Validation and Cleansing
  • Within COBOL programming, the “INSPECT” verb assumes a crucial role in data validation and cleansing, enabling developers to effectively manage tasks like removing leading or trailing spaces, validating numeric data, and conducting pattern checks within data items. Moreover, it offers essential features like counting characters or substrings, intelligently replacing characters or substrings based on specific rules, and verifying data item formats. As a result, it significantly enhances the reliability and accuracy of data processing in COBOL applications.
  1. Data Transformation
  • COBOL programs often need to transform data from one format to another, such as converting uppercase letters to lowercase or vice versa, changing date formats, or reformatting numbers.
  1. Parsing and Extracting
  • The “INSPECT” verb can be used to parse and extract specific portions of data from a larger data item based on predefined patterns or delimiters.
  • It allows COBOL programs to extract information like names, addresses, phone numbers, or any other structured data from a given input.

Cobol Interview Questions and Answers for Intermediate

21. What is the difference between a SEARCH and a SEARCH ALL statement in COBOL? When would you use each?

In COBOL, the “SEARCH” statement is utilized for locating a specific value in a table or array, performing a sequential search to find the first occurrence. It transfers control to the appropriate “AT END” or “WHEN” phrase based on the search result, making it suitable for finding a single occurrence of a value and determining its existence.

On the other hand, the “SEARCH ALL” statement is employed when searching for multiple occurrences of a value in a sorted table. It utilizes a binary search algorithm, making it more efficient for large sorted tables, and sets an index to indicate the position of each occurrence within the table. This makes it ideal for scenarios where you need to find multiple instances of a value or determine their positions within the sorted table.

22. What is the purpose of the SET verb in COBOL, and how does it differ from the MOVE verb?

The “SET” and “MOVE” verbs in COBOL serve different purposes in data manipulation.

  • “SET” Verb: The “SET” verb in COBOL is used to assign specific values to variables or data items. It allows you to set a value to a variable, an individual character within a data item, or even a group of related data items in a single statement. The “SET” verb is mainly used to initialize or modify the content of variables during program execution.
  • “MOVE” Verb: The “MOVE” verb is used for the assignment of data from one data item to another. It transfers the entire content of one data item (e.g., variable, field, or record) to another data item of a compatible data type. The “MOVE” verb is commonly used for copying data between variables or for data transfer between different data structures like record-to-record or file-to-file.

In summary, the “SET” verb is used for directly assigning specific values to variables or parts of data items, while the “MOVE” verb is employed for copying entire data items from one location to another. The choice between “SET” and “MOVE” depends on the specific data manipulation requirement in your COBOL program.

23. What is the purpose of the INITIALIZE verb in COBOL, and when would you use it?

In COBOL, the “INITIALIZE” verb proves to be a valuable asset for developers, offering an efficient way to set the initial values of data items or groups. It serves as a convenient solution for tasks like initializing variables, clearing memory, and establishing the starting state of data structures within a program.

  1. Purpose
  • The “INITIALIZE” verb allows you to set one or more data items to their initial or default values.
  • It is particularly useful when you want to ensure that data items start with a known and consistent value before they are used in your program.
  1. Syntax
  • With the “INITIALIZE” verb in COBOL, developers can effortlessly apply it not only to individual data items and groups but also to entire tables or arrays, ensuring efficient initialization of data within various program structures.
  • It follows the general syntax: INITIALIZE data-item-1 [data-item-2 …].
  1. Functionality
  • When the “INITIALIZE” verb is executed, COBOL sets the specified data items to their initial values based on their data types.
  • Numeric data items are typically initialized to zero, while alphanumeric data items are initialized with spaces.
  • For group data items or tables, the “INITIALIZE” verb recursively initializes each component or entry within the structure.

24. What is the purpose of the OCCURS clause in COBOL, and how is it used?

In COBOL, the “OCCURS” clause is used to define arrays or tables, allowing you to group multiple occurrences of the same data item. Here are some key points about the “OCCURS” clause:

  1. Purpose
  • The “OCCURS” clause holds significant significance in COBOL as it empowers developers to define arrays or tables, offering a streamlined approach to managing data collections with shared attributes. By promoting efficiency in data manipulation and contributing to improved readability and maintainability, the “OCCURS” clause remains an essential and valuable aspect of COBOL programming.
  1. Syntax
  • The “OCCURS” clause is typically used in the DATA DIVISION of a COBOL program within the description of a group data item.
  • The general syntax is 88 data-name OCCURS n TIMES [INDEXED BY index-name].
  • “data-name” refers to the name of the group data item that represents the array or table.
  • “n” specifies the number of occurrences or entries in the array or table.
  • The optional “INDEXED BY” phrase allows you to define an index that can be used to access individual elements within the array or table.
  1. Usage
  • The “OCCURS” clause is an essential feature in COBOL, allowing developers to handle multiple occurrences of the same data structure or item efficiently. It finds common usage in managing data collections, processing arrays or tables, and performing calculations on related data groups. This clause serves as a valuable asset, promoting effective and well-organized data management within COBOL programs.
  • By using the “INDEXED BY” phrase, you can define and use an index that allows you to access and manipulate individual elements within the array or table.


Here’s an example of using the “OCCURS” clause:





In this context, the “CUSTOMER-TABLE” represents an array or table with the capacity to hold up to 100 occurrences of “CUSTOMER-INFO.” Each “CUSTOMER-INFO” occurrence consists of two fields: “CUSTOMER-ID” and “CUSTOMER-NAME.” This setup offers an effective means of storing and organizing customer data, enabling developers to manage information related to multiple customers in a well-structured manner within a COBOL program.

25. What is the purpose of ONE SIZE ERROR options in trapping errors?

The “ONE SIZE ERROR” option in error trapping is used to handle arithmetic errors in COBOL programs. When this option is specified, it allows the program to continue execution even if an arithmetic error occurs during a calculation. Instead of immediately terminating the program, the error condition is noted, and the erroneous result is replaced with an implementation-defined value.

Using the “ONE SIZE ERROR” option can be beneficial in situations where minor arithmetic errors may occur. The program can still proceed with its intended functionality without halting. However, it is crucial to handle these errors appropriately to prevent unintended consequences or data inconsistencies in the program’s output.

26. How can you handle file processing errors in COBOL, and what are some of the common FILE STATUS codes used for error identification?

By utilizing the FILE STATUS clause in conjunction with “AT END” and “INVALID KEY” phrases, COBOL programmers can adeptly handle file processing errors, guaranteeing seamless and dependable file operations.

The FILE STATUS codes, including “00,” “10,” “23,” “30,” “35,” “39,” and “46,” play a pivotal role in pinpointing precise error conditions, empowering developers to implement effective error-handling strategies within their COBOL programs. This proactive approach ensures resilient and error-resistant file processing, elevating the overall reliability of the COBOL application.

27. Explain the difference between PERFORM and CALL statements in COBOL. When would you use each, and what are the key considerations in choosing between them?

The “PERFORM” and “CALL” statements in COBOL serve distinct purposes in executing procedures or paragraphs.


  • The “PERFORM” statement is designed for iterative or repetitive tasks, enabling the execution of a specific section of code (a paragraph or a group of paragraphs) repeatedly until a particular condition is met.
  • Controlled using constructs like “PERFORM UNTIL,” “PERFORM VARYING,” or “PERFORM TIMES,” it is ideal for tasks that require executing a set of operations multiple times, such as processing records in a file or iterating over an array.


  • The “CALL” statement is intended for procedural calls or invoking other COBOL programs or external routines.
  • It transfers control to the called program or routine and, once the control returns, allows the calling program to resume from where it left off.
  • “CALL” is well-suited for invoking separate, reusable code segments, including subroutines or COBOL programs residing in different modules.

28. Which mode do you use to operate a sequential file in COBOL?

In COBOL, the “SEQUENTIAL” mode is employed for operating on a sequential file. This mode facilitates sequential access to the file, enabling the reading or writing of records in the order they are stored in the file. Sequential access starts at the beginning of the file and proceeds sequentially to the end, processing one record at a time. It is commonly utilized for files with a predefined record order that necessitates sequential processing, like reading or writing data sequentially to or from a text file.

29. What are SSRANGE and NOSSRANGE?

In COBOL, SSRANGE and NOSSRANGE are compiler directives that control array subscript range checking during program execution.

SSRANGE (Subscript Range Checking)

  • SSRANGE is a compiler option that enables array subscript range checking. When SSRANGE is specified, the compiler performs bounds checking on array indices or subscripts at runtime. If the program attempts to access an element outside the defined boundaries of the array, it triggers a runtime error, helping to prevent array index out-of-bounds errors. SSRANGE adds an extra layer of safety by ensuring that array access is within the permissible limits.

NOSSRANGE (No Subscript Range Checking)

  • NOSSRANGE is another compiler option that disables array subscript range checking. When NOSSRANGE is used, the compiler skips the bounds check during program execution. This means that the program can freely access elements in the array without being restricted by any index boundaries. However, disabling subscript range checking comes with a trade-off; it increases the risk of potential array index out-of-bounds errors if the program does not handle array access carefully.

30. What is a COBOL copybook? What are the benefits of using these?

In COBOL, a copybook is a separate and reusable file that contains data items and record declarations, along with other common elements used in multiple COBOL programs. The copybook serves as a template or blueprint for defining data structures that are shared across various COBOL programs.

Instead of duplicating the same data declarations in multiple programs, the copybook allows programmers to centralize the data definitions in one place. Programs can include the content of the copybook using the “COPY” statement during the compilation process. The “COPY” statement inserts the copybook’s content directly into the source code of the program, as if the data declarations were part of the program itself.

The benefits of using copybooks are the following:

  • Reusability: By defining data structures once in the copybook, they can be shared among different programs, reducing redundancy and ensuring consistency.
  • Maintenance: Any updates or modifications to the data structures can be made in the copybook, and those changes will be automatically reflected in all programs that include it.
  • Readability: Separating data declarations into a copybook makes the main program’s source code more concise and easier to read.
  • Modularization: Copybooks promote modular programming by encapsulating data definitions, making it easier to manage and understand large programs.

Copybooks typically have a “.cpy” file extension and contain data item declarations, record layouts, and sometimes other COBOL statements. However, they do not contain program logic or procedure divisions, focusing solely on providing reusable data structures for multiple programs.

Advanced COBOL Interview Questions

 Let’s discuss some of the Cobol Interview Questions for Experienced

31. Mention three components of COBOL as a business language.

Here are three components of COBOL as a business language:

  • Data Division: The Data Division in COBOL is responsible for defining and describing the data used in the program. It includes data item declarations, record layouts, and file descriptions. This division allows developers to establish the structure and characteristics of the data required for business applications.
  • Procedure Division: The Procedure Division contains the actual procedural logic of the COBOL program. It consists of executable statements that perform data processing, calculations, and business operations. This division is where the main processing logic of the program is implemented to achieve the desired business functionality.
  • File Handling: COBOL has built-in support for file handling, enabling programs to read from and write to files for data input and output. This feature is essential for business applications that frequently involve interacting with external files to manage and process data efficiently.

These three components work together to form the core of COBOL as a business language, providing developers with the tools to define data structures, implement business rules, and manage data effectively in file-based business applications.

32. What are Call By Reference and Call By Content in COBOL?

In COBOL, “Call By Reference” and “Call By Content” are two different mechanisms used for passing data between programs or procedures.

  1. Call By Reference

In “Call By Reference,” the memory address (reference) of the data item is passed to the called program or procedure. This means that the called program operates directly on the original data in the calling program’s memory. Any changes made to the data within the called program will reflect in the original data in the calling program. This direct access to the memory location allows for efficient data manipulation, especially when dealing with large data structures.

Advantages of Call By Reference:

  • Memory-efficient as it avoids data duplication.
  • Allows the called program to modify the original data, making it useful for scenarios where changes in data need to be propagated back to the calling program.
  1. Call By Content (Call By Value)

In “Call By Content,” a copy of the data is passed to the called program or procedure rather than its memory address. The called program works with the copied data, and any changes made to this copy do not affect the original data in the calling program. This approach preserves the integrity of the original data and prevents unintended modifications within the calling program.

Advantages of Call By Content:

  • Ensures data safety by keeping the original data intact in the calling program.
  • Prevents side effects, as any changes made within the called program are confined to the copied data.

33. Which is the default, TEST BEFORE or TEST AFTER, for a PERFORM statement?

In COBOL, the default testing method for a PERFORM statement is “TEST BEFORE.”

With “TEST BEFORE,” the condition specified in the PERFORM statement is evaluated before entering the loop. If the condition is true, the loop’s body is executed, and the loop continues to execute as long as the condition remains true. Once the condition evaluates to false, the loop terminates, and the program proceeds to the next statement after the PERFORM.

It’s essential to keep in mind that if you want to change the default testing method to “TEST AFTER,” you need to explicitly specify it in the PERFORM statement using the “WITH TEST AFTER” clause. Otherwise, the compiler will assume “TEST BEFORE” by default.

34. What is the linkage section, and what do you use it for?

In COBOL, the Linkage Section is a division within the program that defines data items used to pass information between the calling program and the called program or subprogram. It serves as a communication interface between different programs, allowing them to exchange data during program execution.

The Linkage Section is typically placed in the called program or subprogram and contains data items declared using the “LINKAGE SECTION” header. These data items are also known as “parameters” or “arguments.” When the calling program invokes the called program, it passes values to these data items, which are then used within the called program.

Key uses of the Linkage Section are the following:

  • Passing Data: It allows the calling program to pass data or information to the called program for processing or manipulation.
  • Parameter Passing: It enables the passing of parameters (values or references) from the calling program to the called program, providing flexibility in data handling.
  • Returning Results: The called program can also use the Linkage Section to return results or computed values to the calling program.
  • Encapsulation: By using the Linkage Section, programs can be encapsulated as separate, reusable modules, enhancing program structure and maintainability.

35. How do you write a COBOL program that can be used in a distributed environment?

To write a COBOL program that can be used in a distributed environment, consider the following steps:

  • Platform Independence: Write your COBOL code using standard language features to ensure it can be compiled and executed on different platforms without modification. Avoid using platform-specific extensions.
  • Remote Procedure Call (RPC): If necessary, use Remote Procedure Call (RPC) mechanisms to enable communication between distributed components. RPC allows you to invoke procedures or functions in remote systems seamlessly.
  • Performance Optimization: In a distributed environment, network latency and communication overhead can impact performance. Optimize your COBOL program for efficiency and minimize unnecessary data transfers.
  • Documentation: Provide comprehensive documentation for your COBOL program, outlining its interface, data exchange format, and dependencies. This helps other developers understand and integrate your program into their distributed systems.
  • Testing: Thoroughly test your COBOL program in a distributed environment to ensure it functions correctly and meets performance requirements.

By following these guidelines, you can develop a well-designed and adaptable COBOL program that effectively operates in a distributed environment, facilitating seamless communication and interaction with other systems in the network.

36. What is the PIC clause in COBOL?

In COBOL, the “PIC” (Picture) clause is a fundamental element that allows programmers to define the format, data type, and characteristics of data items, ensuring precise data handling and efficient storage within COBOL programs.

37. Describe the role of the ENVIRONMENT DIVISION in a COBOL program and its importance in handling computing environment dependencies.

The “ENVIRONMENT DIVISION” in a COBOL program is a crucial section that describes the aspects of the program that depend on the computing environment in which the program will be executed. It provides essential information to the compiler and runtime system about the specific hardware, software, and file system configurations needed to run the COBOL program successfully.

The “ENVIRONMENT DIVISION” contains two primary sections:

  • CONFIGURATION SECTION: This section specifies the hardware and software environment requirements for the COBOL program. It includes details such as the character encoding scheme, word size, and other machine-specific attributes.
  • INPUT-OUTPUT SECTION: This section defines the files used by the program for input and output operations. It specifies the organization, access mode, and file attributes for each file, ensuring proper interaction with the external data sources.

The following are the importance in handling computing Environment Dependencies:

  • Portability: By defining the program’s environment requirements in the “ENVIRONMENT DIVISION,” developers can ensure that the COBOL program is portable across different computing platforms. It allows the program to adapt to the specific characteristics of the target environment, making it easier to run on various systems without modification.
  • Compatibility: The “ENVIRONMENT DIVISION” enables the COBOL program to interact seamlessly with the underlying operating system and file system. By providing the necessary details about file organization and access methods, the program can read and write data without compatibility issues.

38. How can you handle file status errors in COBOL I/O operations?

Handling file status errors in COBOL I/O operations is crucial to ensure proper error handling and graceful handling of exceptional situations during file processing. To handle file status errors in COBOL, you can use the FILE CONTINUE and FILE EXCEPTION phrases in I/O statements. These phrases allow you to specify different actions based on the status of the file operation.

39. What is COBOL layout?

COBOL layout refers to the structure and organization of data fields within a record or data structure in a COBOL program. COBOL is a language commonly used in business applications, and it is essential to define the layout accurately to handle data properly during file processing.

In COBOL, data files are composed of records, and each record is made up of individual data fields. The layout defines the order, size, and data types of these fields, allowing the COBOL program to correctly read, write, and process the data in the file.

Here’s a brief explanation of the COBOL layout:

  • Data Description Entry (FD Entry): The layout in COBOL is usually defined in the Data Division of the program, specifically in the FILE SECTION and WORKING-STORAGE SECTION.
  • Data Record Description (01 Level): Within the FD entry, each record in the file is described using a Data Record Description. This is defined using a level number of 01. It represents the highest level of data and acts as the container for all the data fields within the record.

Data fields are defined under the 01 level using individual level numbers.

  • Data Fields (Subordinate Levels): Under the 01 level, individual data fields are defined using subordinate level numbers (02, 03, etc.). These fields represent the actual data elements within the record. Each data field is defined with a name, data type (such as alphanumeric, numeric, or binary), and length.

40. What are the differences between a subscript and an index in COBOL?

In COBOL, both subscripts and indexes are used to access elements within an array or table, but they have distinct purposes and characteristics:


  • A subscript is an integer variable used to access elements of an array. It is typically an implicit counter or a loop control variable.
  • Subscripts are associated with arrays declared using the OCCURS clause, which defines the size and dimension of the array.
  • Subscripts in COBOL typically start at 1 and increment by 1 for each element, unless explicitly specified otherwise.
  • They are primarily used for navigating through array elements sequentially, especially in loop constructs like PERFORM VARYING and SEARCH statements.
  • Example:
  • An index is also an integer variable used to access elements of an array, but its usage and characteristics differ from those of a subscript.
  • Unlike subscripts, indexes are not automatically incremented, and their starting value and increment are explicitly specified in the program logic.
  • Indexes are often used for non-sequential access, such as searching, sorting, or accessing array elements in specific orders.
  • COBOL programmers can manipulate indexes to perform complex data manipulations that are not possible with subscripts.
  • Example:

Course Schedule

Name Date Details
Python Course 22 Jun 2024(Sat-Sun) Weekend Batch
View Details
Python Course 29 Jun 2024(Sat-Sun) Weekend Batch
View Details
Python Course 06 Jul 2024(Sat-Sun) Weekend Batch
View Details

About the Author

Technical Research Analyst - Deep Learning

As a Technical Research Analyst specializing in Deep Learning, Aditya combines expertise in Python with a keen interest in cutting-edge technologies. He possesses a year of experience in designing and deploying robust applications. Additionally, he is passionate about writing and conveying complex technical concepts with clarity and precision.