CLU

CLU é uma linguagem de programação criada pelo Massachusetts Institute of Technology ( MIT ) por Barbara Liskov e seus alunos entre 1974 e 1975 . Ele usou construtores para tipos de dados abstratos que foram incluídos no código, um passo à frente na programação orientada a objetos (OOP). No entanto, muitos outros recursos OOP estavam incompletos ou precisavam de mais desenvolvimento. Por outro lado, a linguagem é prejudicada por uma sintaxe que às vezes pode ser complicada. CLU e Alphard parecem ser linguagens totalmente orientadas a objetos, sem realmente o serem.

Agrupamentos

A sintaxe CLU é baseada em ALGOL , um ponto de partida para o design da maioria das novas linguagens. A adição mais importante é o conceito de cluster , o sistema de extensão de tipo da CLU e a raiz do nome da linguagem (CLuster), que significa "tipo de extensão do sistema CLU e a raiz dos nomes da linguagem". Os clusters geralmente correspondem ao conceito de "objeto" em uma linguagem orientada a objetos e possuem uma sintaxe muito semelhante. Por exemplo, abaixo vemos a sintaxe CLU para um cluster que implementa números complexos : I

    número_complexo = cluster é somar, subtrair, multiplicar, ....
         rep = registro [ parte_real: real, parte_imag: real ]
         add = proc... end add;
         subtrair = proc... fim subtrair;
         multiplique = proc... end multiplique;
        ...
    end número_complexo;

Enquanto os clusters ofereciam um sistema então avançado para estruturar programas, o CLU não oferecia nenhum tipo de estrutura para os clusters. Os nomes dos clusters são globais e nenhum mecanismo foi fornecido para os clusters agrupá-los ou permitir que sejam criados "localmente" dentro de outros clusters. Esse problema não é exclusivo do CLU, pois surpreendentemente muitas linguagens não possuem esse recurso - o problema é centralizado em ALGOL , de variáveis ​​de escopo. Parece que definir o escopo dos nomes de cluster/objeto seria uma expansão óbvia.

A CLU não executa conversões de tipo implícitas. Em um cluster, as conversões de tipo explícitas "up" e "down" alternam entre o tipo abstrato e a representação. Existe um tipo universal "qualquer" e um procedimento force[] para verificar se um objeto é do tipo correto. Os objetos podem ser mutáveis ​​ou imutáveis, os últimos "tipos base" por exemplo inteiros.

Outros recursos

Outra característica importante do tipo de sistema CLU são os iteradores , que retornam objetos de um conjunto, um após o outro. Os iteradores são como "caixas pretas" que fornecem uma interface de programação de aplicativos de API onde não importa o tipo de dados que eles estavam usando. Assim, o iterador para um conjunto de números complexos seria idêntico ao de um array de inteiros . Iteradores são agora uma característica comum da maioria das linguagens modernas.

Uma característica distintiva final no CLU é a atribuição múltipla, onde mais de uma variável pode aparecer no lado esquerdo de um operador de atribuição. Por exemplo, escrevendo x, y = y, xos valores de swap de xe de Y. Da mesma forma, as funções podem retornar vários valores, como x, y, z = f (t).

Todos os objetos em um programa CLU são declarados no início, tornando a alocação de memória automática.

Exemplo de código em CLU

      % Driver e função para calcular fatoriais
      % da distribuição PCLU.
       start_up = proc()
          pi: stream := stream$primary_input()
          po: stream := stream$primary_output()
          enquanto é verdade
              stream$puts(po, "Digite um inteiro (ou RETURN para sair): ")
              s: string := stream$getl(pi)
              se string $ vazio(s) então quebre o final
              n: int := int$parse(s)
                 exceto quando bad_format:
                             stream$putl(po, "Inteiro ilegal")
                        fim
              stream$putl(po, int$unparse(n) || "! = " || int$unparse(factorial(n)))
                 exceto quando negativo:
                             stream$putl(po, "Inteiro deve ser positivo")
                        quando estouro:
                             stream$putl(po, "Estouro")
                        fim
              fim
          fim de inicialização
       fatorial = proc (n: int) retorna (int) sinais (negativo, estouro)
          se n < 0 então sinaliza extremidade negativa
          se n = 0 então return(1) end
          return(n*fatorial(n-1))
             estouro de demissão
       fatorial final

Influência em outras linguagens de programação

• Python e Ruby emprestaram vários conceitos do CLU (por exemplo, a declaração de produção e atribuição múltipla).
• CLU, juntamente com Ada foram grandes inspirações para templates C++.
• Os mecanismos de tratamento de exceções do CLU também influenciaram novas linguagens como Java e C++.
• Todos os objetos em um programa CLU são declarados no início e o gerenciamento de memória é automático. Java diretamente influenciou.
• Python e C# incluem geradores (iteradores em C#), que apareceram pela primeira vez no CLU como iteradores .

Links externos

• página inicial do CLU
• História do CLU (pdf)
• clu2c : programa para compilar código de CLU para C
• Dicionário de linguagens de programação