Ada (linguagem de programação)

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar
Ada
Ada mascote com slogan.svg
ParadigmaMulti-paradigma : estruturado , imperativo , orientado a objetos
FamíliaPascal
Projetado por
  • MIL-STD-1815, Ada 83: Jean Ichbiah
  • Ada 95: Tucker Taft
  • Ada 2005: Tucker Taft
  • Ada 2012: Tucker Taft
Apareceu pela primeira vezfevereiro de 1980 ; 42 anos atrás ( 1980-02 )
Versão estável
Ada 2012 TC1 [1] [2]
Disciplina de digitaçãoestático , forte , seguro , nominativo
SOMulti ou multiplataforma
Extensões de nome de arquivo.adb, .ads
Local na rede Internetwww.adaic.org _ _
Principais implementações
AdaCore GNAT (download gratuito: https://www.adacore.com/download ),
Green Hills Software Optimizing Ada 95 compilador,
PTC, Inc. PTC ApexAda e PTC ObjectAda, [3]
"MapuSoft Ada-C/C++ changer" . 16 de abril de 2019., anteriormente conhecido como "AdaMagic with C Intermediate", [4]
DDC-I Score
Dialetos
SPARK , perfil Ravenscar
Influenciado por
ALGOL 68 , Pascal , Simula 67 , [5] C++ (Ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95) Java (Ada 2005), Eiffel (Ada 2012)
Influenciado
C++ , Chapel , [6] Drago , [7] D , Eiffel , Griffin, [8] Java , Nim , ParaSail , PL/SQL , PL/pgSQL , Python , Ruby , Seed7 , SPARforte, [9] Sparkel , SQL/ PSM , VHDL

Ada é uma linguagem de programação de alto nível estruturada , estaticamente tipada , imperativa e orientada a objetos , estendida de Pascal e outras linguagens. Possui suporte de linguagem embutido para design por contrato (DbC), tipagem extremamente forte , simultaneidade explícita, tarefas, passagem de mensagens síncrona, objetos protegidos e não determinismo . A Ada melhora a segurança e a capacidade de manutenção do código usando o compilador para localizar erros em favor de erros de tempo de execução . Ada é uma norma técnica internacional , definida conjuntamente pela Organização Internacional para Padronização (ISO) e a Comissão Eletrotécnica Internacional (IEC). A partir de 2020 , o padrão, chamado informalmente de Ada 2012, [10] é ISO/IEC 8652:2012. [11]

Ada foi originalmente projetada por uma equipe liderada pelo cientista da computação francês Jean Ichbiah do CII Honeywell Bull sob contrato com o Departamento de Defesa dos Estados Unidos (DoD) de 1977 a 1983 para substituir mais de 450 linguagens de programação usadas pelo DoD na época. [12] Ada foi nomeada em homenagem a Ada Lovelace (1815–1852), que foi creditada como a primeira programadora de computador. [13]

Características

O Ada foi originalmente projetado para sistemas embarcados e de tempo real. A revisão Ada 95, projetada por S. Tucker Taft da Intermetrics entre 1992 e 1995, melhorou o suporte para sistemas, programação numérica, financeira e orientada a objetos (OOP).

Os recursos do Ada incluem: tipagem forte , mecanismos de programação modulares (pacotes), verificação em tempo de execução , processamento paralelo ( tarefas , passagem síncrona de mensagens , objetos protegidos e instruções select não determinísticas ), manipulação de exceções e genéricos . Ada 95 adicionou suporte para programação orientada a objetos , incluindo despacho dinâmico .

A sintaxe de Ada minimiza as escolhas de maneiras de realizar operações básicas e prefere palavras-chave em inglês (como "ou então" e "e então") a símbolos (como "||" e "&&"). Ada usa os operadores aritméticos básicos "+", "-", "*" e "/", mas evita usar outros símbolos. Os blocos de código são delimitados por palavras como "declare", "begin" e "end", onde o "end" (na maioria dos casos) é seguido pelo identificador do bloco que ele fecha (por exemplo, if ... end if , loop ... final do loop ). No caso de blocos condicionais, isso evita um else pendente que poderia emparelhar com a expressão if aninhada errada em outras linguagens como C ou Java.

Ada é projetado para desenvolver sistemas de software muito grandes. Os pacotes Ada podem ser compilados separadamente. As especificações do pacote Ada (a interface do pacote) também podem ser compiladas separadamente sem a implementação para verificar a consistência. Isso torna possível detectar problemas no início da fase de projeto, antes do início da implementação.

Um grande número de verificações em tempo de compilação é suportado para ajudar a evitar bugs que não seriam detectáveis ​​até o tempo de execução em algumas outras linguagens ou exigiriam que verificações explícitas fossem adicionadas ao código-fonte. Por exemplo, a sintaxe requer o fechamento de blocos explicitamente nomeado para evitar erros devido a tokens finais incompatíveis. A adesão à tipagem forte permite detectar muitos erros comuns de software (parâmetros errados, violações de intervalo, referências inválidas, tipos incompatíveis, etc.) durante o tempo de compilação ou durante o tempo de execução. Como a simultaneidade faz parte da especificação da linguagem, o compilador pode, em alguns casos, detectar possíveis deadlocks. [14]Os compiladores geralmente verificam identificadores com erros ortográficos, visibilidade de pacotes, declarações redundantes, etc. e podem fornecer avisos e sugestões úteis sobre como corrigir o erro.

O Ada também oferece suporte a verificações em tempo de execução para proteção contra acesso a memória não alocada, erros de estouro de buffer , violações de intervalo, erros off-by-one, erros de acesso a array e outros bugs detectáveis. Essas verificações podem ser desativadas para aumentar a eficiência do tempo de execução, mas geralmente podem ser compiladas com eficiência. Também inclui recursos para ajudar na verificação do programa . Por esses motivos, o Ada é amplamente utilizado em sistemas críticos, onde qualquer anomalia pode levar a consequências muito graves, por exemplo, morte acidental, lesão ou perda financeira grave. Exemplos de sistemas em que o Ada é usado incluem aviônicos , controle de tráfego aéreo , ferrovias, bancos, tecnologia militar e espacial. [15][16]

O gerenciamento dinâmico de memória do Ada é de alto nível e seguro. Ada não tem ponteiros genéricos ou não tipados ; nem declara implicitamente qualquer tipo de ponteiro. Em vez disso, toda alocação e desalocação de memória dinâmica deve ocorrer por meio de tipos de acesso explicitamente declarados . Cada tipo de acesso tem um pool de armazenamento associado que trata dos detalhes de baixo nível do gerenciamento de memória; o programador pode usar o pool de armazenamento padrão ou definir novos (isso é particularmente relevante para Acesso Não Uniforme à Memória ). É até possível declarar vários tipos de acesso diferentes que designam o mesmo tipo, mas usam pools de armazenamento diferentes. Além disso, a linguagem fornece verificações de acessibilidade, tanto em tempo de compilação quanto em tempo de execução, que garante que um valor de acesso não possa sobreviver ao tipo de objeto para o qual aponta. [17]

Embora a semântica da linguagem permita a coleta automática de lixo de objetos inacessíveis, a maioria das implementações não a suporta por padrão, pois causaria um comportamento imprevisível em sistemas de tempo real. Ada suporta uma forma limitada de gerenciamento de memória baseado em região ; além disso, o uso criativo de pools de armazenamento pode fornecer uma forma limitada de coleta de lixo automática, pois a destruição de um pool de armazenamento também destrói todos os objetos no pool.

Um traço duplo ("--"), semelhante a um travessão , denota o texto do comentário. Os comentários param no final da linha, para evitar que comentários não fechados anulem acidentalmente seções inteiras do código-fonte. Desabilitar um bloco inteiro de código agora requer o prefixo de cada linha (ou coluna) individualmente com "--". Embora denote claramente o código desativado com uma coluna de "--" repetido na página, isso torna a des/reativação experimental de grandes blocos um processo mais demorado.

O ponto e vírgula (";") é um terminador de instrução e a instrução nula ou sem operação é null;. Um single ;sem uma instrução para terminar não é permitido.

Ao contrário da maioria dos padrões ISO , a definição da linguagem Ada (conhecida como Ada Reference Manual ou ARM , ou às vezes o Language Reference Manual ou LRM ) é de conteúdo gratuito . Assim, é uma referência comum para programadores Ada, não apenas programadores que implementam compiladores Ada. Além do manual de referência, há também um extenso documento de lógica que explica o design da linguagem e o uso de várias construções de linguagem. Este documento também é amplamente utilizado por programadores. Quando a linguagem foi revisada, um novo documento de justificativa foi escrito.

Uma ferramenta de software livre notável que é usada por muitos programadores Ada para ajudá-los a escrever o código fonte Ada é o GNAT Programming Studio , parte da GNU Compiler Collection .

História

Na década de 1970, o Departamento de Defesa dos EUA (DoD) ficou preocupado com o número de linguagens de programação diferentes sendo usadas para seus projetos de sistemas de computadores embarcados, muitos dos quais eram obsoletos ou dependentes de hardware, e nenhum dos quais suportava programação modular segura. Em 1975, um grupo de trabalho , o High Order Language Working Group (HOLWG), foi formado com a intenção de reduzir esse número, encontrando ou criando uma linguagem de programação geralmente adequada para os requisitos do departamento e do Ministério da Defesa do Reino Unido . Depois de muitas iterações começando com uma proposta original do Homem de Palhaa linguagem de programação eventual foi nomeada Ada. O número total de linguagens de programação de alto nível em uso para tais projetos caiu de mais de 450 em 1983 para 37 em 1996.

O grupo de trabalho HOLWG elaborou os requisitos da linguagem Steelman , uma série de documentos declarando os requisitos que eles achavam que uma linguagem de programação deveria satisfazer. Muitas linguagens existentes foram formalmente revisadas, mas a equipe concluiu em 1977 que nenhuma linguagem existente atendia às especificações.

Augusta Ada King , Condessa de Lovelace.

Solicitações de propostas para uma nova linguagem de programação foram emitidas e quatro empreiteiras foram contratadas para desenvolver suas propostas sob os nomes de Red ( Intermetrics liderada por Benjamin Brosgol), Green ( CII Honeywell Bull , liderada por Jean Ichbiah ), Blue ( SofTech , liderada por John Goodenough) [18] e Yellow ( SRI International , liderado por Jay Spitzen). Em abril de 1978, após escrutínio público, as propostas Vermelha e Verde passaram para a fase seguinte. Em maio de 1979, a proposta Green, projetada por Jean Ichbiah no CII Honeywell Bull, foi escolhida e recebeu o nome de Ada – em homenagem a Augusta Ada, Condessa de Lovelace . Esta proposta foi influenciada pela linguagem LISque Ichbiah e seu grupo haviam desenvolvido na década de 1970. O manual de referência preliminar da Ada foi publicado no ACM SIGPLAN Notices em junho de 1979. O manual de referência do Padrão Militar foi aprovado em 10 de dezembro de 1980 ( aniversário de Ada Lovelace ), e recebeu o número MIL-STD-1815 em homenagem ao nascimento de Ada Lovelace ano. Em 1981, CAR Hoare aproveitou seu discurso no Prêmio Turing para criticar Ada por ser excessivamente complexo e, portanto, não confiável, [19] mas posteriormente pareceu se retratar no prefácio que escreveu para um livro didático de Ada. [20]

Ada atraiu muita atenção da comunidade de programação como um todo durante seus primeiros dias. Seus apoiadores e outros previram que ela poderia se tornar uma linguagem dominante para programação de propósito geral e não apenas para trabalhos relacionados à defesa. [21] Ichbiah declarou publicamente que dentro de dez anos, apenas duas linguagens de programação permaneceriam: Ada e Lisp . [22] Os primeiros compiladores Ada lutaram para implementar a linguagem grande e complexa, e tanto o desempenho em tempo de compilação quanto em tempo de execução tendiam a ser lentos e as ferramentas primitivas. [21] Os fornecedores de compiladores gastaram a maior parte de seus esforços na aprovação do pacote de validação "ACVC" exigido pelo governo, que era exigido em outro recurso inovador do esforço da linguagem Ada.[22] The Jargon File , um dicionário de gírias de hackers de computador originado em 1975-1983, observa em uma entrada sobre Ada que "é precisamente o que se poderia esperar, dado esse tipo de endosso por decreto; projetado por comitê ... uso e, no geral, um desastroso e multibilionário boondoggle... Ada Lovelace... quase certamente empalideceria com o uso que seu nome foi dado ultimamente; a coisa mais gentil que foi dita sobre isso é que provavelmente há uma boa pequena língua gritando para sair de dentro de sua vasta massa elefantina."

A primeira implementação validada do Ada foi o tradutor NYU Ada/Ed, [23] certificado em 11 de abril de 1983. O NYU Ada/Ed é implementado na linguagem de alto nível SETL . [24] Várias empresas comerciais começaram a oferecer compiladores Ada e ferramentas de desenvolvimento associadas, incluindo Alsys , TeleSoft , DDC-I , Advanced Computer Techniques , Tartan Laboratories , Irvine Compiler , TLD Systems e Verdix . [25]

Em 1991, o Departamento de Defesa dos EUA começou a exigir o uso de Ada (o mandato de Ada ) para todos os softwares, [26] embora exceções a essa regra fossem muitas vezes concedidas. [21] O mandato da Ada do Departamento de Defesa foi efetivamente removido em 1997, quando o DoD começou a adotar a tecnologia comercial de prateleira ( COTS ). [21] Requisitos semelhantes existiam em outros países da OTAN : Ada era necessária para sistemas da OTAN envolvendo comando e controle e outras funções, e Ada era o idioma obrigatório ou preferido para aplicações relacionadas à defesa em países como Suécia, Alemanha e Canadá. [27]

No final dos anos 1980 e início dos anos 1990, os compiladores Ada melhoraram em desempenho, mas ainda havia barreiras para explorar totalmente as habilidades de Ada, incluindo um modelo de tarefas que era diferente do que a maioria dos programadores de tempo real estavam acostumados. [22]

Devido aos recursos de suporte de segurança crítica do Ada , ele agora é usado não apenas para aplicações militares, mas também em projetos comerciais onde um bug de software pode ter consequências graves, por exemplo, aviônicos e controle de tráfego aéreo , foguetes comerciais como o Ariane 4 e 5 , satélites e outros sistemas espaciais, transporte ferroviário e bancário. [16] Por exemplo, o Airplane Information Management System , o software do sistema fly-by-wire do Boeing 777 , foi escrito em Ada. [28] [29] Desenvolvido pela Honeywell Air Transport Systemsem colaboração com consultores da DDC-I , tornou-se indiscutivelmente o mais conhecido de qualquer projeto Ada, civil ou militar. [28] [29] O Canadian Automated Air Traffic System foi escrito em 1 milhão de linhas de Ada ( contagem SLOC ). Ele apresentava processamento distribuído avançado , um banco de dados Ada distribuído e design orientado a objetos. O Ada também é usado em outros sistemas de tráfego aéreo, por exemplo, a próxima geração do sistema de controle de tráfego aéreo Interim Future Area Control Tools Support (iFACTS) do Reino Unido é projetado e implementado usando o SPARK Ada. [30] Também é usado no sistema de sinalização de cabine TVM francês no TGVsistema ferroviário de alta velocidade e os trens suburbanos de metrô em Paris, Londres, Hong Kong e Nova York. [16] [31]

Padronização

A linguagem tornou-se um padrão ANSI em 1983 ( ANSI/MIL-STD 1815A ), e após a tradução para o francês e sem outras alterações em inglês tornou-se um padrão ISO em 1987 (ISO-8652:1987). Esta versão da linguagem é comumente conhecida como Ada 83, a partir da data de sua adoção pela ANSI, mas às vezes também é chamada de Ada 87, a partir da data de sua adoção pela ISO.

Ada 95, o padrão conjunto ISO/ANSI ( ISO-8652:1995 ) foi publicado em fevereiro de 1995, tornando o Ada 95 a primeira linguagem de programação orientada a objetos padrão ISO. Para ajudar na revisão do padrão e aceitação futura, a Força Aérea dos EUA financiou o desenvolvimento do GNAT Compiler . Atualmente, o GNAT Compiler faz parte da GNU Compiler Collection .

Prosseguiu o trabalho de melhoria e atualização do conteúdo técnico da linguagem Ada. Um Corrigendum Técnico para Ada 95 foi publicado em outubro de 2001, e uma grande emenda, ISO/IEC 8652:1995/Amd 1:2007 foi publicada em 9 de março de 2007. Na conferência Ada-Europe 2012 em Estocolmo, a Ada Resource Association (ARA) e Ada-Europe anunciaram a conclusão do design da última versão da linguagem Ada e a submissão do manual de referência à Organização Internacional de Normalização (ISO) para aprovação. A ISO/IEC 8652:2012 foi publicada em dezembro de 2012. [11]

Outros padrões relacionados incluem ISO 8651 -3:1988 Sistemas de processamento de informações—Gráficos de computador—Graphical Kernel System (GKS) language bindings—Parte 3: Ada .

Construções de linguagem

Ada é uma linguagem de programação do tipo ALGOL que apresenta estruturas de controle com palavras reservadas como if , then , else , while , for e assim por diante. No entanto, Ada também possui muitas facilidades de estruturação de dados e outras abstrações que não foram incluídas no ALGOL 60 original , como definições de tipos , registros , ponteiros , enumerações . Tais construções foram em parte herdadas ou inspiradas por Pascal .

"Olá Mundo!" em Ada

Um exemplo comum da sintaxe de uma linguagem é o programa Hello world : (hello.adb)

com  Ada.Text_IO ; 
use  Ada.Text_IO ; 
procedure  Hello  é 
begin 
   Put_Line  ( "Hello, world!" ); 
final  Olá ;

Este programa pode ser compilado usando o compilador de código aberto GNAT disponível gratuitamente , executando

gnatmake hello.adb

Tipos de dados

O sistema de tipos de Ada não é baseado em um conjunto de tipos primitivos predefinidos, mas permite que os usuários declarem seus próprios tipos. Essa declaração, por sua vez, não se baseia na representação interna do tipo, mas na descrição do objetivo que deve ser alcançado. Isso permite que o compilador determine um tamanho de memória adequado para o tipo e verifique violações da definição de tipo em tempo de compilação e tempo de execução (ou seja, violações de intervalo, estouros de buffer, consistência de tipo etc.). Ada oferece suporte a tipos numéricos definidos por um intervalo, tipos de módulo, tipos de agregação (registros e matrizes) e tipos de enumeração. Os tipos de acesso definem uma referência a uma instância de um tipo especificado; ponteiros não digitados não são permitidos. Os tipos especiais fornecidos pela linguagem são tipos de tarefas e tipos protegidos.

Por exemplo, uma data pode ser representada como:

tipo  Day_type    é  intervalo     1  ..    31 ; 
tipo  Month_type  é o  intervalo     1  ..    12 ; 
tipo  Year_type   é o  intervalo  1800  ..  2100 ; 
o tipo  Horas  é  mod  24 ; 
tipo Dia da  semana  é  ( segunda ,  terça ,  quarta ,  quinta ,  sexta ,  sábado ,  domingo );

tipo  Date  is 
   record 
     Day    :  Day_type ; 
     Mês  :  Tipo_mês ; 
     Ano   :  Tipo_ano ; 
   registro final ;

Os tipos podem ser refinados declarando subtipos :

o subtipo  Working_Hours  é o  intervalo de horas  0 .. 12 ; -- no máximo 12 horas para trabalhar por dia subtipo Working_Day é intervalo de dias da semana segunda .. sexta ; -- Dias para trabalhar               
          

Work_Load :  array constante  ( Working_Day ) de Working_Hours -- declaração de tipo implícita := ( Friday => 6 , Monday => 4 , other => 10 ); -- tabela de consulta para horas de trabalho com inicialização    
                       

Os tipos podem ter modificadores como limited, abstract, private etc. Os tipos privados só podem ser acessados ​​e os tipos limitados só podem ser modificados ou copiados dentro do escopo do pacote que os define. [32] Ada 95 adiciona mais recursos para extensão de tipos orientada a objetos.

Estruturas de controle

Ada é uma linguagem de programação estruturada , o que significa que o fluxo de controle é estruturado em instruções padrão. Todas as construções padrão e saída antecipada de nível profundo são suportadas, portanto, o uso dos comandos " go to " também suportados raramente é necessário.

-- enquanto a não é igual a b, loop. 
enquanto  um  /=  b  loop 
  Ada . Texto_IO . Put_Line  ( "Aguardando" ); 
final  do ciclo ;

se  a  >  b  então 
  Ada . Texto_IO . Put_Line  ( "Condição atendida" ); 
senão 
  Ada . Texto_IO . Put_Line  ( "Condição não atendida" ); 
terminar  se ;

para  i  em  1  ..  10  loop 
  Ada . Texto_IO . Put  ( "Iteração:" ); 
  Ada . Texto_IO . Coloque  ( i ); 
  Ada . Texto_IO . Put_Line ; 
final  do ciclo ;

loop 
  a  :=  a  +  1 ; 
  sair  quando  a  =  10 ; 
final  do ciclo ;

caso  i  é 
  quando  0  =>  Ada . Texto_IO . Coloque  ( "zero" ); 
  quando  1  =>  Ada . Texto_IO . Put  ( "um" ); 
  quando  2  =>  Ada . Texto_IO . Put  ( "dois" ); 
  -- declarações case devem cobrir todos os casos possíveis: 
  when  other  =>  Ada . Texto_IO . Put  ( "nenhuma das anteriores" ); 
caso final ;

for  aWeekday  in  Weekday ' Range  loop                -- loop sobre uma enumeração 
   Put_Line  (  Weekday ' Image ( aWeekday )  );          -- output string representação de uma enumeração 
   se  aWeekday  in  Working_Day  then                -- check de um subtipo de uma enumeração 
      Put_Line  (  "to work for"  & 
               Working_Hours ' Image  ( Work_Load ( aWeekday ))  );  -- acesso em uma tabela de pesquisa 
   end  if ; 
fim laço ;

Pacotes, procedimentos e funções

Entre as partes de um programa Ada estão pacotes, procedimentos e funções.

Exemplo: especificação do pacote (example.ads)

 Exemplo de  pacote é 
     tipo  Número  é  intervalo  1  ..  11 ; 
     procedimento  Print_and_Increment  ( j : in  out  Number ); 
fim  Exemplo ;

Corpo do pacote (example.adb)

com  Ada.Text_IO ; 
corpo do pacote  Exemplo é  

  i  :  Number  :=  Number ' First ;

  procedimento  Print_and_Increment  ( j : in  out  Number )  é

    function  Next  ( k : in  Number )  return  Number  é 
    begin 
      return  k  +  1 ; 
    fim  Próximo ;

  comece 
    Ada . Texto_IO . Put_Line  (  "O total é:"  &  Number ' Image ( j )  ); 
    j  :=  Próximo  ( j ); 
  end  Print_and_Increment ;

-- inicialização do pacote executada quando o pacote é elaborado 
começa 
  while  i  <  Number ' Last  loop 
    Print_and_Increment  ( i ); 
  final  do ciclo ; 
fim  Exemplo ;

Este programa pode ser compilado, por exemplo, usando o compilador de código aberto disponível gratuitamente GNAT , executando

gnatmake -z exemplo.adb

Pacotes, procedimentos e funções podem ser aninhados em qualquer profundidade, e cada um também pode ser o bloco lógico mais externo.

Cada pacote, procedimento ou função pode ter suas próprias declarações de constantes, tipos, variáveis ​​e outros procedimentos, funções e pacotes, que podem ser declarados em qualquer ordem.

Simultaneidade

Ada tem suporte a idiomas para simultaneidade baseada em tarefas. A unidade concorrente fundamental em Ada é uma tarefa , que é um tipo limitado embutido. As tarefas são especificadas em duas partes – a declaração da tarefa define a interface da tarefa (semelhante a uma declaração de tipo), o corpo da tarefa especifica a implementação da tarefa. Dependendo da implementação, as tarefas do Ada são mapeadas para threads ou processos do sistema operacional ou são agendadas internamente pelo runtime do Ada.

As tarefas podem ter entradas para sincronização (uma forma de transmissão síncrona de mensagens ). As entradas de tarefa são declaradas na especificação da tarefa. Cada entrada de tarefa pode ter uma ou mais instruções de aceitação no corpo da tarefa. Se o fluxo de controle da tarefa atingir uma instrução de aceitação, a tarefa será bloqueada até que a entrada correspondente seja chamada por outra tarefa (da mesma forma, uma tarefa de chamada será bloqueada até que a tarefa chamada atinja a instrução de aceitação correspondente). As entradas de tarefas podem ter parâmetros semelhantes aos procedimentos, permitindo que as tarefas troquem dados de forma síncrona. Em conjunto com comandos select , é possível definir guardas em comandos de aceitação (semelhante aos comandos guardados de Dijkstra ).

A Ada também oferece objetos protegidos para exclusão mútua . Objetos protegidos são uma construção semelhante a um monitor , mas usam guardas em vez de variáveis ​​condicionais para sinalização (semelhante a regiões críticas condicionais). Objetos protegidos combinam o encapsulamento de dados e a exclusão mútua segura de monitores e protetores de entrada de regiões críticas condicionais. A principal vantagem sobre os monitores clássicos é que as variáveis ​​condicionais não são necessárias para sinalização, evitando possíveis deadlocks devido à semântica de bloqueio incorreta. Assim como as tarefas, o objeto protegido é um tipo limitado interno e também possui uma parte de declaração e um corpo.

Um objeto protegido consiste em dados privados encapsulados (que só podem ser acessados ​​de dentro do objeto protegido) e procedimentos, funções e entradas que são garantidamente mutuamente exclusivas (com a única exceção de funções, que devem ser livres de efeitos colaterais e, portanto, pode ser executado simultaneamente com outras funções). Uma tarefa que chama um objeto protegido é bloqueada se outra tarefa estiver em execução no mesmo objeto protegido e liberada quando essa outra tarefa sai do objeto protegido. As tarefas bloqueadas são enfileiradas no objeto protegido ordenadas por hora de chegada.

As entradas de objetos protegidos são semelhantes aos procedimentos, mas também possuem guards . Se um guarda for avaliado como falso, uma tarefa de chamada será bloqueada e adicionada à fila dessa entrada; agora outra tarefa pode ser admitida no objeto protegido, pois nenhuma tarefa está sendo executada no momento dentro do objeto protegido. Os guardas são reavaliados sempre que uma tarefa sai do objeto protegido, pois este é o único momento em que a avaliação dos guardas pode ser alterada.

As chamadas para entradas podem ser reenfileiradas para outras entradas com a mesma assinatura. Uma tarefa reenfileirada é bloqueada e adicionada à fila da entrada de destino; isso significa que o objeto protegido é liberado e permite a admissão de outra tarefa.

A instrução select em Ada pode ser usada para implementar chamadas e aceitações de entrada sem bloqueio, seleção não determinística de entradas (também com guardas), tempos limite e abortos.

O exemplo a seguir ilustra alguns conceitos de programação concorrente em Ada.

com  Ada.Text_IO ;  use  Ada.Text_IO ;

procedimento  O tráfego  é

   tipo  Airplane_ID  é o  intervalo  1. . 10 ;              -- 10 aviões

    tipo de  tarefa Avião  ( ID : Airplane_ID );         -- task representando aviões, com ID como parâmetro de inicialização 
   tipo  Airplane_Access  é  access  Airplane ;      -- tipo de referência para avião

    tipo  protegido Pista  é                      -- a pista compartilhada (protegida para permitir acesso simultâneo) 
      entrada  Assign_Aircraft  ( ID : Airplane_ID );   -- todas as entradas são garantidas mutuamente exclusivas 
      entrada  Cleared_Runway  ( ID : Airplane_ID ); 
      entrada  Wait_For_Clear ; 
   private 
      Clear :  Boolean  :=  True ;                    - dados privados protegidos - geralmente mais do que apenas uma bandeira... 
   end  Runway ; 
   tipo  Runway_Access  é  acessar  todos Pista ;

   -- a tarefa do controlador de tráfego aéreo recebe solicitações para decolagem e aterrissagem 
   tipo de tarefa  Controlador ( My_Runway : Runway_Access ) é -- entradas de tarefa para entrada síncrona de passagem de mensagens Request_Takeoff ( ID : in Airplane_ID ; Takeoff : out Runway_Access ) ; entrada Request_Approach ( ID : in Airplane_ID ; Approach : out Runway_Access ); final Controlador ;   
      
           
          
    

   -- alocação de instâncias 
   Runway1     :  alias  Runway ;               -- instancia uma pista 
   Controller1 :  Controller  ( Runway1 ' Access ) ;  -- e um controlador para gerenciá-lo

   ------ as implementações dos tipos acima ------ 
   corpo protegido  Runway is entry Assign_Aircraft ( ID : Airplane_ID ) quando Clear é - as tarefas de chamada de guarda de entrada são bloqueadas até que a condição seja verdadeira begin Clear : = Falso ; Put_Line ( Airplane_ID ' Image ( ID ) & "na pista" ); fim ;  
        
      
      
         
           
      

      entrada  Cleared_Runway  ( ID : Airplane_ID ) 
 quando  não  Clear  é 
      begin 
         Clear  :=  True ; 
         Put_Line  ( Airplane_ID ' Image  ( ID )  &  "pista liberada" ); 
      fim ;

      entrada  Wait_For_Clear 
 quando  Clear  é 
      begin 
         null ;       -- não há necessidade de fazer nada aqui - uma tarefa só pode entrar se "Clear" for true 
      end ; 
   fim  da Pista ;

    corpo da  tarefa O controlador  é 
   iniciar 
      o loop 
         My_Runway . Wait_For_Clear ;    -- espera até que a pista esteja disponível (chamada de bloqueio) 
         select                       -- espera por dois tipos de requisições (o que for executável primeiro) 
            quando  Request_Approach ' count  =  0  =>   -- guard statement - aceita somente se não houver tarefas enfileiradas em Request_Approach 
             aceitar  Request_Takeoff  ( ID :  in  Airplane_ID ;  Takeoff :  out  Runway_Access ) 
             do                                  -- início da parte sincronizada
               My_Runway . Assign_Aircraft  ( ID );   -- reserva de pista (potencialmente bloqueando a chamada se o objeto protegido estiver ocupado ou o guarda de entrada for falso) 
               Decolagem  :=  My_Runway ;             -- atribui o valor do parâmetro "out" para dizer ao avião qual o 
             fim da pista  Request_Takeoff ;                -- fim da parte sincronizada 
         ou 
            aceite  Request_Approach  ( ID :  in  Airplane_ID ;  Approach :  out  Runway_Access )  do 
               My_Runway . Assign_Aircraft  ( ID ); 
               Aproximação :=  Minha_Pista ; 
            end  Request_Approach ; 
         ou                           --terminar se não restar nenhuma tarefa que possa chamar de 
            terminação ; 
         fim  de seleção ; 
      final  do ciclo ; 
   fim ;

    corpo da  tarefa O avião  é 
      Rwy  :  Runway_Access ; 
   iniciar 
      Controlador1 . Request_Takeoff  ( ID ,  Rwy );  -- Esta chamada é bloqueada até que a tarefa Controller aceite e complete o bloco de aceitação 
      Put_Line  ( Airplane_ID ' Image  ( ID )  &  " decolagem ..." ); 
      atraso  2,0 ; 
      Rua . Cleared_Runway  ( ID );                -- a chamada não será bloqueada como "Clear" em Rwy agora é falsa e nenhuma outra tarefa deve estar dentro do objeto protegido
      atraso  5,0 ;  -- voe um pouco ... 
      loop 
         select    -- tente solicitar um 
            controlador de pista1 . Request_Approach  ( ID ,  Rwy );  - esta é uma chamada de bloqueio - será executada no controlador atingindo o bloco de aceitação e retornará na conclusão da 
            saída ;  -- se a chamada for retornada estamos liberados para o pouso - saia do bloco de seleção e prossiga... 
         ou 
            atraso  3.0 ;   -- timeout - se não houver resposta em 3 segundos, faça outra coisa (tudo no bloco seguinte) 
            Put_Line  ( Airplane_ID ' Image  ( ID )  & "em padrão de espera" );   -- simplesmente imprima uma mensagem e 
         finalize a  seleção ; 
      final  do ciclo ; 
      atraso  4,0 ;   -- fazer aproximação de pouso... 
      Put_Line  ( Airplane_ID ' Image  ( ID )  &  "tocou no chão!" ); 
      Rua . Cleared_Runway  ( ID );   -- notifique a pista que terminamos aqui. 
   fim ;

   New_Airplane :  Airplane_Access ;

begin 
   for  I  in  Airplane_ID ' Range  loop   -- cria algumas tarefas de avião 
      New_Airplane  :=  new  Airplane  ( I );  -- começará a ser executado diretamente após o 
      atraso de criação  4.0 ; 
   final  do ciclo ; 
fim  de Tráfego ;

Pragmas

Um pragma é uma diretiva do compilador que transmite informações ao compilador para permitir a manipulação específica da saída compilada. [33] Certos pragmas são embutidos na linguagem, [34] enquanto outros são específicos da implementação.

Exemplos de uso comum de pragmas do compilador seriam desabilitar certos recursos, como verificação de tipo em tempo de execução ou verificação de limite de subscrito de matriz, ou instruir o compilador a inserir código de objeto em vez de uma chamada de função (como C/C++ faz com funções inline ).

Genéricos

Ada tem genéricos desde que foi projetado pela primeira vez em 1977-1980. A biblioteca padrão usa genéricos para fornecer muitos serviços. O Ada 2005 adiciona uma biblioteca de contêiner genérica abrangente à biblioteca padrão, que foi inspirada na biblioteca de modelos padrão do C++ .

Uma unidade genérica é um pacote ou um subprograma que recebe um ou mais parâmetros formais genéricos .

Um parâmetro formal genérico é um valor, uma variável, uma constante, um tipo, um subprograma ou mesmo uma instância de outra unidade genérica designada. Para tipos formais genéricos, a sintaxe distingue entre tipos discretos, de ponto flutuante, de ponto fixo, de acesso (ponteiro), etc. Alguns parâmetros formais podem ter valores padrão.

Para instanciar uma unidade genérica, o programador passa parâmetros reais para cada formal. A instância genérica então se comporta como qualquer outra unidade. É possível instanciar unidades genéricas em tempo de execução , por exemplo, dentro de um loop.

Veja também

  • APSE – uma especificação para um ambiente de programação para apoiar o desenvolvimento de software em Ada
  • Perfil Ravenscar – um subconjunto dos recursos de tarefas Ada projetados para computação em tempo real de segurança crítica
  • SPARK (linguagem de programação) – uma linguagem de programação que consiste em um subconjunto altamente restrito de Ada, anotado com meta-informações que descrevem o comportamento do componente desejado e os requisitos individuais de tempo de execução

Referências

  1. ^ "Corrigendum Técnico para Ada 2012 publicado pela ISO" . Associação de Recursos Ada. 2016-01-29 . Recuperado 2016-02-23 .
  2. ^ "Manual de referência de idioma consolidado Ada 2012" . Autoridade de Avaliação de Conformidade Ada. Arquivado a partir do original em 2016-03-03 . Recuperado 2016-02-23 .
  3. ^ "PTC ObjectAda" . PTC . com . Recuperado em 27/01/2014 .
  4. ^ "AdaMagic com certificado C Intermediário" .
  5. ^ Ada Rationale, 1986, pp. 23, 70, 110-114, 137, 165, 236
  6. ^ "Especificação da Capela (Agradecimentos)" (PDF) . Cray Inc. 2015-10-01 . Recuperado 2016-01-14 .
  7. ^ "Dragão" . Arquivado a partir do original em 14/09/2020 . Recuperado 2018-08-06 .
  8. ^ "Grifo" .
  9. ^ "SPARforte" .
  10. ^ Ganssle, Jack (2013-05-29). "Ada Resource Association - Notícias e recursos para a linguagem de programação Ada" . Adaic.org . Recuperado 2013-06-14 .
  11. ^ a b "ISO/IEC 8652:2012 Tecnologia da informação – Linguagens de programação – Ada " . Organização Internacional de Normalização . Recuperado em 23/12/2012 .
  12. ^ "A linguagem de programação Ada" . Universidade de Mich . Arquivado a partir do original em 22/05/2016 . Recuperado em 27 de maio de 2016 .
  13. ^ Fuegi, J; Francisco, J (2003). "Lovelace & Babbage e a criação das 'notas' de 1843". IEEE Annals of the History of Computing . 25 (4): 16–26. doi : 10.1109/MAHC.2003.1253887 . S2CID  40077111 .
  14. ^ "Simultaneidade - Capítulo 6 - Guia de QUALIDADE E ESTILO Ada 95" . adaic.org . Recuperado em 5 de novembro de 2021 .
  15. ^ Taft, S. Tucker; Olsen, Florença (1999-06-30). "Ada ajuda a produzir código com menos bugs" . Notícias de informática do governo. págs. 2–3 . Recuperado 2010-09-14 .
  16. ^ a b c Feldman, Michael. "Quem está usando Ada?" . Grupo de Trabalho de Educação SIGada.
  17. ^ no safe dynamic memory management in ADA , em: Writing Linux Kernel Modules in Safe Rust - Geoffrey Thomas & Alex Gaynor , The Linux Foundation, 2019-10-02
  18. ^ "John Goodenough | Perfil da equipe da SEI" . Sei.cmu.edu . Recuperado em 27/01/2014 .
  19. ^ CARRO, Hoare (1981). "Roupas Velhas do Imperador" (PDF) . Comunicações da ACM . Associação de Máquinas de Computação . 24 (2): 75–83. doi : 10.1145/358549.358561 . S2CID 97895 .  
  20. ^ Watt, DA; Wichmann, BA; Findlay, W. (1987). Ada: Linguagem e Metodologia . Prentice-Hall.
  21. ^ a b c d Sward, Ricky E. (novembro de 2010). "A ascensão, queda e persistência de Ada". SIGada '10: Actas da conferência internacional anual da ACM SIGada sobre SIGada . págs. 71–74. doi : 10.1145/1879063.1879081 .
  22. ^ a b c Rosen, JP. (agosto de 2009). "O paradoxo Ada (es)". Letras Ada . ACM SIGADA. 24 (2): 28–35. doi : 10.1145/1620593.1620597 . S2CID 608405 . 
  23. ^ SoftTech Inc. (1983-04-11). "Relatório Resumido de Validação do Compilador Ada: NYU Ada/ED, Versão 19.7 V-001" . Waltham, MA. Arquivado a partir do original em 2012-03-12 . Recuperado em 2010-12-16 .
  24. ^ Dewar, Robert BK; Fisher, Gerald A. Jr.; Schonberg, Edmond; Froelich, Robert; Bryant, Stephen; Goss, Clinton F.; Burke, Michael (novembro de 1980). "O NYU Ada Tradutor e Intérprete". Avisos ACM SIGPLAN – Anais do Simpósio ACM-SIGPLAN sobre a Linguagem de Programação Ada . 15 (11): 194–201. doi : 10.1145/948632.948659 . ISBN 0-89791-030-3. S2CID  10586359 .
  25. ^ "Lista de compiladores validados Ada" . Ada Information Clearinghouse. 1º de julho de 1992. pp. 1–36.
  26. ^ Câmara de informação de Ada (1983-04-11). "O Mandato Ada do Congresso" . Arquivado a partir do original em 2016-03-04 . Recuperado 2015-06-07 .
  27. ^ Babiak, Nicholas J. (1989). Ada, a nova linguagem de computador do sistema de armas do DoD – Panacea ou Calamity (PDF) . Universidade Aérea (Força Aérea dos Estados Unidos) . págs. 39–40.
  28. ^ a b Rehmer, Karl (2009). "Equipe HADS". Em Stellman, Andrew; Greene, Jennifer (ed.). Equipes bonitas: contos inspiradores e preventivos de líderes de equipe veteranos . Sebastopol, Califórnia: O'Reilly. págs. 299–312.
  29. ^ a b Wolfe, Alexander (outubro de 2004). "Ainda há alguma vida em Ada" . Fila ACM . 2 (7): 28–31. doi : 10.1145/1035594.1035608 .
  30. ^ Ada Core. "GNAT Pro escolhido para o sistema ATC de próxima geração do Reino Unido" . Arquivado a partir do original em 24/12/2010 . Recuperado em 2011-03-01 .
  31. ^ Ada Core. "Olha quem está usando Ada" . Arquivado a partir do original em 24/12/2010 . Recuperado em 2011-03-01 .
  32. ^ "Cartão de Sintaxe Ada" (PDF) . Arquivado a partir do original (PDF) em 6 de julho de 2011 . Recuperado em 28 de fevereiro de 2011 .
  33. ^ "Ada 83 LRM, Sec 2.8: Pragmas" . Archive.adaic . com . Recuperado em 27/01/2014 .
  34. ^ "Ada 83 LRM, Apêndice/Anexo B: Pragmas de linguagem predefinidos" . Archive.adaic. com. Arquivado a partir do original em 2012-02-06 . Recuperado em 27/01/2014 .

Normas internacionais

Justificativa

Esses documentos foram publicados em várias formas, incluindo impressão.

Livros

  • Booch, Grady (1987). Engenharia de Software com Ada . Califórnia: The Benjamin/Cummings Publishing Company. ISBN 0-8053-0604-8.
  • Skansholm, janeiro (1996). Ada 95 Desde o Princípio . Addison-Wesley. ISBN 0-201-40376-5.
  • Gilpin, Geoff (1985). Ada: uma visita guiada e tutorial . Salão Prentice. ISBN 978-0-13-004045-9.
  • Barnes, John (2006). Programação em Ada 2005 . Addison-Wesley. ISBN 0-321-34078-7.
  • Barnes, John (1991). Programação em Ada plus Language Reference Manual . Addison-Wesley. ISBN 0-201-56539-0.
  • Barnes, John (1998). Programação em Ada 95 . Addison-Wesley. ISBN 0-201-34293-6.
  • Barnes, John (1997). Alta Integridade Ada: A Abordagem SPARK . Addison-Wesley. ISBN 0-201-17517-7.
  • Barnes, John (2003). Software de alta integridade: a abordagem SPARK para segurança e proteção . Addison-Wesley. ISBN 0-321-13616-0.
  • Beidler, John (1997). Estruturas de Dados e Algoritmos: Uma Abordagem Orientada a Objetos Usando Ada 95 . Springer-Verlag. ISBN 0-387-94834-1.
  • Gonzalez, Dean W. (1991). Manual do programador Ada . Editora Benjamin-Cummings. ISBN 0-8053-2529-8.
  • Ben-Ari, M. (1998). Ada para Engenheiros de Software . John Wiley & Filhos. ISBN 0-471-97912-0.
  • Cohen, Norman (1996). Ada como segunda língua . McGraw-Hill Ciência/Engenharia/Matemática. ISBN 0-07-011607-5.
  • Burns, Alan ; Wellings, Andy (2001). Sistemas de Tempo Real e Linguagens de Programação. Ada 95, Java em Tempo Real e POSIX em Tempo Real . Addison-Wesley. ISBN 0-201-72988-1.
  • Burns, Alan ; Wellings, Andy (1995). Simultaneidade em Ada . Cambridge University Press. ISBN 0-521-62911-X.
  • Atkinson, Colin (1991). Reutilização, simultaneidade e distribuição orientadas a objetos: uma abordagem baseada em Ada . Addison-Wesley. ISBN 0-201-56527-7.
  • Booch, Grady ; Bryan, Douglas (1994). Engenharia de Software com Ada . Addison-Wesley. ISBN 0-8053-0608-0.
  • Jones, Do-While (1989). Ada em ação: com exemplos práticos de programação . John Wiley & Filhos. ISBN 0-471-60708-8.
  • Stubbs, Daniel; Webre, Neil W. (1993). Estruturas de dados com tipos de dados abstratos e Ada . Brooks Cole. ISBN 0-534-14448-9.
  • Ledru, Pascal (dezembro de 1998). Programação Distribuída em Ada com Objetos Protegidos . Dissertation. com. ISBN 1-58112-034-6.
  • Culwin, Fintan (1997). Ada, uma abordagem de desenvolvimento . Prentice Hall. ISBN 0-13-264680-3.
  • Inglês, João; Culwin, Fintan (janeiro de 1997). Ada 95 a Arte da Programação Orientada a Objetos . Prentice Hall. ISBN 0-13-230350-7.
  • Musser, David R.; Stepanov, Alexander (24 de outubro de 1989). A Biblioteca Genérica Ada: Pacotes de Processamento de Lista Linear . Springer-Verlag. ISBN 0-387-97133-5.
  • Feldman, Michael B. (1997). Construção de Software e Estruturas de Dados com Ada 95 . Addison-Wesley. ISBN 0-201-88795-9.
  • Johnston, Simon (1997). Ada 95 para programadores C e C++ . Addison-Wesley. ISBN 0-201-40363-3.
  • Feldman, Michael B.; Koffman, Elliot B. (1992-1993). Ada: Resolução de Problemas e Design de Programas . Addison-Wesley. ISBN 0-201-52279-9.795 páginas.
  • Feldman, Michael B .; Koffman, Elliot B. (1999). Ada 95 . Addison-Wesley. ISBN 0-201-36123-X.
  • Dale, Nell B .; Weems, Chip; McCormick, John (agosto de 1996). Programação e resolução de problemas com Ada 95 . Editores Jones & Bartlett. ISBN 0-7637-0293-5.
  • Dale, Nell B .; McCormick, John (2007). Estruturas de Dados Ada Plus: Uma Abordagem Orientada a Objetos, 2ª edição . Editores Jones & Bartlett. ISBN 978-0-7637-3794-8.
  • Krell, Bruce C. (1992). Desenvolvendo com Ada: Métodos de Ciclo de Vida . Bantam Dell Pub Group. ISBN 0-553-09102-6.
  • Bispo, Judy (10 de maio de 1990). Ada Distribuída: Desenvolvimentos e Experiências . Cambridge University Press. ISBN 0-521-39251-9.
  • Sanden, Bo (1994). Construção de Sistemas de Software com Exemplos em Ada . Prentice Hall. ISBN 0-13-030834-X.
  • Hillam, Bruce (1994). Introdução aos tipos de dados abstratos usando Ada . Prentice Hall. ISBN 0-13-045949-6.
  • Rudd, David (1994). Introdução ao Design e Desenvolvimento de Software com Ada . Brooks Cole. ISBN 0-314-02829-3.
  • Pyle, Ian C. (1991). Desenvolvendo Sistemas de Segurança: Um Guia Usando Ada . Prentice Hall. ISBN 0-13-204298-3.
  • Baker, Louis (1989). Inteligência Artificial Com Ada . McGraw-Hill. ISBN 0-07-003350-1.
  • Burns, Alan ; Wellings, Andy (1995). HRT-HOOD: Um Método de Projeto Estruturado para Sistemas Ada Hard Real-Time . Norte-Holanda. ISBN 0-444-82164-3.
  • Savitch, Walter; Peterson, Charles (1992). Ada: Uma Introdução à Arte e Ciência da Programação . Editora Benjamin-Cummings. ISBN 0-8053-7070-6.
  • Weiss, Mark Allen (1993). Estruturas de Dados e Análise de Algoritmos em Ada . Editora Benjamin-Cummings. ISBN 0-8053-9055-3.
  • Ledgard, Henry (1983). Ada: Uma Introdução (segunda ed.). Springer-Verlag. ISBN 0-387-90814-5.
  • Bjørner, Dines; Oest, Ole N., eds. (1980). Rumo a uma descrição formal de Ada . Londres: Springer-Verlag. ISBN 3-540-10283-3.

Arquivos

Links externos