ALGOL 68

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Question book.svg
Esta página ou secção não cita nenhuma fonte ou referência, o que compromete sua credibilidade (desde janeiro de 2014).
Por favor, melhore este artigo providenciando fontes fiáveis e independentes, inserindo-as no corpo do texto por meio de notas de rodapé. Encontre fontes: Googlenotícias, livros, acadêmicoYahoo!Bing. Veja como referenciar e citar as fontes.
Algol 68
Paradigma imperativo.
Abstração de dados,
Programação estruturada,
Programação procedural,
ortogonal
Surgido em 1968
Criado por Comitê Internacional
Estilo de tipagem: forte
Compiladores algol68toc
Influenciada por ALGOL
Influenciou C, Bash

ALGOL 68, sigla ALGOrithmic Language 1968, é uma das linguagens de programação da família de ALGOL, sendo uma estruturada e imperativa, que foi concebida como sucessora de ALGOL 60, sendo projetada com os objetivos de atender um escopo muito maior de aplicações e possuir uma sintática e semântica mais rigorosas.

ALGOL 68[editar | editar código-fonte]

É uma linguagem de programação imperativa que foi concebida como uma sucessora à linguagem de programação ALGOL 60, projetada com a meta de um escopo muito maior de aplicações e uma sintaxe e semântica mais rigorosamente definida. Contribuições de ALGOL 68 para o campo de informática são profundos, embora alguns deles não foram identificados publicamente até que foram passados, de uma forma ou outra, para uma de muitas linguagens de programação desenvolvidas subseqüentemente.

  • Algol 68 é uma linguagem de programação de alto nível. Seu nome provém das palavras "Algorithmic Language 68" (Linguagem Algorítmica 68).

A linguagem ALGOL começou a ser formulada em 1957, na Europa, por um grupo internacional de cientistas de computação que finalmente, em 1960, definiram o Algol 60 através de um documento curto, conciso e preciso, o "Revised Report on the Algorithmic Language Algol 60", que foi publicado em 1963 na revista Communications of the ACM. A definição do Algol 60 foi um evento-chave na história das linguagens de programação. Nenhuma outra linguagem teve influência tão importante nos projetos de novas linguagens. Contudo ALGOL 68 é uma continuação do desenvolvimento de ALGOL 60, mas não é um super conjunto dela.

Os principais alvos e princípios[editar | editar código-fonte]

  1. Perfeição e claridade de projeto;
  2. Projeto Ortogonal
  3. Segurança
  4. Eficiência
  5. Verificação de modo estático,
    • Analise gramatical de modo independente,
    • Compilação independente,
    • Otimização de laço,
    • Representações – em conjuntos de caracteres maiúsculos e minúsculos.

História[editar | editar código-fonte]

Uma revisão extensa de ALGOL 60 feita por Adriaan van Wijngaarden, discutida em 1963 pelo Grupo de Trabalho 2.1 da IFIP (International Federation for Information Processing). Essa definição foi aceita em Dezembro de 1968.

Em um congresso em Zurich, um comitê internacional designou o ALGOL como uma linguagem independente de plataforma. Isto deu mais liberdade para as características que eles poderiam colocar na linguagem, mas também tornou mais difícil a escrita de compiladores para ela. Muitos fabricantes de computador não fizeram compiladores. A carência de compiladores em muitas plataformas, combinada com sua carência de ponteiros e muitos tipos de dados básicos tais como caracteres, fez com que ALGOL não fosse amplamente aceito. Cientistas e engenheiros migraram para o FORTRAN, uma linguagem de programação que estava disponível em muitas plataformas. O ALGOL acabou quase totalmente abandonado exceto como uma linguagem para a descrição de algoritmos.

Características[editar | editar código-fonte]

Ao contrário de ALGOL 60 que era uma linguagem de programação voltada para computação científica, ALGOL 68 foi uma linguagem de propósito geral que foi projetada para a comunicação de algoritmos, para sua execução eficiente em vários computadores e para ajudar seu ensino a estudantes. ALGOL era uma linguagem de alto nível, que permitia ao programador trabalhar "longe da máquina", sem se preocupar com os aspectos de como cada comando ou dado era armazenado ou processado. Foi criado para substituir o FORTRAN. Implementava o conceito de estrutura de blocos, onde variáveis, procedimentos, etc., poderiam ser declarados onde quer que o programa os necessitasse.

  • Algol-68, juntamente com Pascal, está entre as primeiras linguagens com uma ampla gama de instruções para controle de fluxo, definição e construção de novos tipos de dados.
  • A linguagem ALGOL-68 foi a primeira linguagem a ser completamente descrita em uma gramática formal, chamada gramática-W, inventada por A. van Wijngaarden.

Gramáticas-W, conhecidas também como gramáticas de dois níveis, são um formalismo que permite gerar linguagens recursivamente enumeráveis; assim sendo, elas possuem o poder computacional da Máquina de Turing. Uma gramática-W consiste de dois conjuntos finitos de regras: as metaproduções e as hiper-regras. As metaproduções são produções livres de contexto, com o sinal ”::” separando seu lado esquerdo do direito, “;“ separarando alternativas no lado direito, e “.“ indicando o final do lado direito; os não-terminais das metaproduções são denominadas meta-noções, e são escritos em letras maiúsculas; os terminais das metaproduções são chamados proto-noções, e são escritos em letras minúsculas, com brancos permitidos por exemplo:

  • [MP1] ALPHA :: a; b; c; d; e; f; g; h; i; j; k; 1; m; n; o; p; q; r; s; t; u; v; w; x; y; z.
  • [MP2] NOTION:: ALPHA; NOTION ALPHA.

As hiper-regras são protótipos para produções livres de contexto nas quais encontramos meta-noções definidas em alguma metaprodução; para as hiper-regras o separador entre os seus lados esquerdo e direito é “:“, o separador de alternativas no lado direito é “ ; “, o símbolo “,“ é usado para separar diferentes proto-noções dentro da mesma alternativa e ‘.“ tem a mesma função que para as metaproduções; por exemplo:

  • [HR1] NOTION sequence: NOTION ; NOTION sequence, NOTION.

Essas meta-noções podem serem substituídas por alguma palavra que elas definem, segundo alguma metaprodução, de acordo com a regra de substituição uniforme: Todas as ocorrências da mesma meta-noção na hiper-regra devem ser substituídas obrigatoriamente pela mesma proto-noção; deste modo pode-se obter um novo conjunto de produções ‘em tempo de derivação”. Assim, por exemplo, usando as metaproduções [MP1] e [MP2] para derivar as palavras “value” e “identifier”, podemos obter, da hiper-regra [HR1], as seguintes duas produções livres de contexto:

  • value sequence : value ; value sequence, value
  • identifier sequence : identifier ; identifier sequence, identifier

Uma das características que foram almejadas na construção do ALGOL 68 foi a ortogonalidade. A ortogonalidade significa que qualquer composição de elementos básicos é possível. Entre os recursos introduzidos pela linguagem ALGOL-68, está a possibilidade de criação de novos operadores e a possibilidade de redefinição da precedência de operadores já existentes. Visto as dificuldades encontradas com PL/I, Algol-68 tentou buscar poder expressivo através da utilização de outra filosofia: escolher um conjunto adequado e coerente de conceitos e combiná-los sistematicamente. A filosofia utilizada por PL/I foi simplesmente juntar as características das várias linguagens de programação.

O ALGOL 68 foi a fonte de diversas idéias novas no projeto de linguagens, algumas das quais subseqüentemente adotadas por outras linguagens. Uma das inovações mais interessantes do ALGOL 68 é um de seus principais critérios de projeto: a ortogonalidade. Um resultado importante da ortogonalidade no ALGOL 68 foi sua inclusão dos tipos de dados definidos pelo usuário. As linguagens anteriores, como o FORTRAN, incluíam somente algumas estruturas de dados básicas. Uma outra iniciativa pioneira na área dos tipos de dados do ALGOL 68 foi a introdução do tipo de arrays dinâmicos, chamados de heap. Um array dinâmico é aquele em que a declaração não especifica limites de subscrito. O ALGOL 68 não se tornou uma linguagem muito popular, um pouco por falta de apoio da IBM, mas apesar disso influiu muito as linguagens posteriores, principalmente devido ao uso que ele faz da ortogonalidade.

Algol 68 era complexo e impôs dificuldades tanto para implementadores quanto para usuários. Ela caracterizou equivalência estrutural; conversão de tipo automática ("coerção"); arrays flexíveis; laços generalizados (for-from-by-to-while-do-od), if-then-elif-fi, uma declaração de caso inteiro com uma cláusula 'out'; declarações skip e goto; blocos; procedures; operadores definidos pelo usuário; parâmetros de procedure; execução simultânea (cobegin/coend); geradores "heap" and "loc" for alocação dinâmica. Não possuía tipos de dados abstratos ou compilação separada.

"Bold" símbolos[editar | editar código-fonte]

Há 61 tais símbolos “bold(realce)” (alguns com equivalentes “breves” do símbolo) no sub-language padrão:

mode, op, prio, proc,
flex, heap, loc, long, ref, short,
bits, bool, bytes, char, compl, int, real, sema, string, void,
channel, file, format, struct, union, 
of, at "@", is ":=:", isnt ":/=:", true, false, empty, nil "∘", skip "~",
co "¢", comment "¢", pr, pragmat,
case in ouse in out esac "( ~ | ~ |: ~ | ~ | ~ )", 
for from to by while do od,
if then elif then else fi "( ~ | ~ |: ~ | ~ | ~ )", 
par begin end "( ~ )", go to, goto, exit "•".

Vantagens e Desvantagens[editar | editar código-fonte]

Vantagens[editar | editar código-fonte]

  • Algol-68, juntamente com Pascal, está entre as primeiras linguagens com uma ampla gama de instruções para controle de fluxo, definição e construção de novos tipos de dados.
  • Embora ALGOL-68 não tenha tido muita popularidade, principalmente nos Estados Unidos, muitos dos seus recursos foram utilizados em linguagens posteriores.
  • Ortogonalidade: uma LP que é ortogonal tem um número de construtores básicos e um conjunto de regras para combiná-los relativamente pequeno (oposto a PL/I)
  • ALGOL também foi utilizado como base para outra linguagem de programação, o Pascal.
  • Contribuições:
    • Estrutura de dado definida pelo utilizador;
    • O tipo referencia;
    • Arrays dinâmicos (chamados flex arrays).
    • Procedimentos de alta ordem,
    • Tipos de dados definidos pelo usuário

Desvantagens[editar | editar código-fonte]

ALGOL não teve sucesso, talvez por tentar ser de muito alto nível em uma época em que a maioria dos sistemas operacionais exigiam do usuário um grande conhecimento de hardware;

  • Foi menos utilizada que ALGOL 60;
  • Difícil de aprender, implementar e entender a descrição.

Exemplo de Programa[editar | editar código-fonte]

BEGIN
  [10]CHAR s1, s2, s3;
  read((s1, s2, s3));
  IF s1 < s2
  THEN 
    IF s2 < s3
    THEN print((s1, s2, s3))
    ELIF s1 < s3
    THEN print((s1, s3, s2))
    ELSE print((s3, s1, s2))
    FI
  ELIF s1 < s3
  THEN print((s2, s1, s3))
  ELIF s2 < s3
  THEN print((s2, s3, s1))
  ELSE print((s3, s2, s1))
  FI
END

Exemplo de representações diferentes do programa[editar | editar código-fonte]

Algol68 como publicado tipicamente
int sum sq:=0;
for i
while
  sum sq≤1000
do
  sum sq+:=i↑2
od 
Código para um compilador 7-bit/ascii
INT sum sq:=0;
FOR i
WHILE
  sum sq<=1000
DO
  sum sq+:=i**2
OD 
Código para um compilador 6-bit
.INT SUM SQ:=0;
.FOR I
.WHILE
  SUM SQ .LE 1000
.DO
  SUM SQ .PLUSAB I .UP 2
.OD

Bibliografia[editar | editar código-fonte]

  • PAGAN, Frank G.. A Practical Guide to Algol 68. London: John Wiley & Sons, 1976. 213 pp.
  • VAN WIJNGAARDEN, A.; MAILLOUX, B.J.; PECK, J.E.L.; KOSTER, C.H.A; SINTZOFF, M.; LINDSEY, C.H.; MEERTENS, L.G.L.T.; FISKER, R.G.. Revised Report on the Algorithmic Language Algol 68. New York: Springer-Verlag, 1976. 236 pp. ISBN 0-387-07592-5

Ver também[editar | editar código-fonte]

Ligações externas[editar | editar código-fonte]