One of the more effective programming practices
involves partitioning large, complex programming challenges into
smaller and more manageable sub-tasks and reusable functions. A
similar approach should be taken when using a programming language
like Cicode to complete a task. Reducing the task to smaller tasks
(or functions) has the following advantages:
Complexity - Once the function is created and tested, the
detailed operation about how it works need not be revisited. Users
need only focus on the results produced by the function.
Code - Creating a generic function instead of copying similar
code reduces the total amount of code in the system. It also means
the function can be reused by separate code areas. This makes the
code more maintainable because it is smaller in size, and only one
instance needs to be modified.
Information - Information can be in the form of operations,
data, or resources. Access to information can be controlled when
functions are written that provide a limited set of actions to be
performed on the information. For example, if a user wishes to log
a message to a database, he or she should only send the message to
a function, say LogDBaseMessage("hello
world"), and the function should control the database resource.
The function then becomes the single interface to the database
resource. Resources that have multiple interfaces to them are
harder to control. This is because in a multitasking environment,
the user cannot control or even know in advance the order of code
execution, and hence a resource may be modified at the same time by
different tasks. Information hiding can also smooth out any
wrinkles in standard functions, minimizing possible misuse of
resources such as semaphores, queues, devices, and files. Functions
that do this are often called `wrapper' functions as they add a
protective shell to existing functions.
Performance - Optimizing code that resides in one place
immediately increases the performance of code that calls this
function. Scattered code will require multiple areas to be modified
should any optimization be necessary.
Code - Code that requires complex operations such
communications protocols, complex algorithms, boolean logic, or
complex data manipulation is susceptible to errors. Placing this
code in a separate function reduces the possibility of this code
corrupting or halting other code.
Readability - A small function with meaningful parameter names
assists readability as it is a step towards self-documenting code
and reduces the need to scan multiple pages of code to establish
what the operation is meant to achieve.
Modular programming has a few rules that define
how functions should be structured - Cohesion - and how they are
related to other functions - Coupling.