Oz (linguagem de programação)

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
Principais implementações	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

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, orientada a objeto com restrições, distribuída e concorrente. Oz tem tanto uma forma semântica simples e uma semântica eficiente^{[carece de fontes]}. Oz é uma linguagem orientada a concorrencia, termo introduzido por Joe Armstrong, o principal designer da Erlang.

Plataforma:

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

Modelo de programação

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

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 lógicas, ou seja, só podem ser instanciadas uma vez. Este tipo de variáveis é usada em linguagens lógicas, como prolog.

Funções

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 restando)
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

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 funcionam, é 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.

Outro Exemplo

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

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

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

É novamente possível estender o modelo declarativo para apoiar a 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

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.

Aplicações

• Linguagem para aprendizado: Desenvolvido para ensinar programação, introduzir conceitos novos e mostrar sua eficiencia;
• Simulações: Imita a operação de um processo do mundo real p sistema a longo tempo
• Sistema multi-agente:
• Processamento Natural da Linguagem:
• Realidade Virtual:

Ligações externas

• Sistema de programação Mozart
• TimeLine JS
• Uma rápida visão do Oz
• Tutorial de Oz
• Oz Mozart Tutorial em formato de blog