COBOL é uma linguagem de programação de Terceira Geração. Este nome é a sigla de COmmon Business Oriented Language
(Linguagem Orientada aos Negócios), que define seu objetivo principal
em sistemas comerciais, financeiros e administrativos para empresas e
governos.
O COBOL 2002 inclui suporte para programação orientada a objetos e
outras características das linguagens modernas. Entretanto, a maior
parte deste artigo está baseado no COBOL 85.
Pré-história e Especificação
O COBOL foi criado em 1959 durante o CODASYL (Conference on Data Systems Language), um dos três comitês propostos numa reunião no Pentágono em Maio de 1959, organizado por Charles Phillips do Departamento de Defesa dos Estados Unidos.
O CODASYL foi formado para recomendar as diretrizes de uma linguagem
para negócios. Foi constituído por membros representantes de seis
fabricantes de computadores e três órgãos governamentais, a saber: Burroughs Corporation, IBM, Minneapolis-Honeywell (Honeywell Labs), RCA, Sperry Rand, e Sylvania Electric Products, e a Força Aérea dos Estados Unidos, o David Taylor Model Basin e a Agência Nacional de Padrões (National Bureau of Standards
ou NBS). Este comitê foi presidido por um membro do NBS. Um comitê de
Médio Prazo e outro de Longo Prazo foram também propostos na reunião do
Pentágono. Entretanto, embora tenha sido formado, o Comitê de Médio
Prazo nunca chegou a funcionar; e o Comitê de Longo Prazo nem chegou a
ser formado. Por fim, um subcomitê do Comitê de Curto Prazo desenvolveu
as especificações da linguagem COBOL. Este subcomitê era formado por
seis pessoas:
- William Selden e Gertrude Tierney da IBM
- Howard Bromberg e Howard Discount da RCA
- Vernon Reeves e Jean E. Sammet da Sylvania Electric Products
Este subcomitê completou as especificações para o COBOL no fim do ano
de 1959. Elas foram inspiradas em grande parte pela linguagem FLOW-MATIC inventada por Grace Hopper, e pela linguagem COMTRAN da IBM inventada por Bob Bemer.
As especificações foram aprovadas pelo CODASYL. A partir daí foram aprovadas pelo Comitê Executivo em Janeiro de 1960, e enviadas à gráfica do governo, que as editou e imprimiu com o nome de COBOL 60. O COBOL foi desenvolvido num período de seis meses, só que a primeira versão(COBOL 60), não durou muito tempo devido inúmeros erros que foram rapidamente corrigidos na versão COBOL 61 e foi base para os primeiros compiladores de COBOL. A versão COBOL 61 serviu como base para outra versão, que foi lançada em 1962 e foi nomeada de COBOL-61 - Versão Estendida, que continha novos elemento quando comparada com as versões anteriores.
Compiladores COBOL geralmente se baseavam no COBOL Padrão Nacional Americano(ANSI),
que adotou o COBOL como uma linguagem padrão. Que teve seu primeiro
padrão noticiado em 1968 e posteriormente em 1974, 1985 e 1989. A última
revisão foi concluída em 2002.
Definindo as características
O COBOL foi definido na especificação original, possuia excelentes
capacidades de autodocumentação, bons métodos de manuseio de arquivos, e
excepcional modelagem de dados para a época, graças ao uso da cláusula
PICTURE para especificações detalhadas de campos. Entretanto, segundo os
padrões modernos de definição de linguagens de programação, tinha
sérias deficiências, notadamente sintaxe prolixa e falta de suporte de
variáveis locais, recorrência, alocação dinâmica de memória e programação estruturada. A falta de suporte à linguagem orientada a objeto é compreensível, já que o conceito era desconhecido naquela época.
O COBOL possui muitas palavras reservadas,
e é difícil evitar de usar alguma inadvertidamente sem o uso de alguma
convenção, como adicionando um prefixo a todos os nomes de variáveis. A
especificação original do COBOL suportava até código auto-modificável
através do famoso comando "ALTER X TO PROCEED TO Y". Entretanto, a
especificação do COBOL foi redefinida de tempos em tempos para atender a
algumas das críticas, e as últimas definições do COBOL corrigiram
muitas destas falhas, acrescentando estruturas de controle melhoradas,
orientação a objeto e removendo a possibilidade de codificação
auto-modificável.
Mantendo-se forte
Embora o COBOL tenha sido proposto originalmente como solução para
resolver problemas de programação do governo e das forças armadas
americanas, programas COBOL continuam em uso na maioria das empresas
comerciais em todo o mundo, notadamente nas instituições financeiras, e
em praticamente todos os sistemas operacionais, incluindo o IBM z/OS, o Microsoft Windows e a família Unix/Linux.
A base global de código é imensa e os aplicativos, de tempos em tempos,
são sujeitos a manutenção. O custo de reescrever um aplicativo COBOL,
já depurado, em uma nova linguagem não justifica os benefícios que possa
eventualmente trazer. No fim dos anos 90 o Gartner Group, uma empresa
de pesquisa na área de processamento de dados, estimou que dos 300
bilhões de linhas de código-fonte existentes no mundo, 80% - ou cerca de
240 bilhões de linhas - eram em COBOL. Eles também reportaram que mais
de metade dos novos aplicativos de missão crítica ainda estavam sendo
desenvolvidos usando o COBOL.
Ao se aproximar o fim do século XX houve uma febre de atividade de programadores COBOL para corrigir os efeitos do bug do milênio,
em certos casos em sistemas desenvolvidos por estes mesmos
programadores há décadas. Este problema foi mais crítico no código COBOL
porque as datas são primordiais em aplicativos comerciais, e a maioria
dos aplicativos comerciais foram escritos em COBOL.
Algumas pessoas acreditam que o uso de aritmética decimal codificada
em binário fez com que programas desenvolvidos sem a previsão de datas
com ano de 4 dígitos ficassem particularmente vulneráveis a falhas com o
problema do ano 2000; entretanto é difícil justificar esta opinião.
Outros argumentam que a aritmética BCD do COBOL evitou muitos outros
problemas que poderiam ocorrer com o uso ingênuo do ponto flutuante em cálculos financeiros.
O COBOL provou ser durável e adaptável. O padrão atual do COBOL é o COBOL2002. O COBOL2002 suporta conveniências modernas como Unicode, geração de XML e convenção de chamadas de/para linguagens como o C, inclusão como linguagem de primeira classe em ambientes de desenvolvimento como o .NET da Microsoft e a capacidade de operar em ambientes fechados como Java (incluindo COBOL em instâncias de EJB) e acesso a qualquer base SQL.
No Brasil a área financeira e de seguros são os principais mercados
de COBOL e está aquecido devido grandes compras e fusões das
instituições.
Mas hoje em dia o COBOL não é muito utilizado no desenvolvimento de
novos programas, a maioria dos novos programas Cobol é escrita apenas
para estender ou suportar aplicações existentes no mainframe. As
empresas que possuem programas em COBOL e que gostariam de migrar para
outras linguagens, usam como principal artifício, o fato de muitas vezes
esta migração não ocorrer devido ao alto custo e ao risco deste
processo. O tempo da migração também é um fator que mantém o COBOL no
mercado.
Estrutura Básica
O COBOL consiste basicamente em quatro divisões separadas:
- IDENTIFICATION DIVISION
A IDENTIFICATION DIVISION possui informações documentais, como nome
do programa, quem o codificou e quando essa codificação foi realizada.
- ENVIRONMENT DIVISION
A ENVIRONMENT DIVISION descreve o computador e os periféricos que serão utilizados pelo programa.
- DATA DIVISION
A DATA DIVISION descreve os arquivos de entrada e saída que serão
usadas pelo programa. Também define as áreas de trabalho e constantes
necessárias para o processamento dos dados.
- PROCEDURE DIVISION
A PROCEDURE DIVISION contém o código que irá manipular os dados
descritos na DATA DIVISION. É nesta divisão que o desenvolvedor
descreverá o algoritmo do programa.
IDENTIFICATION DIVISION ENVIRONMENT DIVISION * CONFIGURATION SECTION * INPUT-OUTPUT SECTION DATA DIVISION * FILE SECTION * WORKING-STORAGE SECTION * LOCAL-STORAGE SECTION * LINKAGE SECTION * COMMUNICATION SECTION * REPORT SECTION * SCREEN SECTION PROCEDURE DIVISION
Segue um exemplo da estrutura básica de um programa chamado EXEMPLO:
IDENTIFICATION DIVISION. * PROGRAM-ID. EXEMPLO. * AUTHOR. WIKIPEDI. * DATE-WRITTEN. 20/09/2009 * ENVIRONMENT DIVISION. * CONFIGURATION SECTION. * SPECIAL-NAMES. * DECIMAL-POINT IS COMMA. * DATA DIVISION. * WORKING-STORAGE SECTION. * PROCEDURE DIVISION. *
Área de codificação no COBOL
Colunas Descrição
1 a 6 branco (será preenchido com a numeração COBOL)
7 (branco) linha de codificação
* (asterisco) linha de comentário
- (hífen) continuação de literal não numérico
8 a 72 instruções do COBOL iniciando na coluna 8
Olá Mundo
IDENTIFICATION DIVISION. PROGRAM-ID. HELLO-WORLD. * ENVIRONMENT DIVISION. * DATA DIVISION. * PROCEDURE DIVISION. PARA-1. DISPLAY "Hello, World!!". * STOP RUN.
Se copiar e colar este exemplo, tenha cuidado com a indentação, já que ela é fundamental em compiladores COBOL padrão [ANSI].
Em alguns compiladores, o código acima poderia ser escrito sem
especificação das divisões que não são utilizadas. Ficando apenas assim:
DISPLAY "Olá, Mundo.".
Escrever programas COBOL omitindo divisões e seções ou escrevendo
fora da faixa convencionalmente aceita pelo ANSI (colunas de 8 a 72)
pode prejudicar o intercâmbio de programas entre ferramentas e
plataformas.
Se estiverem disponibilizadas ferramentas de apoio do COBOLware o
resultado poderia ser exibido tanto em uma janela de modo gráfico quanto
no modo texto.
EXEC COBOLware SEND Message "Olá, Mundo." END-EXEC.
Programa que monta formato de data: Exemplo da saída deste programa : Data do dia ...... : IPIRANGA, 07 de SETEMBRO de 1982.
*-----------------------------------------------------------------
PROCEDURE DIVISION.
*-----------------------------------------------------------------
MOVE FUNCTION CURRENT-DATE TO WS-DATA-CORRENTE
STRING
'IPIRANGA, ' DELIMITED BY SIZE
WS-DIA DELIMITED BY SIZE
' de ' DELIMITED BY SIZE
NOME-MES ( WS-MES ) DELIMITED BY SPACES
' de ' DELIMITED BY SIZE
WS-ANO-INTEIRO DELIMITED BY SIZE
'.' DELIMITED BY SIZE
INTO WS-DATA-EXTENSO
END-STRING
DISPLAY 'Data do dia ...... : ' WS-DATA-EXTENSO
GOBACK.
Programa que encontra os 10 primeiros numeros perfeitos.
IDENTIFICATION DIVISION. ****************************************************************** * PROGRAM-ID. PERFEITO. AUTHOR. WIKIPEDIA. DATE-WRITTEN. 20/08/2009. DATE-COMPILED. * ****************************************************************** * E N V I R O N M E N T D I V I S I O N * ****************************************************************** ENVIRONMENT DIVISION. CONFIGURATION SECTION. SPECIAL-NAMES. DECIMAL-POINT IS COMMA. * ****************************************************************** * D A T A D I V I S I O N * ****************************************************************** DATA DIVISION. * ****************************************************************** * WORKING-STORAGE SECTION. * ****************************************************************** WORKING-STORAGE SECTION. * *----------------------------------------------------------------* * WS-AUXILIARES * *----------------------------------------------------------------* 01 WS-AUXILIARES. 05 WS-DIVIDENDO PIC 9(12) VALUE 0. 05 WS-INDEX PIC 9(05) VALUE 0. 05 WS-MEIO PIC 9(10) VALUE 0. 05 WS-INDEX2 PIC 9(05) VALUE 0. 05 WS-RESTO PIC 9(10) VALUE 0. 05 WS-SOMA PIC 9(12) VALUE 0. * ****************************************************************** * PROCEDURE DIVISION * ****************************************************************** PROCEDURE DIVISION . * ****************************************************************** * MAINLINE * ****************************************************************** MAINLINE. * PERFORM 1000-INICIO * PERFORM 2000-PROCESSO * PERFORM 3000-FINAL. * ****************************************************************** * 1000-INICIO * ****************************************************************** 1000-INICIO. * INITIALIZE WS-AUXILIARE . * ****************************************************************** * 2000-PROCESSO * ****************************************************************** 2000-PROCESSO. PERFORM WS-DIVIDENDO VARYING 0 BY 1 UNTIL WS-INDEX GREATER 9 * COMPUTE WS-MEIO = WS-DIVIDENDO / 2 * PERFORM WS-DIVISOR VARYING 0 BY 1 UNTIL WS-INDEX2 GREATER WS-MEIO * DIVIDE WS-DIVIDENDO BY WS-DIVISOR GIVING WS-PRODUTO REMAINDER WS-RESTO * IF WS-RESTO EQUAL ZEROS * ADD WS-DIVISOR TO WS-SOMA END-IF * END-PERFORM * IF WS-SOMA EQUAL WS-DIVIDENDO * DISPLAY WS-DIVIDENDO 'É NUMERO PERFEITO' ADD 1 TO WS-INDEX END-IF END-PERFORM . * ****************************************************************** * 3000-FINAL * ****************************************************************** 3000-FINAL. * GOBACK. * ****************************************************************** * FIM * ******************************************************************
Visões opostas do COBOL
Todas as linguagens de programação têm seus defensores e detratores. Já foi dito que com linguagens como o C, o C++ e Java
a única maneira de modificar o código legado é reescrevendo-o a cada
vez. Por outro lado, já se disse do COBOL que na realidade só há um
único programa COBOL que foi copiado e modificado bilhões de vezes.
Crítica
A motivação do desenvolvimento do COBOL era de facilitar a
programação tornando a linguagem a mais próxima possível do inglês.
Embora esta idéia pareça razoável, na prática a tarefa mais difícil na
programação é reduzir uma computação complexa numa sequência de passos
simples, não associando estes passos com uma linguagem natural. Os
críticos argumentam que a sintaxe prolixa e a estrutura geral do COBOL
só serve para aumentar o tamanho do programa e dificultar o
desenvolvimento do pensamento preciso necessário para o desenvolvimento
de software. O cientista de computação Edsger Dijkstra
observou em um artigo em 1975 (How do we tell truths that might hurt?):
"O uso do COBOL mutila a mente; seu ensino deveria, portanto, ser
considerado um crime".
Antigas versões do COBOL não dão suporte a variáveis locais e portanto não implementam inteiramente a programação estruturada.
Alguns programadores brincam dizendo que a extensão orientada a
objeto do COBOL deveria ser chamada ADD 1 TO COBOL GIVING COBOL.
Trata-se de uma analogia com o C++, um trocadilho da sintaxe da linguagem C para incrementar uma variável, e evidenciar a prolixidade do COBOL comparada com o C.
Defesa
Por outro lado, os defensores do COBOL argumentam que os que o
criticam e ironizam a linguagem nunca foram programadores COBOL e
geralmente o desconhecem. Na maioria das versões atuais os compiladores
não fazem distinção entre maiúsculas e minúsculas, embora o compilador
irá transformar em maiúsculas todas as palavras-chave antes de
processá-las.
Se alguém quiser tornar o COBOL menos prolixo do que é, geralmente consegue. Por exemplo o código:
ADD A TO B GIVING C. DIVIDE 2 INTO C GIVING C.
pode ser escrito assim:
COMPUTE C = (A + B) / 2.
e o verbo COMPUTE pode manipular fórmulas bastante complexas em forma
algébrica. Por exemplo, o código em COBOL de uma equação da fórmula de Bhaskara 
pode ser escrita, usando o verbo COMPUTE, que pode manipular fórmulas bastante complexas em forma algébrica, como esta:
COMPUTE X = (-B + (B ** 2 - (4 * A * C)) **.5) / (2 * A)
ou esta:
MULTIPLY B BY B GIVING B-SQUARED.
MULTIPLY 4 BY A GIVING FOUR-A.
MULTIPLY FOUR-A BY C GIVING FOUR-A-C.
SUBTRACT FOUR-A-C FROM B-SQUARED GIVING RESULT-1.
COMPUTE RESULT-2 = RESULT-1 ** .5.
SUBTRACT B FROM RESULT-2 GIVING NUMERATOR.
MULTIPLY 2 BY A GIVING DENOMINATOR.
DIVIDE NUMERATOR BY DENOMINATOR GIVING X.
Enquanto linguagens concisas como o C podem encorajar desenvolvedores
a escrever código que pode ser difícil a entender e depurar, o COBOL
encoraja o desenvolvimento inteligível ao nível da instrução.
Ver também
Outras linguagens de programação de terceira geração:
- ALGOL
- APL
- BASIC
- C
- FORTRAN
- Lisp
- PL/I
- RPG
- Anexo:Lista de palavras reservadas da linguagem de programação COBOL
0 comentários:
Postar um comentário