O Não Tão Básico do Básico - Paradigmas de Programação - Parte 4

O que vou comentar hoje não é propriamente um paradigma, mas sim uma técnica de programação: a Programação Modular.

Lá no começo, era comum um programa inteiro ser escrito em um único fonte, com milhares de linhas. Por outro lado, a capacidade humana de registrar um contexto é bastante limitada, rapidamente você esquece os detalhes daquilo que não está diretamente na sua frente. O resultado era um aumento dos erros e da complexidade de manutenção, já que o entendimento de um trecho de código podia depender de de detalhes espalhados em todo o fonte.

Um outro problema era que o processo de compilação era lento, pois todo o código tinha que ser recompilado mesmo que um trecho pequeno fosse alterado.

A solução para isto foi permitir quebrar o fonte em diversas partes (módulos), compiladas separadamente e depois juntadas por um linker. Além de permitir quebrar "fisicamente" o fonte (permitindo compilar somente os alterados), o controle da visibilidade de rotinas e variáveis de uma parte para outra (como o uso de static no C) permite quebrar o programa logicamente.

Desta forma, o programador pode agrupar em cada módulo rotinas e variáveis inter-relacionadas e controlar quais delas os outros módulos poderão acessar. Não é exagero dizer que isto viabilizou o desenvolvimento de programas de maior porte.

modulo1.c:

view plaincopy to clipboardprint?

1. static int var_local;  // não pode ser acessadas pelos demais módulos  
2. int var_publica;   // pode ser acessada pelos demais módulos  
3.   
4. // esta rotina dá acesso de leitura a var_local para os demais módulos  
5. int LeVarLocal ()  
6. {  
7.   return var_local;  
8. }  

static int var_local;  // não pode ser acessadas pelos demais módulos
int var_publica;   // pode ser acessada pelos demais módulos

// esta rotina dá acesso de leitura a var_local para os demais módulos
int LeVarLocal ()
{
  return var_local;
}

modulo2.c

view plaincopy to clipboardprint?

1. extern int var_publica;  
2. extern int LeVarLocal();  
3.   
4. // esta rotina usa variável e rotina do modulo1  
5. void Foo ()  
6. {  
7.   if (LeVarLocal() > 3)  
8.    var_publica = 0;  
9. }  

extern int var_publica;
extern int LeVarLocal();

// esta rotina usa variável e rotina do modulo1
void Foo ()
{
  if (LeVarLocal() > 3)
   var_publica = 0;
}

Note que neste pequeno exemplo a divisão em módulos permitiu restringir o acesso à var_local do modulo1. Por outro lado, o programador decidiu permitir a todos os módulos acessar var_publica.

O passo seguinte foi tornar mais formal o uso de módulos, separando a interface (definições das rotinas e variáveis acessíveis por outros módulos) da implementação (que contém as variáveis e códigos propriamente ditos).

Esta preocupação em agrupar variáveis e código inter-relacionados e controlar a interface entre estes grupos nos leva ao próximo assunto: a Programação Orientada a Objetos.