MODULAR PROGRAMMING: CHARACTERISTICS, EXAMPLES, ADVANTAGES, APPLICATIONS - TECHNOLOGY - 2025

The modular programming is a technique used for software development, where the program is divided into many small blocks or autonomous components called modules, which are manageable, logical and functional.

The module is a block of statements that solves a particular problem. Each module contains everything necessary to fulfill its own functionality and can be edited or modified without affecting the rest of the project.

Example of solving a problem using modules. Source: Kayau / CC BY (https://creativecommons.org/licenses/by/3.0)

This way of programming is achieved by maintaining a permanent module interface that is used by the other software components in order to access the functions of each module.

Modules impose logical boundaries between components, improving maintainability. They are incorporated through interfaces, which are designed in such a way as to minimize the dependency between the different modules.

Main and auxiliary modules

A main module and several secondary modules are what make up the modular programming. From the main module, calls are made to the functions of the auxiliary modules.

These plug-ins exist as separate executable files, which are loaded when the main module runs. Each module has a unique name assigned in the PROGRAM statement.

The work teams can develop different modules separately without having to know all the modules of the system. Each of the modular applications is associated with a version number to provide flexibility to developers in maintaining the module.

Modular programming features

Modularity

A computer does not need an exploded version of the code in order to run it. It's human cognitive limitations that force you to write code in smaller chunks.

A program can contain other functions and can also refer to functions that are in other files. These functions or modules are sets of statements that are used to perform an operation or calculate a value.

In order to maintain simplicity and readability in large and complex programs, a short main function is used in conjunction with other functions, rather than a long main function.

By separating a program into groups of modules, each module will be easier to understand, thus complying with the basic guidelines of structured programming.

Function definition

A function consists of a declaration of its definition followed by commands and statements. The general form of a function is:

Function_name (parameter declaration) {

sentences;

commands;

return expression;

}

- The declaration of the parameters represents the information that is being passed to the function.

- Additional variables used specifically by the function are defined in the sentences.

- All functions must include a return statement.

Scope of variables

Variables that are declared within the main function or in user-defined functions are called local variables. These have a value when the function executes, but their value is not retained when the function completes.

Variables that are declared external to the main program or to user-defined functions are called global variables. These variables can be taken from any function that is inside the program.

It's procedural

Modular programming is quite procedural, since it is completely oriented to writing code for functions, without taking into account the data.

Modular programming examples

Modularity in real life

Suppose a house that has electricity, with several outlets on the walls. This system allows you to plug in various electrical devices, for example, microwave, washing machine, dryer, etc.

These devices are designed to perform their specific task when plugged in and turned on, regardless of where they are located.

The modules of an application must follow this same philosophy. This means that they only have to perform their specific task no matter what part of the application they are in, or even which application they are connected to.

Also, just as an electrical device can be easily unplugged from the outlet, a module must be designed in such a way that it can be easily removed from an application.

Just as removing an electrical device does not impact the functionality of the other connected devices, removing modules from an application should not impact the functionality of the other modules of that application.

Functions in Java

In Java modules are written as independent functions. For example, you might have a function or code block to calculate a student's GPA based on their grades in all the courses they have taken.

The function needs to obtain the list of grades as input and then return the calculated grade average:

This function is called CalculateAverageNote. It receives as input a list of notes, using an array of data type double, and returns the calculated average.

In the function, the local variable sum is initialized to zero and then, using a for loop, all qualifications are added to sum. Finally, the sum obtained is divided by the number of notes, returning the resulting value.

If the input matrix had the notes 3.5, 3.0 and 4.0, after adding them, it would have sum the value of 10.5 and then it would be divided by 3, because there are three notes. The function would return the value 3.5.

Advantage

Independent project programming

Multiple programmers can work on the same project if it is divided into modules. Different programmers can independently design different program modules, which is required for a large and complex program.

Efficient program development

Programs can be developed more quickly, as small, stand-alone modules are easier to understand, design, and test than large programs.

The programmer can provide the necessary input and verify that the module is correct by examining its output.

Multiple use of modules

Code written for one program is often useful in others. Modular programming allows these sections to be saved for future use. Because the code is relocatable, the saved modules can be linked to any other program that meets the input and output requirements.

With monolithic programming, such sections of code are embedded within the program and are not available for use by other programs.

Ease of debugging and modification

A module is smaller than a full program, so it is easier to test. Each module can be written and tested separately from the rest of the program. After a module has been tested, it can be used in a new program without having to test it again.

When a program must be modified, modular programming simplifies the job. New or debugged modules can be linked to an existing program without changing the rest of the program.

Disadvantages

Overly object-oriented structure

This programming uses interfaces, which is a pretty effective idea. To take advantage of that, some frameworks come with a full set of interchangeable classes. For example, to handle persistence, there could be multiple classes that implement a persistence interface.

However, integrated development environments (IDEs) get confused about this. For example, you could be trying to find the source of a method, and the IDE will not know which method you want to see, thus displaying a long list of files where a method with that name exists.

Modules too small

There are a lot of modules that only contain a very small function. Each module requires additional parsing and processing time, in addition to its heading in code.

Therefore, using many small modules will add an overhead to the compilation system, increasing the package size.

Decompose for no reason

Some codes almost never change. In those cases it may not make much sense to try to make it look cleaner or with abstract logic, if just using it works fine.

There are codes that don't look too pretty, yet they haven't changed much in recent years. There is no reason to decompose code that has never changed and is already working well into modules.

Applications

Modular programming is just a concept. Its practice can be applied in any programming language, especially those of a procedural nature, which have a separately compiled program.

Component libraries built from separately compiled modules can be combined into a set using a programming tool called a linker.

The names of the functions in the different modules must be unique in order to facilitate their access in case the functions used by the main module must be exported.

Among the programming languages ​​that support the concept of modular programming are C, Ada, PL / I, Erlang, Pascal, Algol, COBOL, RPG, Haskell, Python, HyperTalk, IBM / 360 Assembler, MATLAB, Ruby, IBM RPG, SmallTalk, Morpho, Java (packages are considered modules), Perl, etc.

C language

Modular programming can be applied in C language because it makes it possible to remedy a great difficulty by separating it into several modules.

Each of these modules solves a particular problem, while the main program, which is the set of such procedures, solves the problem as a whole.

Every function defined in C is by default accessible globally. This can be done by including a header file, where the implementation of the function is defined.

As an example, we want to declare a stack data type and also that the implementation and the data structure is hidden from users.

This can be done by first defining a public file called stack.h, which will contain the generic data with the stack data type and the functions supported by the stack data type.

stack.h:

extern stack_var1;

extern int stack_do_something (void);

Now you can create a file called stack.c that contains the implementation of the stack data type:

References

1. CIO Wiki (2019). Modular Programming. Taken from: cio-wiki.org.
2. IT Definitions (2020). Modular Programming. Taken from: defit.org.
3. New Mexico Tech (2020). Modular programming with functions. Taken from: ee.nmt.edu.
4. Christian Maioli (2020). 3 creative techniques for writing modular code. Tech Beacon. Taken from: techbeacon.com.
5. Geeks for Geeks (2020). Modular Approach in Programming. Taken from: geeksforgeeks.org.
6. Study (2020). Modular Programming: Definition & Application in Java. Taken from: study.com.