COBOL
| COBOL | |
|---|---|
| Paradigma | procedural, Orientação a objeto |
| Surgido em | 1959 |
| Última versão | COBOL2002 |
| Criado por | Grace Hopper, William Selden, Gertrude Tierney, Howard Bromberg, Howard Discount, Vernon Reeves, Jean E. Sammet. |
| Estilo de tipagem: | Forte e estática |
| Dialetos: | HP3000 COBOL/II, COBOL/2, IBM OS/VS COBOL, IBM COBOL/II, IBM COBOL SAA, IBM Enterprise COBOL, IBM COBOL/400, IBM ILE COBOL, Unix COBOL X/Open, Micro Focus COBOL, Microsoft COBOL, Ryan McFarland RM/COBOL, Ryan McFarland RM/COBOL-85, DOSVS COBOL, UNIVAC COBOL, Realia COBOL, Fujitsu COBOL, ICL COBOL, ACUCOBOL-GT, COBOL-IT, DEC COBOL-10, DEC VAX COBOL, Wang VS COBOL, Visual COBOL, Tandem (NonStop) COBOL85, Tandem (NonStop) SCOBOL (um variante de COBOL74 para criar consolas em terminais baseados em texto) |
| Influenciada por | FLOW-MATIC, COMTRAN, FACT |
| Influenciou | PL/I, CobolScript, ABAP |
COBOL é uma das linguagem de programação mais antigas. O seu 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.1
As especificações do COBOL 2002 inclui suporte a programação de orientação a objetos e outras características das linguagens modernas.2
Índice |
Pré-história e Especificação [editar]
O COBOL foi criado por um comitê de investigadores de várias instituições civis e governamentais durante o segundo semestre de 1959. As especificações eram em grande parte inspiradas na línguagem de programação FLOW-MATIC inventada pela Grace Hopper - referida como "a mãe da língua COBOL." A línguagem de programação da IBM COMTRAN inventada pelo Bob Bemer também foi utilizada, mas a especificação da FACT da Honeywell tinha sido distribuída até tarde aos membros do comitê do processo, e teve relativamente pouco impacto. O uso corrente e estatudo do FLOW-MATIC como a única linguagem do grupo de estudo que efectivamente tinha sido utilizada numa situação real, fez com que fosse bastante atractiva ao comitê.3
Durante o CODASYL (Conference on Data Systems Language)1 , 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 [editar]
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 [editar]
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.[carece de fontes]
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.[carece de fontes]
Estrutura Básica [editar]
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 [editar]
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 [editar]
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 [editar]
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 [editar]
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.
Defesa [editar]
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 = -1 * B + (B ** 2 - 4 * A * C) ** 0.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.
MULTIPLY B BY -1 GIVING B-NEGATIVO.
ADD B-NEGATIVO TO RESULT-1 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.
Referências
- ↑ a b Dornelles, Carlos Alberto. A história do COBOL. Página visitada em 20/7/2012.
- ↑ . [S.l.: s.n.]. ISBN 0-620-34652-3
- ↑ Jean_Sammet. . "[1]" 13 (8).
- Sammet, J.E. (1981). "The Early History of COBOL." In History of Programming Languages, by Wexelblat, R.L., ed. New York: ACM Monograph Series.
- SAADE, Joel. COBOL Sem Mistérios. São Paulo: Novatec, 1997, 520 p. ISBN 85-85184-61-2.
Ver também [editar]
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
