O estudo e a pesquisa em uma determinada área são sempre acompanhados da produção de ferramentas, sejam elas teóricas ou mais concretas. Minha iniciação científica com o professor José Coelho consistiu na implementação de uma ferramenta para auxiliar o desenvolvimento de programas e facilitar a produção de animações de algoritmos na área de Algoritmos em Grafos.

O gRabbit^[1] (Graph Base For Building Implementation Tests) é uma ferramenta para a visualização de animações de algoritmos em grafos e edição de desenhos de grafos. O gRabbit permite ao usuário desenhar, modificar e salvar o desenho de um grafo, bem como carregar um previamente salvo. Além disso, ele permite a visualização de animações descritas através de um script próprio.

Além da implementação, alguns papers sobre sistemas de animação de algoritmos foram lidos como embasamento teórico para os tópicos abordados neste trabalho.

Tecnologias aplicadas

Escolhi a linguagem C++^[2] para escrever o gRabbit em conjunto com a biblioteca wxWidgets^[3], por ela ser muito portável e não precisar de quase nenhuma alteração no código fonte para compilar em uma plataforma diferente da qual o programa foi desenvolvido. Além disso, é utilizada a STL (Standard Template Library) do C++ para a manipulação das estruturas de dados do programa. Todo o projeto foi desenvolvido na plataforma Linux dada a quantidade e qualidade das ferramentas para programação existentes.

O gRabbit foi desenvolvido utilizando técnicas de programação orientada a objetos de tal forma que pudesse ser o mais modular possível. Há uma necessidade de que ele seja construido dessa forma para poder permitir e facilitar a inclusão de novas primitivas de animação e novos objetos a serem animados aumentando assim a quantidade de algoritmos para as quais o programa pode produzir animações.

Sistemas de animação de algoritmos

Na literatura^[4] encontramos diversas definições e classificações sobre sistemas de animação de algoritmos e podemos considerar o gRabbit como sendo um tal sistema. De uma maneira geral, um sistema desse tipo deve ser capaz de exibir uma animação de um algoritmo de uma forma mais abstrata, escondendo os detalhes de implementação e criando assim uma imagem (ou conjunto delas) do que está acontecendo no programa.

Existe claramente uma distinção quando falamos de um sistema de animação de algoritmos criado exclusivamente para fins didáticos ou um criado como ferramenta de engenharia de software para o auxílio ao desenvolvimento e/ou depuração de programas. Os conceitos envolvendo os dois tipos de sistema são diferentes e aqui vamos tratar os conceitos sobre sistemas que servem como ferramentas de engenharia de software pois foram estes os conceitos seguidos no projeto e que tornam o sistema mais amplo e apropriado para o uso de uma maneira geral.

Uma abordagem natural para a animação de algoritmos seria identificar partes importantes do algoritmo e associar a elas passos da animação. Por exemplo, em um algoritmo de busca em grafos, pode-se associar a cada visita a um vértice, uma tela onde o vértice em questão seja pintado de outra cor. Um sistema que implementa este tipo de abordagem é dito Event-Driven (orientado a eventos) e cada um desses passos importantes do algoritmo são chamados de Eventos de Interesse. Podemos criar as cenas de animação através de chamadas apropriadas no nosso sistema de animação que são inseridas no código do usuário e que geram os passos de animação durante a execução do algoritmo. Alternativamente, podemos simplesmente criar um log desses eventos para exibir posteriormente a animação.

A outra abordagem bastante utilizada é dita Data-Driven e consiste basicamente em capturar as alterações dos dados no programa, ou seja, acompanhar a evolução dos valores das variáveis e atribuir alguma interpretação a essas mudanças de modo que possivelmente estejamos mostrando as ações realmente pretendidas pelo algoritmo. Um exemplo de programas que normalmente implementam este tipo de abordagem são os debuggers convencionais que mostram a evolução das variáveis ao longo do tempo e sua interpretação é a mais básica possível mostrando apenas o valor delas. Um debugger visual, que mostre um gráfico da evolução das variáveis no tempo seria um sistema de animação com uma abordagem Data-Driven. É natural que um sistema que permita atribuir uma interpretação gráfica mais bem definida a uma seqüência de mudanças nos valores de uma variável deva ser considerado um sistema melhor em termos da qualidade da animação produzida.

No caso particular do gRabbit, usamos uma abordagem Event-Driven com tratamento post-mortem dos eventos, ou seja, o programa do usuário gera um script de animação que contém uma descrição das mudanças que devem ocorrer no sistema gráfico. O gRabbit lê este script e executa as instruções contidas nele gerando a animação.

Interface do gRabbit com o usuário

Ao lado temos uma tela típica do gRabbit. Do lado esquerdo temos duas barras de botões. A primeira delas possui botões de edição do grafo. Atualmente temos apenas três botões que são respectivamente as ferramentas de arraste, desenho de vértices e desenho de arcos. A segunda barra possui os controles da animação que são respectivamente: play, stop, pause, loop (executa a animação continuamente), back (reinicia), forward (vai para a última cena da animação), step back e step forward (animação cena a cena).

Através dos menus, na parte superior da janela, podemos abrir um arquivo de grafo, salvar o grafo que está em edição no momento e abrir um script de animação para ser executado.

Selecionando a ferramenta de desenho de vértices, podemos desenhar quantos vértices desejarmos na área de desenho (a parte branca na figura). Quando selecionamos a ferramenta de desenho de arcos, devemos clicar necessariamente em um vértice previamente desenhado que será o vértice de origem e depois em um outro vértice distinto que será o vértice de destino. A partir de algum desenho pronto, basta escolher a ferramenta de arraste que podemos então selecionar e mover os vértices para novas posições.

Até o presente momento, a interface com o usuário é esta, uma interface bem simples, sem muitos detalhes. Melhorias significativas estão previstas para o futuro.

Formato dos grafos

O gRabbit utiliza um formato para salvar um grafo em um arquivo que é semelhante ao utilizado pelo SGB^[5]. O arquivo é em formato texto (UNIX) e as informações sobre o grafo estão separadas em linhas. A primeira linha consiste em um cabeçalho com informações sobre o grafo. As linhas seguintes são as linhas representando os vértices, um vértice por linha, e logo em seguida são representados os arcos, também um por linha. A extensão do arquivo é .grb, mas ela não é obrigatória.

Logo abaixo temos um exemplo de um arquivo de grafo e ao lado uma tela do gRabbit exibindo o grafo codificado por este arquivo.

GRABBIT-Graph(2,4,1)
V1,109,189,"A",(255,0,0)
V2,232,101,"B",(255,0,0)
V3,342,231,"C",(255,0,0)
V4,255,349,"D",(255,0,0)
A1,"Teste",(0,0,0),V1,V3
A2,"Arco",(0,0,0),V3,V4

A primeira linha do arquivo é um cabeçalho e a palavra GRABBIT indica apenas ao gRabbit que o arquivo pode ser aberto por ele. O símbolo hífen é um separador obrigatório e a palavra Graph indica o tipo do objeto que será carregado. Atualmente o gRabbit só suporta grafos. Logo em seguida, vem uma lista de valores entre parênteses que são os parâmetros do objeto. No caso, os valores são respectivamente o número de arcos, número de vértices e o tipo do grafo, onde o valor 1 indica que é um grafo dirigido e 0 um grafo não-dirigido.

As linhas subseqüentes são as informações dos vértices e existem em número igual ao fornecido como parâmetro do objeto. Cada linha dessas contém, separado por vírgulas e em ordem, os seguintes campos:

• um identificador;
• as coordenadas X e Y;
• uma string entre aspas duplas que representa o rótulo (o gRabbit só mostra os dois primeiros caracteres dessa string na interface);
• uma seqüência de três números, entre parênteses e separados por vírgulas, que são os valores RGB variando de 0 a 255 e que indicam a cor de preenchimento.

Logo após as linhas sobre os vértices, temos as linhas descrevendo os arcos do grafo. Cada linha destas é composta respectivamente pelos següintes campos:

• um identificador;
• uma string entre aspas duplas que é o rótulo;
• uma seqüência de três números, entre parênteses e separados por vírgulas, que são os valores RGB variando de 0 a 255 e que indicam a cor do arco;
• dois identificadores de vértices anteriormente listados que representam em ordem os vértices de origem e destino do arco (obviamente a ordem não importa se o grafo for não-dirigido).

O formato do arquivo deve ser seguido rigorosamente para que o gRabbit possa carregar corretamente o objeto a ser exibido. Caso exista algum problema, o gRabbit indica que houve uma falha, especifica o seu tipo e a linha onde ela ocorreu, parando imediatamente de ler o arquivo. Como o gRabbit vai criando o grafo conforme ele realiza a leitura do arquivo, quando um erro é encontrado, já temos criado o grafo até aquele ponto e essas informações são exibidas na tela.

Scripts de animação

LoadGraph("teste.grb");
PaintVertex(V8,(110,120,0));
PaintArc(A1,3,(255,0,0));
ChangeVertexText(V1, 1, "99", (255,0,0));
PaintVertex(V8,(255,0,0));
PaintVertex(V1,(255,0,255));
ChangeArcText(A6, 1, "9999", (255,0,0));
PaintArc(A1,2,(0,0,0));
PaintArc(A6,2,(0,0,0));
PaintVertex(V1,(255,0,0));

Temos ilustradas também outras instruções que fazem parte da animação. O arquivo de animação é constituído de várias delas, uma por linha, separadas por ponto e vírgula. Cada uma dessas instruções representa um passo da animação.

Os tipos de dados que as instruções podem receber como parâmetro são:

• string:  Uma cadeia de caracteres entre aspas duplas;
• name:    Um identificador que consiste de uma cadeia de caracteres composta exclusivamente de letras e números;
• size:    Um número inteiro;
• field:   Um número inteiro;
• time:    Número inteiro representando a quantidade de tempo em milissegundos;
• (r,g,b): Uma tripla de números inteiros separados por vírgulas. Cada um dos três números pode variar de 0 a 255 e representam, respectivamente, os valores vermelho, verde e azul das componentes de uma cor.

E as instruções de animação disponíveis no momento são:

• LoadGraph(string): Carrega o grafo do arquivo especificado por 'string';
• SaveGraph(string): Salva o grafo corrente no arquivo especificado por 'string';
• PaintVertex(name,(r,g,b)): Altera a cor do vértice de identificador 'name';
• PaintArc(name,size,(r,g,b)): Altera a cor do arco de identificador 'name' e a largura da linha do arco para 'size';
• ChangeVertexText(name,field,string,(r,g,b)): Altera o texto do vértice identificado por 'name' para o valor contido em 'string' correspondente ao campo 'field' (não implementado ainda). Altera também a cor do texto;
• ChangeArcText(name,field,string,(r,g,b)): Altera o texto do arco identificado por 'name' para o valor contido em 'string' correspondente ao campo 'field' (não implementado ainda). Altera também a cor do texto;
• Delay(time): Faz com que o sistema espere 'time' milissegundos antes da execução da próxima instrução.

Por enquanto existem poucas instruções e elas são bastante simples, mas mesmo assim já é possível realizar animações de diversos algoritmos de grafos.

Produzindo uma animação: um exemplo

Ao longo do desenvolvimento do gRabbit foram feitos vários testes e, em particular, um deles vale a pena ser mencionado. O prof. Coelho e eu decidimos testar um programa que buscava um circuito hamiltoniano^[6] em um grafo. O programa era simples e procurava o circuito usando backtraking e estava implementado havia um certo tempo. Ele era usado pelo prof. Coelho em suas aulas.

Ao lado vemos uma tela da animação deste programa. Foi a partir de um teste de animação destes, que visava testar o sistema de animação do gRabbit, que descobrimos um bug no próprio programa do circuito hamiltoniano. Através da animação, observamos que o grafo era percorrido de modo estranho e muitos caminhos não eram testados (não havia backtracking). Com isso tivemos uma pista do problema que havia nesse programa e o prof. Coelho arrumou o bug.

Com isso, podemos perceber a utilidade do gRabbit para a depuração de outros programas. A primeira visualização da animação já nos mostrou que havia algo errado com o programa e também nos deu a pista de onde estava o erro. Em outras situações, o gRabbit poderia ser utilizado para detectar também erros conceituais no algoritmo implementado.

Como produzir uma animação como a acima utilizando o gRabbit? Tudo o que temos que fazer é gerar um script de animação para que o gRabbit o execute, bem como gerar o grafo que será utilizado. O programa do circuito hamiltoniano^[6] está disponível como um exemplo.

O programador deve identificar no seu código quais são os eventos de interesse que ele deseja exibir ao usuário, ou seja, no que consistirá sua animação. No caso do programa do circuito hamiltoniano, nossos eventos de interesse são as visitas a arestas e vértices que o algoritmo realiza, portanto mostramos com arestas azuis o caminho atual do algoritmo e pintamos uma nova aresta testada de azul. Caso a aresta seja rejeitada, ela é novamente pintada de preto. Os vértices do caminho também são pintados de azul e pintamos de vermelho o vértice cujo conjunto de arestas estamos olhando. Os demais vértices são pintados de branco. Desse modo, conseguimos mostrar a animação do programa de modo que uma pessoa que entende o algoritmo em questão possa deduzir facilmente o que está acontecendo, e uma pessoa que não o conheça tenha uma visualização agradável do seu funcionamento e possa, assim, compreender melhor o algoritmo.

Uma maneira bem simples de construir o script de animação é alterar o código original do programa e adicionar código que gere apropriadamente as instruções de animação. Na linguagem C, basta adicionar chamadas a printf com os parâmetros apropriados para gerar todo o código de animação. Deve-se apenas tomar cuidado para que os identificadores dos arcos e vértices tenham os mesmos nomes dos identificadores no arquivo de grafo gerado.

Instalando o gRabbit

Instalar o gRabbit é simples. Como um primeiro passo deve-se instalar o compilador GCC^[7] na versão 3.x ou superior e deve-se garantir que todo o suporte à STL está disponível. Logo após, deve-se instalar a biblioteca wxWidgets^[3] na versão 2.4.2 utilizando-se a mesma versão do compilador g++ (que faz parte do pacote do GCC) que será utilizado para compilar o gRabbit. A wxWidgets deve ser compilada com suporte ao GTK 1.x, pois o suporte ao GTK 2.x ainda é experimental e causará problemas ao gRabbit.

Feito esta preparação inicial, basta fazer o download dos fontes do gRabbit^[1], seguir quaisquer instruções especiais para a versão utilizada que constem com a documentação do pacote e executar o comando make no diretório onde os fontes foram descompactados.

Problemas ainda restantes

Ainda existe muito trabalho a ser feito: restam muitos bugs no gRabbit que não puderam ser arrumados devido ao cronograma. Algumas vezes, porém, optei por incluir determinadas funcionalidades ao invés de melhorar ou corrigir problemas nas já existentes. Por essa razão, permanecem alguns problemas que são até mesmo sérios:

• Ao carregar o gRabbit, vemos que os botões para a animação estão presentes e aparentemente ativos. Caso alguém clique em algum deles, a aplicação é terminada e é exibido um Segmentation Fault, ou seja, uma operação de acesso ilegal de memória. Isso ocorre pois não existe uma animação carregada no momento e nenhuma verificação é feita antes de o gRabbit tentar simplesmente executar a animação.
• Alguns problemas envolvem o arraste dos objetos. Quando o usuário tenta arrastar um vértice para fora da área de desenho, o vértice é "preso" no canto correspondente da tela. Se o usuário soltar o mouse fora da área de desenho, o cursor desaparece e o vértice permanece colorido, como se estivesse selecionado. Porém, o vértice não está mais selecionado e o usuário consegue clicar sobre outros objetos.
• Um outro problema existente se deve ao fato de que arcos anti-paralelos (arcos diferentes que possuem os mesmos vértices como pontas, mas sentidos diferentes) são desenhados um em cima do outro. Com isso, caso o arco de baixo seja pintado de uma cor distinta, visualiza-se apenas uma parte da flecha de cor diferente.
• Não existe explicitamente uma estrutura interna para o objeto "grafo", o que dificulta a manipulação do grafo como um todo. Isto também impossibilita a manipulação de mais de um grafo ao mesmo tempo. Ademais, fica mais complicado determinar o que fazer com um grafo que está sendo editado no momento em que o usuário tenta abrir um novo grafo.
• Não existem nem um sistema de undo, nem uma maneira de apagar vértices ou arestas e nem uma forma de iniciar um projeto novo. Portanto, o usuário deve reiniciar a aplicação caso deseje desfazer algum passo.

Otimizar o código também é uma outra necessidade e podemos ainda listar outros problemas, mas fica a cargo do leitor testar a aplicação e talvez até mesmo reparar os erros. Afinal, o gRabbit é um software livre.

Futuro do gRabbit

Não podemos prever exatamente o que vai acontecer no futuro, mas podemos planejar o que desejamos. Várias funcionalidades ainda serão acrescentadas ao gRabbit. A maior parte visa melhorar a interface com o usuário, de modo a tornar a ferramenta mais prática e fácil de usar. Alguns exemplos nesse sentido seriam:

• permitir que vértices e arestas sejam deletados pela interface;
• corrigir diversos bugs da interface;
• implementar o scroll de tela;
• permitir que grupos de vértices possam ser selecionados e arrastados de uma só vez;
• alterar a forma como são desenhados arcos anti-paralelos;
• permitir que os rótulos das arestas e dos vértices sejam alterados pela interface;
• implementar novas ferramentas para desenho;
• permitir a manipulação de mais de um grafo ao mesmo tempo;
• permitir que sejam manipulados grafos não-dirigidos;
• permitir que o usuário possa escolher as cores, tamanhos e fontes dos elementos em interfaces apropriadas.

Sem dúvida esta é apenas a ponta do iceberg e muita coisa ainda pode ser feita e melhorada. Mas tais melhorias só dizem respeito à interação com o usuário. Algumas outras alterações são possíveis e tornam a ferramenta mais completa e conseqüentemente mais útil. São elas:

• integração com o SGB^[5];
• acrescentar novas primitivas de animação;
• permitir o desenho de grafos a partir de arquivos do SGB;
• suportar novos objetos, como por exemplo um conjunto de polígonos;
• criar suporte para execução do programa a ser testado na própria interface do gRabbit;
• tentar tornar o processo de animação o mais transparente possível;
• permitir a inclusão de plugins;
• implementar ferramentas para criação e manipulação de imagens a partir do desenho do grafo.

Novamente, essas são apenas algumas possibilidades, sendo que algumas podem até ser inviáveis. No momento, entretanto, o gRabbit continuará crescendo baseado nessas idéias. Quaisquer sugestões são muito bem-vindas e poderão ser realmente incorporadas na aplicação. O gRabbit ainda é um protótipo de uma aplicação que deve crescer e se tornar um pacote para o desenvolvimento, depuração e apresentação de programas na área de algoritmos em grafos, ou qualquer outra que possa eventualmente ser suportada pelo gRabbit.

Desafios e Frustrações

Quando decidi fazer uma iniciação científica, eu tinha certeza que seria um grande desafio. No começo o maior problema foi decidir o projeto em si. Eu queria desenvolver um programa que tivesse um uso prático, que fosse um software livre e que pudesse facilitar alguma tarefa cotidiana. Acabei me decidindo por fazer algo ligado a área de grafos e geometria computacional. Desta vontade nasceu o gRabbit. A escolha da linguagem e das bibliotecas a serem utilizadas não representou nenhum problema pois já havia decidido utilizar a linguagem C++ e a biblioteca wxWidgets, já que minha intenção também era de aprender as duas mais a fundo.

Ao longo da iniciação, os maiores problemas foram especificar corretamente um projeto grande, pensar no seu desenvolvimento e saber como dividir corretamente as partes do código, visando modularização. Tais problemas também geraram uma grande frustração no final, pois o gRabbit, como é hoje, não é exatamente um espelho de como eu o imaginei no começo.

A escolha da biblioteca wxWidgets também foi um pouco infeliz, pois a documentação com certeza não é a mais completa existente. A biblioteca demonstrou ser lenta em diversas situações e nela encontrei alguns bugs que dificultaram muito o desenvolvimento. A falta de exemplos de interfaces gráficas, bem como a minha falta de conhecimento nessa área, também foram fatores que dificultaram muito todo o projeto.

No final, estou frustrado por não ter conseguido implementar completamente o que eu desejava, e pelo fato de que a aplicação não se parece com o que eu havia idealizado. Além disso, muito código deve ser reescrito, pois a estrutura interna do programa não foi escolhida adequadamente e, por isso, existe uma dificuldade muito grande de expandir o projeto.

Disciplinas mais relevantes

Grande parte destas disciplinas envolveram bastante programação em C, o que me ajudou muito no trabalho já que C e C++ são bastante semelhantes. As disciplinas MAC 323, 211, 242, 422, 328, 438, 331 e 300 ajudaram muito com uma grande carga de programação. Em particular, na disciplina de MAC 242 eu tive o primeiro contato real com uma aplicação gráfica dentro do BCC, o que me ajudou bastante no desenvolvimento deste projeto. Os conceitos aprendidos ali foram essenciais. As disciplinas MAT 112 e 122, MAC 414, 331, 441, 328 e 323 forneceram toda a base teórica e algorítmica para o desenvolvimento do projeto. Sem estas disciplinas eu não teria conseguido solucionar a maior parte dos problemas encontrados. Apenas lamento não ter me esforçado mais em Álgebra Linear e em Vetores e Geometria. Acho, inclusive, que a carga didática dessas disciplinas deveriam ser aumentadas no currículo.

Interação com o orientador e com outros amigos

A interação com o orientador foi fundamental para a especificação e para o desenvolvimento do projeto. Aprendi muitos conceitos sobre os passos de desenvolvimento do software, sobre como proceder para obter um resultado satisfatório dentro do prazo e muitas dicas de como escrever um texto e fazer uma apresentação de um trabalho.

O projeto não seria o mesmo sem a ajuda de alguns amigos. Em particular, gostaria de agradecer bastante a dois deles que contribuíram com dicas, idéias e exemplos de código que foram incorporados (e devidamente creditados a eles) no código do gRabbit. São eles: Wagner César Bruna, que me ajudou bastante com a linguagem C++, a biblioteca wxWidgets e diversos conceitos envolvendo interfaces gráficas, e Wendel Scardua, que colaborou bastante com a resolução de problemas de Álgebra Linear, como rotação de pontos. Além disso, ele colaborou com diversas idéias sobre a interface e sobre a estrutura interna da aplicação.

Gostaria de agradecer também a todos os outros amigos que colaboraram de alguma forma no desenvolvimento deste projeto e na formulação desta monografia. Particular atenção a Marcel Kenji de Carli Silva e Juliana Barby Simão. Não é pelo fato de eu não citar outros nomes aqui que vocês são menos importantes que o Wendel e o Wagner. Todos colaboraram muito para o resultado final deste trabalho.

Trabalhos no BCC

O projeto do gRabbit foi desenvolvido essencialmente por mim, com a ajuda de alguns amigos como citado anteriormente. Por conta disso, não tenho nada a comentar sobre o processo de trabalho em grupo nesse projeto, já que não houve. Porém, durante o BCC eu tive algumas oportunidades de trabalho em grupo que foram fundamentais até mesmo no desenvolvimento deste projeto. Eu tive contato com outras formas de pensamento no desenvolvimento de programas e essa interação com os demais colegas foi de grande valia para o meu crescimento profissional. Durante os estágios que realizei, enquanto estive estudando no BCC, também desenvolvi grandes projetos com várias pessoas e esta experiência foi fundamental para o desenvolvimento do gRabbit, já que muitas decisões sobre a sua estrutura vieram dela.

Vale ressaltar que o trabalho em grupo no BCC ainda é relativamente pouco incentivado e é pouco efetivo já que, na maioria dos casos, os grupos se formam com o intuito de diminuir o trabalho dos seus membros de forma que apenas um deles acaba desenvolvendo o trabalho inteiro, enquanto os outros fazem o mesmo com outras disciplinas do mesmo semestre. Durante os estágios que fiz, esse tipo de interação jamais poderia existir já que isto comprometeria o desenvolvimento do projeto.

Disciplinas e conceitos estudados na prática

Eu jamais tinha imaginado a quantidade de Álgebra Linear que existe por trás de uma aplicação gráfica, na qual o usuário deve desenhar e manipular figuras simples, como é o caso do gRabbit. Qualquer coisa além do trivial exige um esforço matemático significativo e que se justifica nos resultados obtidos. Sem a carga matemática que o curso oferece, eu certamente não teria capacidade de desenvolver uma aplicação como esta. Ainda há muito a fazer, mas o que já foi feito depende fortemente do conteúdo visto no curso.

Meu futuro

Arrumar um emprego será a grande prioridade após a conclusão do curso. Também devo começar um mestrado na área de Algoritmos em Grafos, durante o qual devo continuar este projeto e melhorá-lo significativamente, incluindo estudos sobre desenho de grafos e animação de algoritmos. O gRabbit não será abandonado em nenhuma hipótese. Ele é o fruto de bastante trabalho e de um sonho que é o de desenvolver alguma aplicação grande somente minha. Mesmo que o gRabbit continue como um projeto independente, espero fazer o melhor possível e construir um software que as pessoas possam utilizar em seu dia a dia.

Referências

[1] gRabbit: Graph Base for Building Implementation Tests (Cópia local: gRabbit 0.1)

[2] Dinkum Reference to C/C++

[3] wxWidgets

[4] Visualization in algorithm engineering: Tools and techniques.

[5] SGB: Stanford Graph Base

[6] Programa que encontra o circuito hamiltoniano (download)

[7] GCC: GNU Compiler Collection

Disclaimer: Nenhum software livre foi sacrificado para a produção deste trabalho!