Introdução à Programação com Telis

Prévia do material em texto

Introdução a programação utilizando Telis
Versão 0.7
Florianópolis − SC
Sumário
1 Instalação de Telis p. 3
2 Primeiro programa p. 4
2.1 Desenhos e Telis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 6
3 Criando Modelos e Agendas p. 9
3.1 Criando um modelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 9
3.2 Criando agendas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 12
3.3 Publicando o programa na internet . . . . . . . . . . . . . . . . . . . . p. 13
4 Criando Agendas Parametrizáveis p. 15
4.1 Desenhando um relógio . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 15
4.2 Ponteiro dos segundos . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 16
4.3 Ponteiro dos minutos . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 19
4.4 Ponteiro das horas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 20
4.5 Colocando o relógio para funcionar . . . . . . . . . . . . . . . . . . . . p. 21
5 Usando Moldes para Remover Duplicação de Código p. 24
5.1 Movendo a agenda para o molde . . . . . . . . . . . . . . . . . . . . . . p. 24
5.2 Subindo a agenda iniciar . . . . . . . . . . . . . . . . . . . . . . . . . . p. 26
6 Comunicação entre atores p. 32
6.1 Separando modelo de visão com estímulos . . . . . . . . . . . . . . . . p. 33
6.2 Separando modelo de visão com comunicação direta . . . . . . . . . . . p. 35
7 Conclusão p. 39
3
Lição 1--Instalação de Telis
Para utilizar Telis são necessários os seguintes pré-requisitos mínimos:
• Java 1.5 update 4 ou superior
• Internet Explorer 5.5 ou Mozilla Firefox 2 ou superior
• Plugin Java para o respectivo navegador
Para realizar a instalação da plataforma Java, baixe o programa de instalação do úl-
timo Java Runtime Environment (JRE) encontrado no sítio: http://java.sun.com/javase/downloads.
Escolha um local para salvar o arquivo em sua máquina. A operação de baixar o arquivo
pode demorar vários minutos, dependendo da velocidade de sua conexão com a Internet,
devido ao tamanho do arquivo.
Após terminar de baixar o arquivo, execute-o com um clique duplo. A licença será exi-
bida, prosseguindo com a instalação você estará automaticamente aceitando esta licença.
Nesta mesma janela selecione a opção Typical Install e clique em Accept.
Uma barra de progresso será exibida informando o progresso da instalação. Ao tér-
mino, uma tela será exibida informando que a instação foi concluída com êxito.
O próximo passo é baixar e instalar o Ambiente Telis. O Ambiente Telis está disponível
paraWindows e Linux e pode ser baixado em: http://telis.edugraf.ufsc.br/desenvolvimento/versoes.
Escolha o sistema operacional desejado e faça o download da última versão disponível.
Em seguida descompacte o arquivo na pasta onde você deseja que o Telis seja instalado.
Para executá-lo clique duas vezes no arquivo �Telis.bat� no caso do Windows, ou �Telis.sh�
no caso do Linux.
http://java.sun.com/javase/downloads
http://telis.edugraf.ufsc.br/desenvolvimento/versoes
4
Lição 2--Primeiro programa
A linguagem Telis lembra as linguagens usadas em calculadoras eletrônicas de bolso.
Há uma "memória"com estrutura de pilha, que armazena os objetos a serem operados.
Em uma memória de pilha, o último valor armazenado será o próximo valor a ser acessado.
Este comportamento é análogo a uma pilha de pratos, ao colocar um novo prato na pilha,
os outros pratos se tornam inacessíveis, o único prato que se pode tirar da pilha é aquele
que acabou de ser empilhado. Após este prato ser removido da pilha o que fora colocado
antes deste é o único que poderá ser removido e assim por diante.
Agora será tomado como exemplo o código Telis mostrado em 2.1. Quando executado
o número 2 é colocado na memória. Em seguida o número 4 é colocado sobre o número
2, pois esta memória é uma pilha. Então é executado o operador +. Este operador pega
o topo e o subtopo da pilha, 4 e 2 respectivamente, realiza a operação de soma e empilha
o resultado na memória. Neste momento a memória que era composta dos números 4 e 2
possui apenas o valor 6.
2 4 +
Algoritmo 2.1: Operação de soma em Telis. Primeiro exemplo.
A �gura 1 ilustra esta seqüência de operações. Nos passos 1 e 2 os valores são em-
pilhados, e a pilha se encontrará no estado mostrado no passo 3. Então é executado o
operador + no passo 4 e a pilha chega ao estado mostrado
Figura 1: Ilustração passo a passo da memória durante a execução do programa 2 4 +.
Vamos agora ver este pequeno programa em ação. Abra o Ambiente de desenvolvi-
5
mento Telis, executando o arquivo telis.bat no Windows ou telis.sh no Linux. Ao
abrir o Ambiente de desenvolvimento Telis, você verá uma uma janela no canto superior
da tela. Maximize esta esta janela, de forma a visualizar a tela como a da �gura 2. No
canto inferior há um campo de texto com um botão ao seu lado direito com o texto �Exe-
cutar� e uma legenda ao lado esquerdo com o texto �Comando�, como indicado na �gura
2. Neste campo é possível escrever e executar trechos de comandos Telis.
Figura 2: Foto do Ambiente Telis em execução, com o campo de comandos indicado.
Dica
Sempre utilize a barra de comandos para realizar pequenos testes
e experimentar novos comandos. Aliado ao visualizador da pilha, é
uma excelente ferramenta para entender o que está ocorrendo.
Na barra de comandos, entre com o texto �2 4 +�. Clique em executar. Uma aranha
aparecerá no centro da tela para realizar o seu calculo e na pilha está o valor 6. Para
visualizar a pilha clique no terceiro botão da esquerda para a direita, isto é, o botão azul
da �gura 2. Com isto, uma janela será exibida e o conteúdo atual da pilha poderá ser
inpecionado, no caso, apenas o valor 6. O seu primeiro programa em Telis foi feito!
6
2.1 Desenhos e Telis
Agora que sabe-se como a memória de pilha de Telis funciona, o próximo passo será
desenhar um quadrado na tela.
Ao executar o exemplo acima, realizando a soma entre 2 e 4, no centro da tela apareceu
uma aranha, símbolo de Telis. Esta aranha é o ícone que representa um ator. Um ator
é uma entidade que realiza os cálculos e possui a memória. Ao executar os comandos
na barra de comandos do Ambiente, um ator é criado para processar. Telis fornece uma
série de comandos para movimentar o ator. Em Telis comandos são chamadas agendas
primitivas. Assim como no exemplo da soma, os parâmetros e valores retornados pelas
agendas primitivas são consumidos e empilhados na memória de pilha que o ator possui.
Para movimentar o ator existe a agenda primitiva frente. Esta agenda faz com que
o ator se desloque x unidades para frente, onde x é o valor que se encontra no topo da
pilha. Para virar, utiliza-se a agenda primitiva direita, que faz o ator girar x graus para
a direita, onde x é o valor que se encontra no topo da pilha.
Observe o exemplo 2.2, neste exemplo, o ator primeiro se movimenta para frente 50
unidades, em seguida vira para a direita 90◦ e se movimenta mais 50 unidades para frente.
A movimentação do ator é ilustrada na �gura 3. Reproduza esta seqüencia de comandos
no ambiente utilizando a caixa de comandos.
50 frente
90 direita
50 frente
Algoritmo 2.2: Movimentando o ator.
Dica
O último botão na barra de ferramentas, botão �parar� em ver-
melho, limpa a tela e encerra a execução de todos os atores que
estiverem ativos permitindo retornar ao estado inicial.
Podemos fazer o ator se movimentar em quadrado de forma a descrever a trajetória
de um quadrado. Para que possamos desenhar o quadrado é necessário riscar. O ator
pode riscar enquanto se movimenta, a agenda primitiva comRastros faz com que o ator
comece a desenhar segmentos de reta entre a posição em que se encontrava e a nova
posição alcançada através da agenda frente, por exemplo. De forma análoga, a agenda
7
Figura 3: Ilustração das agendas primitivas frente e direita.
primitiva semRastros faz com que o ator pare de desenhar estes segmentos e permite que
o ator se reposicione para iniciarnova pintura.
Com isso temos todos os elementos para desenhar o quadrado. No exemplo 2.3 é uma
pequena variante do exemplo anterior, mas agora os rastros estão ligados antes que o ator
comece a se movimentar fazendo com que um quadrado seja desenhado na tela, como na
�gura 4.
comRastros
50 frente
90 direita
50 frente
90 direita
50 frente
90 direita
50 frente
Algoritmo 2.3: Desenhando um quadrado.
Figura 4: Resultado do desenho do quadrado.
8
Agora que você conhece alguns comandos básicos e a forma como a pilha funciona
pratique. Utilize o ambiente e faça pequenos desenhos. Além das primitivas mostradas
aqui existem outras que pode ser utilizadas como as primitivas semRastros, andarPara,
gerarAleatório, pintarÁreas, �xarCorDosRastros e mostrar.
9
Lição 3--Criando Modelos e Agendas
3.1 Criando um modelo
Agora que já você já criou o seu primeiro programa, enviando comandos ao ator criado
pelo Telis vamos melhorar este programa. A primeira coisa que faremos é parar de utilizar
a caixa de texto de comandos do ambiente Telis para escrever o programa. Esta caixa foi
feita para realizar pequenos experimentos, mas as restrições impostas são muito grandes.
O tamanho do campo é pequeno, todos os comandos são executados por um único ator e
não é possível salvar o trabalho realizado entre sessões do ambiente.
Para contornar estes problemas, Telis oferece um editor mais completo que oferece
maior espaço e permite o que o trabalho realizado persista. Para utilizá-lo, devemos
entender o conceito de modelo. Um modelo em Telis é um roteiro pré-de�nido que será
seguido por um ator. Todo ator está atrelado a um determinado modelo, inclusive aquele
criado pelo Ambiente Telis para executar os comandos inseridos na caixa de texto de
comandos. É possível criar um ou mais atores a partir de um dado modelo, isto é chamado
instanciação.
Para se criar um modelo no ambiente Telis devemos abrir o editor, clicando no terceiro
ícone da barra de tarefas e será exibida a tela mostrada na �gura 5. Esta janela é
organizada em abas, dentre as quais a que nos interessa é a aba Modelo.
Dica
A primeira aba encontrada na janela do editor contém a documenta-
ção de todas as agendas primitivas disponíveis. Esta documentação
apresenta uma breve descrição do que a mesma faz, o que ela espera
encontrar e o que ela ira retornar para a pilha, e pequenos exemplos
de código.
Dentro desta aba é possível criar, modi�car e instanciar modelos utilizando um editor
10
Figura 5: Foto do editor do ambiente Telis. O botão destacado é utilizado para abrí-lo.
de texto mais elaborado. Para criar o modelo clique no botão �Criar Modelo� localizado
na parte inferior esquerda da janela. Será exibido uma caixa para informar o nome do
modelo, por exemplo �PintorDeQuadrados�. Após concluída a criação a lista de modelos
possuirá o novo modelo, ao selecionálo será possível editar o código fonte. O botão
�Ativar� localizado acima do editor instância um ator a partir deste modelo. Clique no
botão ativar, e abra o visualizador da pilha. Agora no visualizador você verá que existe
na lista de atores ativos um ator do modelo �PintorDeQuadrado� como é possível ver na
�gura 6.
Dica
Escolha nomes para os seus modelos de forma a representar o que
eles fazem e o seu papel no sistema. Isso ajuda em vários aspectos
como organização e manutenibilidade do seu código. Por conven-
ção, em nomes de modelos cada palavra do nome inicia com letra
maiúscula, prática chamada CamelCase.
O modelo criado agora não possui nenhum código logo os atores instânciados a partir
dele não realizam nenhuma ação. Para fazer com que o modelo �PintorDeQuadrado� crie
11
Figura 6: Janela de atores ativos após instanciação de um modelo.
atores que realmente pintem quadrados vamos colocar o código mostrado no exemplo 3.1
como o código do modelo. Ao instanciar o modelo iremos ver um quadrado na tela.
Modelo:
comRastros
50 frente
90 direita
50 frente
90 direita
50 frente
90 direita
50 frente
Algoritmo 3.1: Modelo PintorDeQuadrado.
Modelos são excelentes formas de organizar o programa, permitindo a de�nição de
atores com mesmo comportamento uma única vez, e incentivando a divisão de respo-
nabilidades responsabilidades entre estes. A divisão de responsabilidades dentro de um
programa é uma das principais tarefas durante o desenvolvimento do programa e afeta
diretamente a manutenibilidade do código. Código com muitos atores (e modelos) com
responsabilidades muito pequenas tornam o programa muito fragmentado e difícil de en-
tender. No caso oposto, poucos atores com muitas responsabilidades, o código dos atores
se tornam muito complexos já que possuem muitas responsabilidades. Uma das tarefas
do projetista é encontrar um meio termo onde não se tenha uma explosão de modelos e
atores, mas não tenhamos modelos muito complexos.
12
3.2 Criando agendas
Apesar de ajudar a organizar a estrutura geral do programa dividindo responsabilida-
des, o código do modelo pode ser difícil de ser entendido caso não seja possível fragmentar
o código do modelo. Além disso, é comum que uma mesma seqüência de ações devam ser
realizadas diversas vezes durante a vida de um ator, mas não se deve replicar o código.
A duplicação de código deve ser evitada sempre. Código duplicado piora muito a manu-
tenibilidade do código pois cada vez um problema for encontrado ou uma alteração for
necessária todas os códigos duplicados deverão ser modi�cados.
Para contornar estes problemas Telis disponiliza agendas. Agendas são obrigatoria-
mente atreladas a modelos, e todo modelo possui no mínimo uma agenda chamada iniciar.
Toda agenda possui um nome que será utilizado para invocá-la e um código associado que
será executado quando a agenda for invocada.
A agenda iniciar é automaticamente executada após um ator ser instanciado. Os
códigos executados até aqui, como no exemplo 3.1, está na realidade contido nesta agenda.
As outras agendas do modelo só são executadas quando invocadas. Para invocar uma
agenda basta escrever o nome da mesma no código, da mesma forma como se faz com
uma agenda primitiva. Após o término da execução da agenda o programa continua com
o seu �uxo normal.
Vamos modi�car o �PintorDeQuadrados� mostrado no exemplo 3.1 e utilizar agendas.
Ao invés de utilizar duas primitivas (frente e direita) para desenhar o lado do quadrado,
criaremos uma agenda que faça isto e a utilizaremos na agenda iniciar. Para criar uma
agenda proceda da mesma forma que para a inclusão de um modelo, mas utilizando o
botão �Criar agenda� que se encontra ao lado do botão utilizado para a criação de um
modelo. O código resultante é mostrado no exemplo 3.2
Modelo:
iniciar:
comRastros
desenharLado
desenharLado
desenharLado
desenharLado
desenharLado:
50 frente
90 direita
13
Algoritmo 3.2: Modelo PintorDeQuadrado.
Ao executar este código o ator primeiro executa a primitiva comRastros. Em seguida
a agenda desenharLado é executada e o ator passa a executar o código da mesma andando
50 unidades para frente e girando 90 graus. Após o terminar a execução da agenda, o ator
retorna a agenda iniciar e executa a agenda desenharLado mais três vezes completando o
desenho do quadrado. A �gura 7 mostra esquematicamente como o �uxo de execução do
ator se desenrola.
Figura 7: Ilustração do �uxo de execução durante a execução do exemplo 3.2.
3.3 Publicando o programa na internet
Agora temos um modelo capaz de criar atores que desenham quadrados na tela. Mas
não criamos ainda um programa. Em Telis programas são chamados �Apliques�. Um
aplique possui um nome, dimensões (altura e largura) e uma lista dizendo os atores que
deverão ser disparados e seus respectivos modelos.
Para se criar um aplique é utilizada a aba Apliques do editor. Lá preenche-se os dados
necessários e pode-se ativar o aplique. Ao ativar um aplique é aberta uma janela e os
atores especi�cados são instanciados e iniciam sua execução.
O que é mais interessante da criaçãode aplique é a possibilidade de publicá-los. Ao
publicar um aplique não é mais necessário o uso do ambiente de desenvolvimento para
executá-lo, ao invés dele, utiliza-se o navegador. A publicação pode ser local ou remota.
Caso seja local uma página web com o seu programa é criada na pasta que você especi�car,
caso seja local o seu programa será publicado na internet nos servidores do Edugraf e
14
disponíveis na url http://telis.edugraf.ufsc.br/apliques/.
Dica
Ao publicar um aplique você compartilha o código com outros, e
todo e qualquer código publicado pode ser utilizado, modi�cado e
estudado por você. Para incentivar o estudo e compartilhamento de
códigos Telis, o ambiente permite que códigos publicados sejam im-
portados da internet para o seu ambiente. Esta função é disponível
através do primeiro botão da barra de tarefas do ambiente.
15
Lição 4--Criando Agendas
Parametrizáveis
Depois dos exemplos e programas relacionados aos quadrados e a introdução de con-
ceitos básicos do funcionamento do Telis e de modelos, atores e agendas feitas nas lições
anteriores vamos aplicar estes conhecimentos e desenvolver um relógio analógico.
O relógio analógico deverá possuir os ponteiros de segundos, minutos e horas, atualizando-
se a medida que o tempo passa. Para melhor distribuir as funcionalidades do programa
iremos separar o problema em quatro partes distintas: o desenho da parte �xa do relógio,
dos ponteiros dos segundos, dos minutos e das horas. Cada uma destas partes será repre-
sentada por um ator diferente que quando atuarem em conjunto façam o relógio analógico
funcionar.
4.1 Desenhando um relógio
Começaremos criando o modelo para o ator que será responsável pelo desenho das
partes estáticas do relógio, que é a mais simples. A parte estática do nosso relógio será
bastante simples sendo composta apenas por um círculo que delimitará o relógio na tela.
Assim, o código básico do relógio consistirá no posicionamento do autor e o desenho de
um círculo com o tamanho adequado. O código responsável é mostrado no exemplo 4.1.
AroDoRelogio:
iniciar:
[−105 −105] andarPara
[210 210] desenharElipse
suicidar
Algoritmo 4.1: Modelo da aro do relógio.
No exemplo 4.1 existem algumas estruturas e agendas primitivas ainda não vistas. As
agendas primitivas andarPara e desenharElipse são bastante intuitivas e não entraremos
16
em maiores detalhes, para maiores informações consulte a referência de primitivas. Os
detalhes importantes são os colchetes e a primitiva suicidar.
A primitiva suicidar é utilizada para terminar com a vida de um ator. Em Telis um
ator é uma entidade autônoma e permanece ativa após terminar a execução da agenda
iniciar. Ao invocar a agenda primitiva suicidar o ator é destruído, se o seu ícone estiver
visível ele é apagado da tela e o ator sai da lista de atores ativos do ambiente liberando
quaisquer recursos que ele possua como a sua pilha por exemplo.
Os colchetes são utilizados para denotar listas. Listas podem conter qualquer tipo de
dados incluindo números, textos, outras listas e código. No caso [-105 -105], é empilhada
uma lista contendo 2 elementos sendo o primeiro elemento -105 e o segundo -105 também.
Listas podem ser manipuladas através de primitivas e são a forma básica de estruturar
dados em Telis. Na ajuda do ambiente existe uma seção sobre as agendas primitivas que
podem ser usadas para manipular estas listas.
4.2 Ponteiro dos segundos
Agora que temos como instanciar um ator responsável pelo desenho das partes �xas
do relógio iremos criar um modelo para o ator responsável pelo desenho dos ponteiros dos
segundos. Este ponteiro deverá ser apagado e redesenhado no ângulo correto de segundo
em segundo, isto é deve realizar os seguintes passos:
1. Obter a hora do sistema e extrair as informações dos segundos
2. Calcular o ângulo com o qual o ator deverá se deslocar
3. Pintar o ponteiro
4. Dormir por 1 segundo
5. Apagar o ponteiro
6. Repetir o procedimento a partir do passo 1
A estrutura básica do problema é bastante simples. Telis possui a agenda primitiva
obterHora que retorna uma lista contendo as horas, minutos e segundos nesta ordem. Logo
para obtermos os segundos basta pegarmos o terceiro elementos da lista que a primitiva
obterHora colocar na pilha, o que pode ser realizado com a primitiva obterElemento.
17
O segundo passo é calcular o ângulo com a horizontal do ponteiro dos segundos. Isto
pode ser realizado com a expressão 90− (segundos− 360/60). A origem desta expressão
pode ser visualizada de forma mais clara na �gura 8.
Figura 8: Na �gura, a linha verde indica o ângulo 0o. A duas linhas vermelhas indicam o
ângulo feito pelos ponteiros com 0 e 1 segundo. O ângulo entre a linha verde e o ponteiro
a 1 segundo é igual ao complemento do ângulo entre as linhas vermelhas que é igual
1x360/60 = 6.
Para realizar o terceiro passo, isto é, a pintura do ponteiro vamos posicionar o ator
no centro da tela, ajustar o ângulo do ator e fazê-lo andar utilizando a primitiva frente.
O quarto passo pode ser realizado com a agenda primitiva descansar. Esta agenda faz
com que o ator pare a sua execução por n segundos, onde n é o parâmetro que se encontra
no topo da pilha e será consumido.
O quinto passo é idêntico ao terceiro, desde que pintemos com a cor de fundo ao invés
de pintarmos com a cor do ponteiro. Isso é verdade desde que a suavização de traços esteja
desligada. Ao desenhar algo na tela Telis utiliza uma técnica para melhorar a aparência
e evitar a sensação de serrilhados, o que acaba fazendo que esta tática não funciona. É
possível desligar esta suavização com a primitiva comSerrilhado.
Para o último passo precisamos de algo para realizar repetições e de forma in�nita.
Para isso utilizaremos a agenda primitiva paraSempre. Esta agenda recebe uma lista com
um código, e este código será executado para sempre. Existem várias outras estruturas
de repetição em Telis como as agendas vezesRepetir, enquantoVerdadeiro, paraCada.
18
Juntando tudo que foi discutido até aqui podemos chegar ao código mostrado no
exemplo 4.2. O código responsável pelo desenho foi colocado em uma agenda separada.
PonteiroDosSegundos:
iniciar:
comSerrilhado
[
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
[@ang 9 100 3] mostrarPonteiro
1 descansar
[@ang 15 100 3] mostrarPonteiro
] praSempre
mostrarPonteiro:
[angulo cor tamanho espessura] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
Algoritmo 4.2: Modelo da ponteiro dos segundos.
No exemplo 4.2 é utilizada a primitiva associar. Esta primitiva é utilizada para
associar a um símbolo, um nome um determinado valor que se encontra na pilha. A
pilha é ótima para armazenamento de dados temporários durante cálculos. Entretanto
para armazenamento de informações que devem persistir durante mais tempo e para evitar
a manipulação da pilha pode-se gravar o valor da pilha em em uma variável. O valor da
variável será empilhado ao executar o nome informado antes da primitiva associar. No
exemplo, o terceiro elemento do hora, isto é, os segundos é armazenado na variável s,
sendo este valor posteriormente acessado para o calculo do ângulo.
A primitiva associar também permite associar várias variáveis de uma única vez atra-
vés de listas. Caso o topo e subtopo da pilha sejam listas, a lista do topo da pilha será
utilizada como nome para as variáveis e lista do subtopo da pilha será utilizada para
os valores que serão atribuídos. As duas listas devem possuir o mesmo tamanho, caso
19
contrário um erro será gerado.
Outro detalhe que aparece neste exemplo é o uso do @. O @ é utilizado dentro de
listas com o intuito de inserir na lista que se está criando não o símbolo que se encontra
após o mesmo, mas sim o resultado da execução deste símbolo.
4.3 Ponteiro dos minutos
O modelo para o ponteiro dos minutos é bastante parecido com o modelo feito parao ponteiros dos segundos. As grandes diferenças são:
1. Leitura dos segundos ao invés dos minutos
2. Tamanho, cor e espessura do ponteiro
Adotando essas alterações o código para o modelo do ponteiro dos minutos �ca como
no exemplo 4.3.
PonteiroDosMinutos:
iniciar:
comSerrilhado
[
obterHora 2 obterElemento m associar
90 m 6 ∗ − ang associar {ang=90−(m∗6)}
[@ang 0 80 3] mostrarPonteiro
1 descansar
[@ang 15 80 3] mostrarPonteiro
] praSempre
mostrarPonteiro:
[angulo cor tamanho espessura] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
20
Algoritmo 4.3: Modelo da ponteiro dos minutos.
4.4 Ponteiro das horas
O modelo para o ponteiro das horas segue a mesma estrutura básica dos outros dois
(segundos e minutos), entretanto o cálculo do ângulo é diferente devido ao ponteiro das
horas possuir 12 posições ao invés das 60 posições assumidas pelos ponteiros dos minutos
e dos segundos.
Adotando essas alterações o código para o modelo do ponteiro das horas �ca como no
exemplo 4.4.
PonteiroDasHoras:
iniciar:
comSerrilhado
[
obterHora 1 obterElemento h associar
90 h 30 ∗ − ang associar {ang=30−(h∗6)}
[@ang 0 50 6] mostrarPonteiro
1 descansar
[@ang 15 50 6] mostrarPonteiro
] praSempre
mostrarPonteiro:
[angulo cor tamanho espessura] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
Algoritmo 4.4: Modelo da ponteiro das horas.
21
4.5 Colocando o relógio para funcionar
Agora possuímos as 3 partes do relógio funcionando independentemente. Para fazer-
mos o relógio funcionar devemos instanciar um ator de cada um dos modelos que criamos.
Isso pode ser feito manualmente, mas não é uma solução interessante já que depende de
procedimentos manuais para que o relógio funcione adequadamente. Uma solução é a
criação de um aplique composto por uma instância de cada um dos 4 modelos.
De qualquer forma não é bom depender do aplique para de�nir como o relógio deverá
ser montado. Isso limita o uso do relógio fazendo com que qualquer um que queira utilizar
um relógio tenha que conhecer todos os componentes de que ele é feito. Para remediar
esta situação criaremos um modelo chamado Relogio e nele instanciaremos todos os com-
ponentes do mesmo, assim para instanciar um relógio não será necessário conhecimento
das partes do mesmo bastando instanciar o relógio mostrado no exemplo 4.5.
Relógio:
iniciar:
AroDoRelogio
PonteiroDosSegundos
PonteiroDosMinutos
PonteiroDasHoras
Algoritmo 4.5: Modelo Relógio.
A ocultação de detalhes internos é chamado de encapsulamento e é uma característica
desejável no paradigma de orientação a objetos. Neste paradigma existem objetos e a
computação se desenrola com a criação, destruição e troca de mensagens entre estes
objetos. Cada objeto deve encapsular os seus dados e detalhes dentro de si. Telis é uma
linguagem multi-paradigma e também utiliza conceitos de orientação a objetos. Objetos
são semelhante a atores e os modelos são chamados de classes nas linguagens orientadas
a objetos.
Chegamos então ao código mostrado no exemplo 4.6 possuindo todos os modelos
desenvolvidos até aqui.
PonteiroDosSegundos:
iniciar:
comSerrilhado
[
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
22
[@ang 9 100 3] mostrarPonteiro
1 descansar
[@ang 15 100 3] mostrarPonteiro
] praSempre
mostrarPonteiro:
[angulo cor tamanho espessura] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
PonteiroDosMinutos:
iniciar:
comSerrilhado
[
obterHora 2 obterElemento m associar
90 m 6 ∗ − ang associar {ang=90−(m∗6)}
[@ang 0 80 3] mostrarPonteiro
1 descansar
[@ang 15 80 3] mostrarPonteiro
] praSempre
mostrarPonteiro:
[angulo cor tamanho espessura] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
PonteiroDasHoras:
iniciar:
23
comSerrilhado
[
obterHora 1 obterElemento h associar
90 h 30 ∗ − ang associar {ang=30−(h∗6)}
[@ang 0 50 6] mostrarPonteiro
1 descansar
[@ang 15 50 6] mostrarPonteiro
] praSempre
mostrarPonteiro:
[angulo cor tamanho espessura] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
Relógio:
iniciar:
AroDoRelogio
PonteiroDosSegundos
PonteiroDosMinutos
PonteiroDasHoras
Algoritmo 4.6: Exemplo do relógio com agendas parametrizadas.
24
Lição 5--Usando Moldes para
Remover Duplicação de Código
5.1 Movendo a agenda para o molde
No capítulo anterior criamos um relógio funcional com os ponteiros dos minutos,
segundos e horas. Mas ao olharmos mais de perto o código resultante vemos que os
três modelos que criamos para representar cada um dos três modelos possuem código em
comum.
Ao encontrar código em comum em uma agenda, uma saída para evitar a duplicação
de código é a utilização de agendas mas se estas agendas estão em modelos diferentes?
Como é possível compartilhar código entre diferentes modelos? Telis utiliza um mecanismo
chamado Molde para resolver este problema.
Um modelo pode ser moldado por quantos moldes forem necessários e quando isto
ocorre ele ganha todas as agendas de�nidas pelo molde. Estas agendas são exatamente
iguais as agendas de�nidas em um modelo comum, mas como vários modelos podem ser
moldados pelo mesmo molde temos um mecanismo para evitar a duplicação e resolver o
nosso problema.
Para criar um molde utiliza-se o botão de criação de moldes que se encontra abaixo
do botão utilizado para criação de modelos, o restante do processo é o mesmo. Os moldes
aparecem com uma coloração diferenciada na lista de modelos do editor. A lista de moldes
que moldam um modelo encontra-se acima do editor de texto. Esta lista deve conter o
nome dos moldes separados por espaços. Há uma opção abaixo da listagem de agendas
que permite a visualização de agendas que foram adquiridas de um molde e disponíveis
para uso.
Depois de criado o molde pode-se criar agendas dentro do mesmo. Assim como mo-
delos moldes possuem uma agenda iniciar que será invocada antes da agenda iniciar do
25
modelo. Esta regra é seguida por todo e qualquer agenda do molde, se existir uma agenda
com mesmo nome no molde e em quem ele molda a agenda de quem do molde é executada
primeiro.
Aplicando o conceito de molde no exemplo anterior, criaremos um molde Ponteiro
que irá moldar os modelos PonteiroDosSegundos, PonteiroDosMinutos, PonteiroDasHo-
ras. Este molde possuirá a agenda mostrarPonteiro comum todos os ponteiros, e os
modelos não a possuirão mais. Com estas alterações chegamos ao exemplos 5.1
Molde Ponteiro:
mostrarPonteiro:
{ Agenda mostrarPonteiro.
Recebe na pilha o angulo do ponteiro,
a cor do ponteiro, o tamanho e espessura.
Devolve na pilha: nada.
}
[espessura tamanho cor angulo] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
Modelo PonteiroDosSegundos moldado por Ponteiro:
iniciar:
comSerrilhado
[
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
[@ang 9 100 3] mostrarPonteiro
1 descansar
[@ang 15 100 3] mostrarPonteiro
] praSempre
Modelo PonteiroDosMinutos moldado por Ponteiro:
iniciar:
comSerrilhado
26
[
obterHora 2 obterElemento m associar
90 m 6 ∗ − ang associar {ang=90−(m∗6)}
[@ang 0 80 3] mostrarPonteiro
1 descansar
[@ang 15 80 3] mostrarPonteiro
] praSempre
Modelo PonteiroDasHoras moldado por Ponteiro:
iniciar:
comSerrilhado
[
obterHora 1 obterElemento h associar
90 h 30 ∗ − ang associar {ang=30−(h∗6)}
[@ang 0 50 6] mostrarPonteiro
1 descansar
[@ang 15 50 6] mostrarPonteiro
] praSempre
Modelo Relógio:
iniciar:
AroDoRelogio
PonteiroDosSegundos
PonteiroDosMinutos
PonteiroDasHoras
Algoritmo5.1: Exemplo do relógio com uso de molde.
5.2 Subindo a agenda iniciar
No exemplo 5.1 conseguimos remover a duplicação existente entre os diversos modelos
movendo a agenda desenharPonteiro para um molde. Mas as agendas iniciar dos modelos
estão todas muito parecidas. Será que não existe alguma forma de aproveitar melhor o
molde e evitar esta potencial duplicação entre os ponteiros?
Neste processo de tentar encontra remover a duplicação de algo parecido é deixar os
códigos iguais. Vamos adotar esta abordagem aqui. Começaremos criando novas agendas
até que a agenda iniciar de todos os modelos estejam iguais, quando conseguirmos isto
poderemos subir a agenda para o molde.
27
Molde Ponteiro:
mostrarPonteiro:
[angulo cor tamanho espessura] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
Modelo PonteiroDosSegundos moldado por Ponteiro:
iniciar:
comSerrilhado
[
calcularAngulo angulo associar
[@angulo @cor @tamanho @espessura] mostrarPonteiro
1 descansar
[@angulo 15 @tamanho @espessura] mostrarPonteiro
] praSempre
cor:
9
tamanho:
100
espessura:
3
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo PonteiroDosMinutos moldado por Ponteiro:
iniciar:
comSerrilhado
[
calcularAngulo angulo associar
[@angulo @cor @tamanho @espessura] mostrarPonteiro
1 descansar
[@angulo 15 @tamanho @espessura] mostrarPonteiro
] praSempre
cor:
28
0
tamanho:
80
espessura:
3
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo PonteiroDasHoras moldado por Ponteiro:
iniciar:
comSerrilhado
[
calcularAngulo angulo associar
[@angulo @cor @tamanho @espessura] mostrarPonteiro
1 descansar
[@angulo 15 @tamanho @espessura] mostrarPonteiro
] praSempre
cor:
0
tamanho:
50
espessura:
6
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo Relógio:
iniciar:
AroDoRelogio
PonteiroDosSegundos
PonteiroDosMinutos
PonteiroDasHoras
cor:
9
tamanho:
100
espessura:
3
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
29
Algoritmo 5.2: Tornando métodos iniciar dos ponteiros iguais.
No exemplo ?? foram criados quatro novas agendas: uma para retornar a cor, uma
para a espessura, uma para o tamanho e uma para o cálculo do ângulo do ponteiro em
um determinado instante. Além disso, estas agendas passaram a ser utilizadas na agenda
iniciar, fazendo com que a agenda iniciar de todos os métodos se tornem iguais. Logo,
podemos subir o método iniciar para o molde Ponteiro obtendo o resultado mostrado no
exemplo 5.3.
Molde Ponteiro:
iniciar:
comSerrilhado
[
calcularAngulo angulo associar
[@angulo @cor @tamanho @espessura] mostrarPonteiro
1 descansar
[@angulo 15 @tamanho @espessura] mostrarPonteiro
] praSempre
mostrarPonteiro:
[angulo cor tamanho espessura] associar
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
Modelo PonteiroDosSegundos moldado por Ponteiro:
cor:
9
tamanho:
100
espessura:
3
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
30
Modelo PonteiroDosMinutos moldado por Ponteiro:
cor:
0
tamanho:
80
espessura:
3
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo PonteiroDasHoras moldado por Ponteiro:
cor:
0
tamanho:
50
espessura:
6
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo Relógio:
iniciar:
AroDoRelogio
PonteiroDosSegundos
PonteiroDosMinutos
PonteiroDasHoras
cor:
9
tamanho:
100
espessura:
3
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Algoritmo 5.3: Método iniciar dos ponteiros no molde Ponteiro.
A agenda iniciar está no molde, mas as agendas cor, tamanho, espessura e calcula-
rAngulo se encontram nos modelos, isso não deveria gerar um erro? A resposta a esta
31
pergunta é depende, este comportamento é dependente da linguagem em que se está pro-
gramando. Em Telis e outras linguagens dinâmicas como Ruby, Python por exemplo um
erro não é gerado pois em tempo de execução os moldes estão atrelados aos modelos e a
agenda que será invocada será a agenda deste modelo. Em linguagens estáticas como Java
e C++ um erro ocorre, é necessário a declaração destas agendas no molde. Entretanto,
estas linguagens fornecem mecanismos para que a implementação destas agendas sejam
postergadas para os modelos obtendo assim o mesmo efeito obtido em Telis.
Dica
Assim como modelos, moldes também podem ser moldados por
outros moldes permitindo a criação de hierarquias mais complexas
e permitindo uma maior coerência e facilidade na hora de evitar as
duplicações de código.
32
Lição 6--Comunicação entre atores
Na lição anterior foi criado um relógio. Cada compoenente lógico do relógio foi asso-
ciado a um modelo especí�co responsável por realizar os calculos das posições do relógio
e fazer a apresentação, ou seja, desenhar na tela a parte correspondente.
Em engenharia de software, existem os chamados padrões de projeto. Padrões foram
introduzidos em 1994 e são catálogos que buscam capturar estruturas de organização re-
correntes, dando a elas nome, descrição, aplicabilidade, citando vantagens e desvantagens
do uso. Um dos padrões é chamado Modelo-Controle-Visão ou MVC. Este padrão diz
que o programa deve ser estruturado em 3 partes: Modelo, Controle, Visão. O modelo
é responsável por representar os objetos do domínio da aplicação. A visão é responsável
por apresentar os dados ao usuário. O controle faz a comunicação observando o que é
realizado na visão e manipulando o modelo de acordo. Existem vertententes nas quais a
visão pode observar e reagir a mudanças no modelo, em outras a visão não se relaciona
com o modelo, quem reage as alterações no modelo é o controle, que por sua vez atualiza
a visão. Note que a visão, modelo e controle não correspondem a modelos, esta é uma
estrutura geral de organização sendo que cada um destes componentes pode ser composto
por vários modelos.
O objetivo neste capítulo é separar a visão do controle na aplicação do relógio. O
problema em fazer isto é que com o que temos até o momento não é possível realizar
comunicação entre atores. Um ator é uma unidade de processamento atômica e indepen-
dente que executa a sua agenda iniciar, não fazendo mais nada após o término desta. Telis
oferece mecanismos para que atores possam se comunicar, via estímulos e via comunica-
ção direta. Iremos modi�car os exemplos anteriores utilizando ambas as abordagens para
realizar a comunicação entre modelo e visão. Nestes exemplos iremos suprimir a camada
de controle por simplicidade.
33
6.1 Separando modelo de visão com estímulos
Para realizar a comunicação entre modelo e visão iremos utilizar estímulos. Estímulos
em Telis são �mensagens�� enviadas e recebeidas por atores. Imagine que cada ator se
comporte como sendo uma espécie de emissora de rádio: ele emite um estímulo que pode
ser recebido (tratado) por todos aqueles que estiverem esperando por um estímulo do
mesmo tipo.
Um ator pode enviar um estímulo utilizando a primitiva dizer. Esta primitiva busca
recebe como parâmetro uma lista, sendo esta lista a mensagem, também conhecida como
tupla, a ser enviada pelo ator. Depois de enviada a mensagem pode ser recebida por
qualquer outro ator que tenha declarado que está interessado na mesma. É importante
salientar que atores não podem tratar estímulos enviados por ele mesmo. Outro detalhe
é que estímulos podem ser perdidos por outros atores caso eles estejam tratam outro
estimulo. Durante o tratamento de um determinado estímulo o ator �ca surdo, isto é, não
é capaz de tratar nenhum outro estímulo. Após o término do tratamento, oator volta a
receber e tratar estímulos.
Para declarar que está interessado em um determinado em um estímulo utiliza-se a
primitiva seDito. Esta primitiva recebe dois parâmetros. O primeiro é uma lista, chamada
de �ltro, indicando o tipo de tupla que o ator está interessado em tratar, e o segundo uma
lista de comandos indicando o que deverá ser executado quando a mensagem for recebida.
Ao receber um estímulo o ator veri�ca quais os tratadores casam com a tupla recebida,
para tudo que estiver fazendo no momento e executa o tratador associado. Antes de iniciar
o tratador a tupla é colocada na pilha, permitindo a extração de informação da mesma.
Após o término de execução do tratador, o ator limpa a pilha, retornando ao mesmo estado
encontrado antes da execução e continua a executar do ponto onde ouve a interrupção.
Para determinar se uma tupla casa com um determinado �ltro Telis faz o seguinte:
1. Veri�ca se o tamanho da tupla e do �ltro são iguais.
2. Compara elemento a elemento se estes casam.
3. Se condição acima for verdadeira para todos os elementos da tupla e a primeira
condição for verdadeira, a tupla e o �ltro casam.
Dois elementos casam se são iguais. Telis fornece um mecanismo para especi�car posições
na tupla que esperam um determinado tipo de dados, como parâmetros. Isto é conseguido
34
através das palavras-chaves: texto, número, lista. Se o �ltro contiver uma destas palavras
chaves e a tupla possuir na mesma posição um elemento do tipo discriminado no �ltro,
estes elementos irão casar. Abaixo alguns exemplos:
Agora que conhecemos estímulos, vamos usá-los para implementar a visão e o modelo
separadamente. Iremos criar um modelo responsável pelo desenho dos ponteiros, um
modelo responsável pelo desenho do restante do relógio, e modelos responsáveis pelo
cálculo dos ângulos e tempos de descanso de pintura. Quando o ângulo de um ponteiro
tiver que ser atualizado um estímulos será enviado e os atores da visão irão se atualizar.
Essas alterações podem ser vistas no exemplos 6.1.
Modelo VisãoPonteiro:
iniciar:
[ponteiro cor tamanho espessura] associar
0 angulo associar
comSerrilhado
[RELOGIO @ponteiro numero]
[
[NULO NULO angulo] associar
[@angulo 15 @tamanho @espessura] mostrarPonteiro
[@angulo @cor @tamanho @espessura] mostrarPonteiro
]
seDito
mostrarPonteiro:
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
Molde Ponteiro:
iniciar:
[
calcularAngulo angulo associar
[RELOGIO @ponteiro @angulo] dizer
1 descansar
] praSempre
35
Modelo PonteiroDosSegundos moldado por Ponteiro:
ponteiro:
"segundos"
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo PonteiroDosMinutos moldado por Ponteiro:
ponteiro:
"minutos"
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo PonteiroDasHoras moldado por Ponteiro:
ponteiro:
"horas"
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo Relógio:
iniciar:
AroDoRelogio
["segundos" 9 100 3] VisãoDoPonteiro
["minutos" 0 80 3] VisãoDoPonteiro
["horas" 0 50 6] VisãoDoPonteiro
PonteiroDosSegundos
PonteiroDosMinutos
PonteiroDasHoras
suicidar
Algoritmo 6.1: Relógio com Visão e Controle utilizando estímulos.
6.2 Separando modelo de visão com comunicação di-
reta
Outra forma de comunicação entre atores disponibilizada pelo Telis é chamada de co-
municação direta. Ao contrário da comunicação via estímulos na qual um ator envia um
estímulo e um número qualquer de atores reagem ao mesmo de forma assíncrona, a comu-
36
nicação direta ocorre entre 2 atores e de forma síncrona. Um ator envia pede a execução
de uma agenda para um segundo ator conhecido, aguarda o término do processamento da
requisição e recebe uma resposta.
Para realizar a comunicação direta é necessário que o ator que deseja requisitar a
execução conheça o outro ator. Isso acontece por meio da identidade. Todo ator possui
uma identidade única na execução. O ator pode obter a sua própria identidade através das
primitivas euMesmo ou obterIdentidade. Ao instanciar um ator, é empilhado a identidade
do novo ator na pilha do ator que o instanciou permitindo assim a comunicação entre
ambos.
A comunicação direta funciona de forma semelhante a estímulos, no que diz respeito
a execução, o ator que recebe um pedido de comunicação direta para o que está fazendo,
trata a requisição e retorna ao que estava fazendo. A diferença é que em estímulos, o
tratador é atrelado ao �ltro através da primitiva seDito. Na comunicação direta o ator
que deseja realizar a comunicação indica o nome de uma agenda do ator alvo. O ator
alvo irá executar esta agenda e retornar o que estiver no topo da pilha. Um elemento da
pilha do ator que está iniciando a comunicação direta é consumido como parâmetro se
necessário.
Ao contrário da comunicação utilizando estímulos, não existe perda de comunicação
direta. Se um ator estiver tratando uma comunicação direta ou um estímulo quando
uma nova requisição de comunicação direta chegar, o ator en�leira as requisições para
posterior execução. O ator retoma a sua execução normal apenas depois que todas as
requisições tenham sido atendidas. Importante salientar que comunicação direta não
interrompe o tratamento de um estímulo, mas um estímulo pode interromper o tratamento
de comunicação direta. Estímulos possuem um carater emergencial e prioritário e por isso
possuem prioridade sobre comunicação direta.
Para realizar a comunicação direta, utiliza-se a notação do ponto. Nesta notação,
coloca-se a identidade do ator com o qual se deseja realizar a comunicação direta na
pilha, e em seguida um ponto seguido do nome da agenda que deverá ser executada, como
mostrado no exemplo 6.2. Não deve haver espaços entre o ponto e o nome da agenda.
"possível parâmetro" identidadeDoAtor.nomeDeUmaAgenda
Algoritmo 6.2: Exemplo de comunicação direta.
Para evitar que um ator realize comunicação direta com qualquer agenda de outro
ator, Telis fornece um mecanismo para evitar que uma agenda possa ser utilizada para
37
comunicação direta. Estas agendas são chamadas de agendas privadas, sendo as outras
chamadas de agendas públicas. A diferença entre agendas privadas e agendas públicas é
que agendas privadas tem seu nome iniciado por .
Durante a execução da agenda iniciar atores não são capazes de tratar requisições de
comunicação direta. Isto ocorre para que a inicialização de atores ocorra antes que uma
agenda seja invocada. Assim sendo atores que entram em loops in�nitos na agenda iniciar
são incapazes de atender requisições de comunicação direta. Caso alguém tente realizar
uma comunicação direta com um destes atores, um time-out ocorre gerando um erro.
Agora que sabemos como funciona a comunicação direta, iremos substituir a comuni-
cação direta no exemplo 6.1 por comunicação direta. Para fazer isso, teremos que informar
ao modelo as identidades dos atores responsáveis pela visão para que a comunicação direta
possa ser realizada. Além disso, o tratador de estímulos da visão deverá ser transformado
em uma agenda pública. O resultado pode ser visualizado no exemplo 6.3
Modelo VisãoPonteiro:
iniciar:
[ponteiro cor tamanho espessura] associar
0 angulo associar
comSerrilhado
atualizar:
[angulo] associar
[@angulo 15 @tamanho @espessura] mostrarPonteiro
[@angulo @cor @tamanho @espessura] mostrarPonteiro
mostrarPonteiro:
angulo �xarDirecao
cor �xarCorDosRastros
espessura �xarEspessura
comRastros
tamanho frente
tamanho −1 ∗ frente
semRastros
Molde Ponteiro:
iniciar:
[visao] associar
comSerrilhado
[
38
calcularAngulo angulo associar
[@angulo] visao.atualizar
1 descansar
] praSempre
Modelo PonteiroDosSegundos moldado por Ponteiro:
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo PonteiroDosMinutos moldado por Ponteiro:calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo PonteiroDasHoras moldado por Ponteiro:
calcularAngulo:
obterHora 3 obterElemento s associar
90 s 6 ∗ − ang associar {ang=90−(s∗6)}
Modelo Relógio:
iniciar:
AroDoRelogio
[9 100 3] VisãoDoPonteiro segundos associar
[0 80 3] VisãoDoPonteiro minutos associar
[0 50 6] VisãoDoPonteiro horas associar
[@segundos] PonteiroDosSegundos
[@minutos] PonteiroDosMinutos
[@horas] PonteiroDasHoras
suicidar
Algoritmo 6.3: Relógio com Visão e Controle utilizando estímulos.
39
Lição 7--Conclusão
Nesta apostila foi feita uma introdução a programação de computadores utilizando a
linguagem de programação Telis, com uma abordagem baseada em exemplos. Trechos de
códigos e programas são desenvolvidos e explanados visando a introdução da sintaxe de
Telis e de conceitos importantes e, muitas vezes, avançados de programação.
Telis apresenta diversos conceitos avançados e complexos, como concorrência e pa-
ralelismo, de forma simples e intuitiva. Isto incentiva o uso dos conceitos por parte do
programador iniciante, deixando-o confortável em usá-la.
Apesar de ser uma ótima ferramenta para aprender a programar e introduzir conceitos
avançados de forma simples, Telis não é uma linguagem comercial. O próximo passo é
aprender uma linguagem de programação comercial. Mas como o aluno aprendeu todos
os conceitos importantes em Telis, a aprendizagem desta linguagem deverá se tornar mais
suave.
	Instalação de Telis
	Primeiro programa
	Desenhos e Telis
	Criando Modelos e Agendas
	Criando um modelo
	Criando agendas
	Publicando o programa na internet
	Criando Agendas Parametrizáveis
	Desenhando um relógio
	Ponteiro dos segundos
	Ponteiro dos minutos
	Ponteiro das horas
	Colocando o relógio para funcionar
	Usando Moldes para Remover Duplicação de Código
	Movendo a agenda para o molde
	Subindo a agenda iniciar
	Comunicação entre atores
	Separando modelo de visão com estímulos
	Separando modelo de visão com comunicação direta
	Conclusão