Telis

Programando na Internet

Introdução

A rede Internet, tal como evoluiu nos últimos anos, permitiu inúmeros exemplos de trabalho cooperativo à distância. Tecnologias recentes (como Java), abriram novas perspectivas nessa direção, uma vez que possibilitam um ainda maior dinamismo e interação utilizando a rede.

Infelizmente, o domínio produtivo dessas novas tecnologias exige um longo tempo de aprendizagem, pela complexidade dos pré-requisitos conceituais envolvidos, sejam aqueles intrínsecos, sejam aqueles relativos ao ambiente de execução/comunicação (OO, TCP/IP, etc..)

A proposta Telis tenta seguir o caminho da simplicidade, sem abrir mão da efetividade. O sistema se apoia numa tradição de linguagens poderosas (e ainda simples), de Forth e AABC a LOGO. Mas, assim como Ágora, Telis foi projetada desde o início para habitar máquinas em rede (Internet), o que lhe confere uma particularidade especial.

O software Telis consiste em um Ambiente de Desenvolvimento, que permite a edição, depuração e manutenção de programas escritos na linguagem Telis, e de um Interpretador, que permite a execução desses programas em qualquer máquina que disponha de um navegador Internet com a possibilidade de rodar "applets". A seguir apresentaremos alguns aspectos da linguagem em detalhe. A idéia é mostrar que Telis busca poder de comunicação pela rede sem perder a simplicidade do código.

A linguagem básica

A linguagem Telis lembra inicialmente as linguagens usadas em calculadoras eletrônicas de bolso. Os processos em Telis (denominados "atores") utilizam uma "memória de curta duração" com estrutura de pilha, que armazena os objetos a serem operados. As agendas Telis funcionam como procedimentos ou funções, e podem manipular os valores da memória de pilha, obtendo-se assim resultados diversos.

Por exemplo, a seqüência:

    5 8 +

fará com que o valor 5 seja armazenado na pilha, seguido do valor 8. Com a entrada do caracter +, ambos os valores serão retirados da pilha e sofrerão adição, cujo resultado passará a ser o novo valor do topo da pilha.

Em Telis, esta idéia foi generalizada para outros tipo de dados. Por exemplo, a seqüência:

    "estamos" " concatenando texto" concatenar

fará com que sejam armazenados na pilha as duas cadeias de caracteres, e a seguir sejam substituídas na pilha pelo resultado de sua concatenação: a cadeia "estamos concatenando texto".

Da mesma forma, Listas de valores primitivos podem ser utilizadas, entre colchetes, e serem operadas utilizando a pilha. Por exemplo, a seqüência:

    [ 23 45 98 ] 144 inserirNoFim

fará com que sejam armazenados na pilha tanto a lista de elementos [ 23 45 98] como o valor 144, que a seguir serão retirados e substituídos por uma nova lista, que agrega este valor ao seu final, resultando em: [ 23 45 98 144 ].

Uma das estratégias para viabilizar um rápido aprendizado da linguagem foi a incorporação de "Turtlegraphics" [Papert, S. (1985)], ou seja, comandos que resultam em traçados na tela do monitor, obtidos pelos deslocamentos relativos de um cursor gráfico programável ("ande 100 passos para a frente, a partir de onde esteja", ou: "gire 90 graus em torno de seu próprio eixo").

Em Telis, essas funcionalidades são obtidas com o comando frente, e o comando direita, que retiram seus parâmetros da pilha. Assim, em:

    100 frente 90 direita

o cursor sairia da posição em que estava, deslocando-se 100 unidades à frente, e em seguida girando 90 graus para a direita.

Além de agendas primitivas como frente, direita, concatenar, etc., em Telis o programador pode criar suas próprias agendas, utilizando primitivas e/ou outras agendas.

Um modelo de ator, em Telis, expressa o comportamento de uma classe de atores. Pode-se incluir num modelo, além de uma agendaInicial, agendas locais, que sejam válidas somente para o modelo que estiver sendo definido. Por exemplo, o código

    "andarEGirar"
        [ 100 frente 90 direita ] 
    incluirAgenda

está definindo uma nova agenda: andarEGirar. Esta agenda passa a fazer parte do dicionário desse modelo de atores, de forma que, caso fosse digitado:

    andarEGirar

o efeito seria o mesmo que o obtido por executar a lista de comandos: 100 frente 90 direita .

Qualquer agenda, uma vez criada, pode vir a participar da definição de outras agendas, como em:

    "quadrado"
        [andarEGirar andarEGirar andarEGirar andarEGirar ]
    incluirAgenda

que define a nova agenda quadrado (que desenharia na tela um quadrado de 100 unidades de lado).

Na verdade, agendas como essa costumam ser "fatoradas", eliminando-se a duplicação com o uso de um comando de repetição, como em:

    "quadrado"
        [ [andarEGirar] 4 vezesRepetir  ]
    incluirAgenda

Programação por Eventos

O modelo de eventos de Telis é inspirado em Ágora [Melgarejo & Marchini (1992)]. Aqui as listas podem caracterizar eventos de interface, eventos externos e até mesmo eventos produzidos por um ator com a finalidade de se comunicar com outros.

Evento produzido por uma interface física.

Os dispositivos de interface (como teclado e "mouse") produzem eventos quando necessitam reportar alguma atividade. Por exemplo: cada vez que uma tecla do teclado for pressionada, será gerado um evento descritivo, ao qual qualquer ator poderá ter acesso.

No caso de um dispositivo apontador como o "mouse", poderia ser emitido um evento como:

    [ MOUSE "pressionado" 0 [80 10] ]

informando que o botão direito do dispositivo apontador foi pressionado, quando o mouse se encontrava no ponto de coordenadas (80,10).

Eventos criados pelo programador

Um ator qualquer em Telis pode tambem emitir eventos de sua autoria. Isso generaliza o conceito de eventos, permitido o uso de um estilo de programação "por eventos".

Por exemplo, o evento:

    [ "dados pessoais" "joão" 34 1,70 ]

poderia ser emitido por um ator para comunicar, digamos, que uma pessoa de nome "joão" tem 34 anos de idade e 1,70 m de altura.

Para fazer com que um evento desse tipo seja divulgado aos interessados, devemos utilizar o comando dizer. Além disso o "alcance" pretendido para a divulgação é dado através de um atributo do ator, que pode ser alterado através do comando fixarAlcance. Assim, o (trecho de) programa:

    "rede" fixarAlcance 
        [ "dados pessoais" "João" 34 1,70 ]
    dizer

permite a divulgação pela rede dos dados pessoais de "João". Note-se que qualquer programa Telis, rodando naquele momento em qualquer máquina conectada à rede, poderia tomar conhecimento deste evento.

Temos assim a base de um mecanismo bastante simples de comunicação pela Internet.

Mas precisamos ainda de um mecanismo receptor, que possa não somente filtrar os eventos de interesse, como reagir a eles tomando as medidas adequadas.

Comunicação entre Programas

Para reagir com presteza aos eventos de seu interesse, um programa Telis deve utilizar um mecanismo que possa perceber tanto os eventos de interface como os eventos enviados por outros programas, e tratar adequadamente a informação recebida. Em Telis, esse mecanismo é implementado pelo comando seDito. Quando ocorre um evento aguardado pelo seDito, é paralisada a execução do trecho de programa corrente, para ser executada a seqüência de comandos de tratamento do evento. Uma vez tratado o evento, deve ser retomada a seqüência normal de instruções do programa.

O comando seDito tem a seguinte sintaxe:

    <evento genérico>
        <lista de comandos que tratam o evento> 
    seDito

O comando seDito permite tanto a filtragem da informação que chega, como a especificação das medidas reativas a serem tomadas. Para isso ocorrer, o seDito deve ser instalado com o mesmo alcance que o dizer que ele pretende tratar.

Para verificar se a informação que chega é adequada, são utilizados eventos genéricos, que agem como "filtros" de informação. Um filtro deve servir como modelo da classe de eventos esperada pelo programa. Por exemplo, um trecho como:

    "rede" fixarAlcance
        ["TERMINADO"]
        [ suicidar ] 
    seDito

indica que desejamos receber eventos simples pela rede, contendo tão somente a palavra "TERMINADO". O programa diz ainda que, em resposta à chegada de um evento como esse, o ator deve "suicidar".

Mas eventos assim tão específicos (embora úteis para sincronizar atividades), não são os mais comuns. Normalmente, um programa precisa especificar qual a classe de eventos que pode receber, podendo mesmo não serem conhecidas previamente todas as ocorrências possiveis. Para podermos especificar ocorrências futuras de um evento através de seu formato, utilizamos os comparadores genéricos de Telis, como: número, texto, lista, símbolo, qualquer.

Os comparadores genéricos são utilizados para compor os filtros (eventos genéricos), como em:

    ["Dados Pessoais" texto número número] 

Os filtros não representam nenhum evento particular, mas sim o conjunto de todas os eventos possíveis, os que "casem" com esse modelo. Podemos dizer que o filtro acima "casa" com o evento específico abaixo:

    ["Dados pessoais" "joão" 34 1,70 ]

Isso porque tanto o evento genérico como o evento específico têm um ítem exatamente igual (o texto "Dados Pessoais"), e o próximo ítem da lista é um texto, seguido de um número, e de outro número, como exigido pelos comparadores existentes no filtro.

Fluxo de Controle do Programa

Vimos que para haver comunicação devemos supor a ocorrência de um evento específico num programa que está preparado para filtrar e tratar essa informação. Sempre que a informação que está chegando "casar" com a especificação contida no filtro, a execução do programa corrente é suspensa, e o fluxo de controle passa a ser dirigido pela lista de comandos fornecida para o tratamento do evento.

Por exemplo, o programa:

   {laço infinito}               <-- as chaves identificam comentários
       [ 1 frente ]
   praSempre

executaria indefinidamente a seqüência

    [ 1 frente ]

Mas, se acrescentarmos aí um "tratador de eventos", usando o comando seDito, tudo mudaria. Veja o programa modificado:

    [ "esquina!" ]
        [ 90 direita ]
     seDito

    {laço infinito}
        [ 1 frente ]
    praSempre

Agora, a cada vez que ocorrer algum evento que "case" com o filtro [ "esquina!" ], o traçado repetitivo [ 1 frente ] será suspenso, passando a ser executada a seqüência [ 90 direita ]. Uma vez terminada a execução dessa seqüência, é retomada a execução de [ 1 frente ], indefinidamente. Até acontecer a chegada de um outro evento [ "esquina!" ].

Publicação de Programas

Um procedimento comum em ambientes de programação é o "salvamento" do código em disco local. Num ambiente Telis, ao invés disso, desde o início do ciclo de vida de um programa ele começa sua vida pública. Isto porque os programas Telis são armazenados (publicados) num espaço compartilhado, acessível pela Internet, através de um servidor Telis.

Assim, qualquer pessoa que tenha acesso à Internet pode conhecer o programa, cujo código (XML) pode ser visualizado através do navegador WEB. Além disso, ao acessar a página (HTML) aonde se encontra embutido o programa , a pessoa visualiza o seu funcionamento, pois os programas Telis são executados automaticamente em qualquer navegador que possa executar "applets".

Em suma...

A Internet parece ser um ambiente propício para rodar Telis; Telis parece ser um ambiente propício para programar na Internet; E a experiência que acumulamos nesses últimos anos tem mostrado centenas de belas aplicações distribuidas, compostas por páginas WEB com Telis "embarcado". Todas desenvolvidas por iniciantes, a imensa maioria sem nenhum conhecimento prévio em programação...


Instale o Ambiente Telis e experimente você mesmo. Leia o Manual. Acompanhe as discussões. Pergunte pra gente o que faltar...

Envie suas sugestões.

E, mais uma vez,

Bem-vindo ao mundo Telis smile

algumas referências

O uso do conceito de pilha

E D U G R A F - Laboratório de Software Educacional - UFSC - CTC - INE
Campus Universitário - Trindade - Florianópolis - SC - Brasil 88040-090
Fone: +55 48 331 9735 / Fax: +55 48 331-9770
Última alteração deste tópico em 2007-05-23T18:13Z por FernandoBertoldi