Oz (linguagem de programação)

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 Abril de 2008).
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êmicoScirusBing. Veja como referenciar e citar as fontes.
Oz
Paradigma multiparadigmal, lógica, funcional, imperativa, orientada a objetos, com restrições, concorrente.
Surgido em 1991
Criado por Gert Smolka e seus estudantes
Estilo de tipagem: dinâmica
Compiladores Sistema de programação Mozart
Influenciada por Erlang, Lisp, Prolog
Influenciou Alice
Página oficial www.mozart-oz.org

Oz é uma linguagem de programação multiparadigma, desenvolvida nos Laboratórios de Sistemas de Programação da Saarland University.

Oz foi primeiro desenvolvida por Gert Smolka e seus estudantes em 1991.

No ano de 1995, foi lançado a primeira versão do Oz, o OZ 1. Ele caracterizava-se por basear-se num modelo de concorrencia, que assume que qualquer expressão pode potencialmente ser executada de modo concorrente. Mais tarde, surgiu a versão Oz 2, que teve como principal novidade melhoramentos relativas ao modelo de concorrencia anterior. Em 1996 o desenvolvimento do Oz continuou em cooperação com o grupo de pesquisa de Seif Haridi no Swedish Institute of Computer Science. Desde 1999, Oz tem sido continuamente desenvolvido por um grupo internacional, o Mozart Consortium, que originalmente consistia da Saarland University, da Swedish Institute of Computer Science, e da Université catholique de Louvain. Em 2005, a responsabilidade do desenvolvimento Mozart foi transferida para um grupo, Mozart Board, com o propósito expresso de abrir o desenvolvimento Mozart para uma comunidade maior.

O Sistema de programação Mozart é a implementação do Oz 3. Ele foi lançado com uma licença de Código aberto pela Mozart Consortium. Mozart foi levado para várias plataformas, como Unix, FreeBSD, GNU/Linux, Microsoft Windows, e Mac OS X. As principais diferenças das versões anteriores estão relacionados a introdução de functors(componentes de softwares espalhados por diferentes URLs), e as futures (sincronização do fluxo de dados na internet)

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

Oz é uma linguagem que veio a partir da experiência de outras linguagens, tais como prolog, Earland e lisp, portando a maior parte dos conceitos dos maiores paradigmas de programação, incluindo paradigmas lógico, funcional (tanto lazy quanto eager), imperativo, orientado a objeto com restrições, distribuído e concorrente. Oz tem tanto uma forma semântica simples e uma semântica eficiente[carece de fontes?]. Oz é uma linguagem orientada a concorrência, termo introduzido por Joe Armstrong, o principal designer da Erlang.

Plataforma:
  • Possui maquina virtual, que é portavel e pode ser executada em sistemas Unix ou Windowns
  • O sistema Mozart tem uma biblioteca orientada a objetos qu disponibiliza funcionalidades de interface gráfico baseadas em Tcl/Tk.
  • Facilmente expandido de forma a aumentar as suas funcionalidades através de suas DLLs.

Modelo de programação[editar | editar código-fonte]

O modelo Oz é constituído por uma area de armazenamento abstrata feita por thread de fluxo de dados. Por meio delas, é possível realizar a execução de sequencias, expressões e realizar o bloqueio quando ocorre a indisponibilidade de dados na área de restrições. Sua área de armazenamento é composto por 3 componentes: a área de restrições, com as variáveis e valores instanciados, área de procedimentos, com as definições dos procedimentos e a área das células', com os apontadores mutáveis. A implementação da linguagem é realizada num ambiente de desenvolvimento chamado de OPI (Oz Programming Interface). Este ambiente de desenvolvimento usa o Emacs, expandindo os seus menus e coloração sintáctica, de forma a facilitarem a programação.

Programando em OZ[editar | editar código-fonte]

A melhor forma de iniciar a programação é começando pela sequencial, levando-se em consideração que um conjunto de instruções podem ser executadas sequencialmente (thread). As variáveis em OZ são variáveis logicas, ou seja, só podem ser instanciadas uma vez. este tipo de variáveis é usada em linguagens logicas, como prolog.

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

Funções são valores de primeira classe, permitindo a programação de ordem superior funcional:

fun {Fact N}
   if N =< 0 then 1 else N*{Fact N-1} end
end

fun {Comb N K}
   {Fact N} div ({Fact K} * {Fact N-K}) % Não existe estouro de inteiros em Oz (a não ser que não haja memória sobrando)
end

fun {SumList List}
   case List of nil then 0
   [] H|T then H+{SumList T} 
   end
end

Variáveis ​​de fluxo de dados e simultaneidade declarativa[editar | editar código-fonte]

Quando o programa encontra uma variável unbound (fora dos limites) ele espera por um valor:

thread 
   Z = X+Y     % irá esperar até que ambos X e Y são ligados a um valor.
   {Browse Z}  % Mostra o valor de Z.
end
thread X = 40 end
thread Y = 2 end

Não é possível alterar o valor de uma variável de fluxo de dados, uma vez que é ligada:

X = 1
X = 2 % erro

Variáveis ​​de fluxo de dados tornam mais fácil a criação de agentes de fluxo concorrentes:

fun {Ints N Max}
   if N == Max then nil
   else 
      {Delay 1000}
      N|{Ints N+1 Max}
   end
end

fun {Sum S Stream}
   case Stream of nil then S
   [] H|T then S|{Sum H+S T} end
end

local X Y in
   thread X = {Ints 0 1000} end
   thread Y = {Sum 0 X} end
   {Browse Y}
end

Devido à maneira como as variáveis ​​de fluxo de dados funciona, é possível colocar threads em qualquer parte do programa e garante-se que ele terá o mesmo resultado. Isto faz com que a programação concorrente seja muito fácil. Threads são muito baratas: é possível ter centenas de milhares de threads em execução de uma só vez.[1]

Outro Exemplo[editar | editar código-fonte]

Esse exemplo calcula um fluxo de números primos usando o algoritmo Trial division, através da criação recursiva de agentes concorrentes de fluxo que filtram números não primos:

fun {Sieve Xs}
   case Xs of nil then nil
   [] X|Xr then Ys in
      thread Ys = {Filter Xr fun {$ Y} Y mod X \= 0 end} end
      X|{Sieve Ys}
   end
end

Laziness[editar | editar código-fonte]

Oz faz uso de eager evaluation por padrão, mas lazy evaluation também é possível:

fun lazy {Fact N}
   if N =< 0 then 1 else N*{Fact N-1} end
end
local X Y in
  X = {Fact 100} 
  Y = X + 1 % the value of X is needed and fact is computed
end

Simultaneidade de passagem de mensagens[editar | editar código-fonte]

O modelo declarativo concorrente pode ser estendido com a passagem de mensagens através da semântica simples:

declare
local Stream Port in
   Port = {NewPort Stream}
   {Send Port 1} % Stream is now 1|_ ('_' indicates an unbound and unnamed variable)
   {Send Port 2} % Stream is now 1|2|_ 
   ...
   {Send Port n} % Stream is now 1|2| .. |n|_
end 

Com uma porta e uma thread o programador pode definir agentes assíncronos:

fun {NewAgent Init Fun}
   Msg Out in
   thread {FoldL Msg Fun Init Out} end
   {NewPort Msg}
end

Estado e objetos[editar | editar código-fonte]

É novamente possível estender o modelo declarativo para o apoiar programação orientada a objetos e a estado com uma semântica muito simples; nós criamos uma nova estrutura de dados mutável chamada Cells:

local A X in
   A = {NewCell 0}
   A := 1  % changes the value of A to 1
   X = @A  % @ is used to access the value of A
end

Com essas simples mudanças de semântica, podemos apoiar o paradigma orientado a objetos. Com um pouco de açúcar sintático (syntactic sugar) a programação orientada a objetos torna-se bem integrada em Oz.

class Counter
   attr val
   meth init(Value)
      val:=Value
   end
   meth browse
      {Browse @val}
   end
   meth inc(Value)
      val :=@val+Value
   end
end

local C in
   C = {New Counter init(0)}
   {C inc(6)}
   {C browse}
end

Velocidade de Execução[editar | editar código-fonte]

A velocidade de execução de um programa produzido pelo compilador Mozart (versão 1.4.0 implementando Oz 3) é muito lenta. Em um benchmark(teste de desempenho) é na média cerca de 50 vezes mais lento do que o compilador GCC para a linguagem C, resolvendo as tarefas de benchmark.[2]

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

Referências

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