P@J
João Henrique da Rosa
Universidade do Vale dos Sinos
Unisinos 950, São Leopoldo, RS, Brasil
[email protected]
satisfazer essas características inteiramente através das
linguagens orientadas a objetos é muito difícil e tomaria
muito tempo do programador. Então é proposto o uso da
programação declarativa baseada em lógica, a qual
disponibiliza ótimas configurações para construção de
componentes de softwares baseados em teorias lógicas,
onde os conceitos de raciocínio, dedução e, especificações
declarativas de algoritmos e comportamentos, são
compreendidos e implementados de forma mais simples.
Devido a esses fatos, a orientação a objetos e a
programação declarativa baseada em lógica têm sido
objetos de muitos estudos, os quais buscam a integração
do que há melhor em cada um desses paradigmas.
Existem propostas, tais como a de Espák [2] e Natali [3],
quais visam essa integração, e algumas que têm por
objetivo apenas fornecer uma biblioteca de interface para
acessar o motor Prolog de linguagem orientada a objetos,
tal como Java.
Todavia, tanto na integração das linguagens quanto no
simples acesso do motor Prolog através de uma
biblioteca, há alguns inconvenientes. No
caso
da
integração das linguagens, a integridade conceitual do
modelo do programa é sacrificada com a introdução de
outra linguagem, além de aumentar a complexidade do
sistema e exigir dos desenvolvedores o conhecimento
dessa linguagem inserida. Já no fato de se possuir um
simples acesso ao motor Prolog, não há uma linguagem
de integração, porém, existe a necessidade de
implementação de “boilerplate code” a cada vez que
ocorressem desencontros entre os paradigmas.
Notando-se então os inconvenientes existentes tanto
no acesso do motor Prolog, quanto na utilização de uma
linguagem de integração, percebe-se a necessidade de
uma extensão que negocie de forma melhor a integração
de uma linguagem e a perda da integridade do programa.
Para suprir essa necessidade Cimadamore propõe o
desenvolvimento de um framework em cima de um motor
Prolog existente. Framework esse que baseia no Java
generics e Java annotations, e tem como objetivo fornecer
o completo aproveitamento da linguagem Prolog no Java.
O motor Prolog utilizado para concretização desse
framework foi o tuProlog, o qual possui muitas
qualidades, entre elas destacam-se os fatos dele ser leve e
escrito em Java. Com o tuProlog bibliotecas de Java
podem ser usadas para acessar teorias de Prolog, e viceversa, ou seja, uma biblioteca Prolog de predicados
lógicos pode ser usada para acessar Java APIs.
Resumo
Apesar das linguagens orientadas a objetos
atualmente serem o fluxo principal no desenvolvimento de
aplicações, várias pesquisas nesse contexto sugerem que
uma abordagem multiparadigma tem grande valor.
Principalmente levando-se em conta as funcionalidades
que o paradigma baseado em lógica oferece, tais como o
raciocínio automático e a capacidade de concisão para
expressar algoritmos. Cimadamore [1] sendo consciente
da importância de uma abordagem multiparadigma,
propõe um framework, chamado P@J, para reforçar a
interoperabilidade entre o Java e o Prolog. Essa
framework é baseada no TuProlog, qual é um motor de
Prolog open source para o Java. O P@J suporta leves
transparências de comunicação, ele faz isso
primeiramente através da introdução de uma API, a qual
é responsável pela modelagem dos termos lógicos de
primeira ordem. Essa API utiliza o Java Generics e Java
Wildcards, as quais dão mais semântica e segurança as
aplicações. Acima dessa API, uma camada de anotações,
Annotation layer, é introduzida, a qual herda o Java e,
tem a capacidade de implementar partes de códigos de
aplicações usando Prolog.
Palavras Chaves: Java, Prolog, Multiparadigm.
1. Introdução
O homem, com necessidade de resolução de
problemas cada vez mais abstratos, tem aumentado
consideravelmente a complexidade nos sistemas
computacionais. Esse aumento de abstração acontece por
dois caminhos principais, o da interação e o da
inteligência.
Na via da interação tem se os sistemas que são
tipicamente construídos por subsistemas, quais interagem
entre si com o objetivo de atingir a meta estabelecida pelo
software. Para concretização de sistemas com essa
característica, as linguagens orientadas a objetos são
vistas como uma ótima ferramenta, pois elas possuem
grande flexibilidade para esse tipo de modelagem.
Já na trilha da inteligência, os sistemas devem
geralmente ter embutidos a automática e complexa
capacidade de raciocínio, a habilidade de se adaptar e a
aptidão de se configurar em ordem de alcançar o seu
objetivo em ambientes abertos e imprevisíveis. Todavia,
1
Em cima desse motor foi introduzido um framework
chamado P@J, o qual herda a programação Java e possui
habilidades de Prolog. A estruturação do P@J é dividida
em duas camadas empilhadas, nas quais acontece a
redução da grande diferença de semântica entre Java e
Prolog.
Uma dessas camadas é a Generic API, a qual introduz
uma nova hierarquia de classes de Java com o objetivo de
modelar termos de Prolog, assim o código do usuário que
faz interface com o motor tuProlog pode alternar
automaticamente entre a representação de dados do tipo
orientado a objetos ou do tipo lógico.
A outra camada é a de anotações, Annotation layer, na
qual é adicionada uma verdadeira biblioteca Java baseada
no Prolog, disponibilizando assim anotações práticas de
Java para que o programador possa chamar teorias de
Prolog dentro de classes do Java.
Esse artigo está dividido em cinco seções. Na seção
dois serão abordadas questões relativas ao funcionamento
do motor tuProlog e, a suas características principais. Na
seção três será dada uma noção básica do funcionamento
da camada Generics API no P@J. Na seção quatro serão
mostradas as funcionalidades principais da camada de
anotações no P@J. Na seção cinco será feito uma
conclusão dos estudos.
Figura 1: Exemplo de permutação
Nesse exemplo o predicado any/3 recebe uma lista,
enquanto o predicado permutation/2 pega uma com uma
versão permutada. Embora esse seja somente um exemplo
com fins de explicação e muito simples, um programador
Java deve tirar proveito do fato do algoritmo de
permutação ser facilmente resolvido em Prolog.
Entretanto, é importante citar uma dificuldade inicial para
fazer o acesso do motor Prolog através de Java, essa
dificuldade consiste na estruturação dos dados, a qual é
dada de formas diferente em Java e Prolog. Porém, o
motor tuProlog soluciona isso de maneira inteligente com
inserção de um passo de transformação, o qual transforma
objetos comuns de Java para objetos do tipo Term
tuProlog.
Como o objetivo de familiarizar o leitor, na Figura
dois é mostrado mais um exemplo, no qual se assumirá
que a lista é um objeto do tipo LinkedList<Integer>
contendo elementos 1, 2, e 3. Esse exemplo cria uma meta
do tipo permutation([1,2,3],X), que questiona por
qualquer lista X qual seja uma permutation de [1,2,3]:
2. Motor tuProlog
O motor tuProlog é leve e completamente escrito em
Java, o seu núcleo é uma minúscula classe Java que
contem somente as configurações essenciais de um motor
Prolog, sendo que outros predicados como I/O e ISO
podem ser dinamicamente adicionados ou removidos da
instancia de um motor conforme as necessidades da
aplicação. Além disso, usando o tuProlog os componentes
de uma aplicação podem ser desenvolvidos pelo
paradigma que for mais adequado, podendo ser ele o
declarativo/lógico ou imperativo/orientado a objetos.
O motor tuProlog possui funcionalidades tanto no
sentido Java para Prolog quanto no sentido inverso. No
primeiro caso o motor tuProlog fornece uma biblioteca
chamada JavaLibrary, com a qual quaisquer entidades de
Java, sendo elas objetos, classes e pacotes, podem ser
representadas como termos de Prolog e, assim serem
aproveitadas nele. Já no outro sentido o motor tuProlog
pode ser chamado e usado como um simples Objeto de
Java.
Uma vez que, o motor tuProlog é inteiramente escrito
em Java é possível consultá-lo para a solução qualquer
problema, desde que se trate de uma teoria lógica,
diretamente de dentro de um programa escrito em Java, o
motor tuProlog é na realidade visto pelo Java como
qualquer outro Objeto seu. Logo abaixo, na Figura 1, é
dado um exemple simples da utilização do Prolog para
solução de um problema trivial de permutação em listas.
Figura 2: Exemplo de permutação em listas
usando o paradigma orientado a objetos e o
paradigma lógico.
Para execução desse código, o motor tuProlog tem
então que estar criado e inicializado com o Objeto Theory
contendo o código acima, o qual pode ser pego de uma
array de Strings ou através de um java.io.InputStream. O
exemplo da Figura três, qual se encontra logo abaixo,
mostra como isso é feito.
2
lógica, as qual são expressas com letras maiúsculas, o
termo f é um fazedor de funções e, todos os ti são termos
maiores que zero. Os termos t podem ser listados na
forma como estão no exemplo ou dessa forma: [th|tt], na
qual th é o cabeçalho e tt é o corpo.
O primeiro problema que foi encontrado na
implementação do P@J ...
Figura 3: Exemplo de inicialização do motor
tuProlog
Após a execução do código presente na Figura 3, o
motor estará pronto para encontrar uma ou mais soluções
para a meta exposta na Figura dois. Todas as soluções
encontradas pelo motor são objetos do tipo SolveInfo, os
quais devem ser acessados em ordem navegando-se todo
o espaço de soluções. Na Figura quatro, a qual se encontra
logo abaixo, é dado um exemplo de código usado para
acessar em ordem todas a soluções encontradas pelo
motor tuProlog.
4. P@J Annotation API Layer
5. Conclusão
4. Referencias
[1] Maurizio Cimadamore, Mirko Viroli DEIS, Cesena Alma
Mater Studiorum – Universit à di Bologna “A Prolog-oriented
extension of Java programming based on generics and
annotations”.
[2] M. Espák. Japlo: Rule-based Programming on Java. Journal
of Universal Computer Science, 12(9):1177–1189, 2006.
[3] Andrea Omicini and Antonio Natali. Object-oriented
computations in logic programming. In Proceedings of
ECOOP’94, volume 821 of LNCS, pages 194–212.
Figura 4: Exemplo de código utilizado para
acessar
todas
as
soluções
de
metas
encontradas pelo motor tuPolog.
O primeiro problema que foi encontrado na
implementação do P@J foi o de mapear esses conceitos
em um caminho muito preciso dentro de uma estrutura
orientada a objetos.
3. P@J Generics API Layer
Ao longo dessa seção será descrito a configuração das
classes adicionadas para tornar a representação de dados
entre Prolog e Java mais transparente. Antes de tudo, é
preciso saber que todo dado em Prolog é considerado
como um termo, mesmo as clausulas e metas podem ser
representadas como tal. Abaixo, na Figura cinco temos
um exemplo de sintaxe, a qual será explicada a seguir.
Figura 5: Exemplo de Sintaxe.
Nesse exemplo o termo a é um valor primitivo
qualquer, integer, boolean etc, o termo V é uma variável
3