Mas não é bem assim. Alterações no sistema podem requerer que todos ou uma determinada série de testes sejam refeitas para validar a correção do programa. Quando o programador possui prazos e nao se policia muito bem, os testes impõem um limite tangível. Passou nos testes não é necessário mais nada. Também não é bem assim, mas vamos ignorar por hora.

O “video-tutorial-mudo” mostra como utilizar TDD no desenvolvimento e como o sistema facilita a vida do usuário na criação de classes, métodos e execução dos testes. Foram feitos apenas testes para passar, mas poderiam ser criados testes para os casos onde deve ocorrer falha (divisão por zero por exemplo) e, como sempre, outras coisinhas.

Inicialmente criamos uma classe derivada de TestCase que conterá os métodos correspondentes aos testes a serem efetuados. Existe ainda o método setUp que, se definido, será executado antes de cada teste e o método tearDown que será executado ao final. Colocamos os métodos na categoria testing.

No evento do vídeo abaixo, após a criação do primeiro método para o teste, eu poderia criar a variável ‘c’ na instância da classe e inicializá-la no método setUp. Optei por declará-la como temporária dentro do próprio método. Tudo que o ambiente não reconheceu, tentou criar de uma forma automatizada ou solicitar a confirmação.

Poderemos executar os testes diretamente pelo menu, toda a classe ou os métodos individualmente. Como de praxe, quando um teste falha, o círculo na esquerda fica vermelho. Se passa é mostrado na cor vermelha. Podemos utilizar a janela TestRunner para auxiliar na execução dos testes. Depois fizemos uma pequena refatoração no programa e executamos os testes novamente para confirmar se estava tudo perfeito.

O vídeo baseia-se na imagem salva do artigo anterior.

=-=-=-=-=
Powered by Blogilo

Ok, então criamos uma classe, seus métodos, agrupamos para uma melhor organização, efetuamos os testes e, ao sair do ambiente, decidimos por salvar a imagem. Quando abrimos o ambiente novamente, ele encontra-se no mesmo estado que estava quando saímos. Podemos inclusive continuar com os testes no Workspace que tudo funcionará normalmente. Aliado ao fato de podermos efetuar alterações no código e continuar trabalhando como se nada tivesse acontecido, certamente são fatores que facilitam a vida do desenvolvedor.

Digamos que eu queira alterar o método resetTo: para que, se for recebido um valor negativo, inicialize o contador com zero. Não tem nenhum problema. Basta alterar o método e continuar com os testes (TDD fica para outra hora). Mas e se…. A sei. Você faz uma cópia do método ou comenta as linhas caso necessite retornar ao código original? Aqui não é necessário. O próprio ambiente se encarrega de fazer o versionamento do programa. A qualquer momento você poderá retornar algo anterior. Mais uma característica do ambiente para facilitar a vida do desenvolvedor.

Se fosse somente pela linguagem, Smalltalk seria apenas mais uma em um ambiente onde se cria uma nova linguagem a cada dia com algumas frescurinhas para diferenciar de outra. Mas como Smalltalk pressupõe a linguagem e o ambiente (já era assim na década de setenta) e o ambiente oferece facilidades não encontradas ou dificilmente encontradas em outros ambientes, aliados a uma linguagem simples e flexível, o seu estudo vale a pena. Se você possui um caixa razoável até poderia pensar em investir em um ambiente comercial (veja alguns casos de sucesso com o VisualWorks; e o JPMorgam não é o que se pode chamar de empresa pequena).

Ok, mais um vídeo mudo.

=-=-=-=-=
Powered by Blogilo

Depois falaremos mais sobre imagem. Para não bagunçar o sistema, criarei uma categoria chamada Sandbox onde vou criar classes para demonstração.

Depois crio uma classe Contador. Posteriormente, adiciono diversos métodos ao contador como incremento e decremento. Os métodos serão categorizados para que tudo fique mais ordenado e de fácil localização.

Ao criar o método para a inicialização da classe, foi informada uma variável que conterá o valor atual do contador propositadamente não definida anteriormente para mostrar como o ambiente se comporta nessas situações no momento em que ele compila o método (Accept).

No meio tempo, exploramos algumas possibilidades do ambiente como edit & continue com adição de novos métodos, inspeção do conteúdo de uma classe com o resultado da execução dos métodos.

Ao término iremos fechar a janela e salvar a imagem para uso futuro o que significa, basicamente, salvar o estado atual do ambiente. No próximo artigo veremos melhor o que significa isso.

Abaixo o vídeo-tutorial-mudo.

=-=-=-=-=
Powered by Blogilo

• Chamo o método addOne para um número cuja finalidade seria de adicionar 1 ao número. Um simples incremento.
• Como o método não existe, o ambiente me informa e pede para que seja confirmado, cancelado ou corrigido. Ele abre uma janela com diversas opções que ele acha que poderia ser as correções.
• Se eu escolho informar que eu estava correto e o método não existe, o ambiente gera uma exceção para o erro com possibilidade para que eu continue, abandone, inicie a depuração ou crie o método.
• Decido por criar o método na classe Integer (já que eu havia aplicado para um inteiro), escolho a categoria arithmetic (serve para que os métodos fiquem agrupados de forma lógica) e os dados de quem está efetuando a alteração para que alguém seja considerado culpado em caso de problema.
• É aberta uma janela para que eu edite o que o novo método irá fazer, informo que é apenas para somar 1 e retornar o resultado (usa-se ^ para indicar retorno de um valor), informo Accept para que o método seja compilado e seleciono Proceed para continuar o programa que estava sendo executado.

Ok, acabamos de ter o primeiro contado com o edit & continue, isto é, efetuamos uma alteração no programa e continuamos a execução sem a perda do que foi processado anteriormente. Na maioria das linguagens, se o seu programa está rodando a duas semanas, já processou um zilhão de dados e encontra um problema em uma circunstancia que não havia sido prevista inicialmente, a solução seria efetuar as correções e esperar mais duas semanas para chegar ao pondo em que havia parado. Em teoria, um programa em Smalltalk necessitaria ser interrompido apenas para a correção do bug e seguiria em frente. Outra opção radical, o que não significa racional, seria a possibilidade de colocar o sistema em produção logo após ter iniciado. Mas vamos juntar o Edit & Continue com o Refactoring.

• Agora eu resolvo invocar o método addOne para um valor em ponto flutuante. Novamente o ambiente irá mostrar um erro dizendo que não existe método addOne para a classe Float. Lógico, eu adicionei o método para a classe Integer. Poderia criar um novo método para a classe Float o que não seria muito inteligente. O ideal seria mover o método para a classe pai e ele seria herdado pelas filhas.
• Para fazer isso, posso abrir o navegador no ambiente, procurar o método addOne e movê-lo para a classe pai. Como pode ser visto nos menus do vídeo, as opção para refactoring são abundantes. Então escolho Refactor method e Pull up e pronto. O método passou da classe Integer para a classe Number. Digo para aceitar e pronto.

E assim termina o vídeo-tutorial-mudo de hoje. Lembrando que eu estou usando o Pharo versão 1.3. YMMV.

=-=-=-=-=
Powered by Blogilo

Para começar, o ambiente de desenvolvimento em Smalltalk já é algo muito bom. Totalmente integrado e já vem com a linguagem. Ou será que é a linguagem que vem com o ambiente? Há bastante tempo eu testei o Squeak mas achei meio estranho. Como o objetivo era para o aprendizado infantil na área de programação, era muito lúdico para o meu gosto. Mesmo assim, vários projetos interessantes surgiram sob a plataforma. O Seaside foi um deles e talvez o mais importante. Outro foi o Croquet . Um tempo depois surgiu o Pharo. Apesar de baseado no Squeak, ainda estava no início do desenvolvimento e não dei muita atenção. Mas já está bem usável e justifica que se fale mais sobre ele. É o que será utilizado por mim em todos os exemplo. Se alguém deseja um comercial, a opção pode ser o VisualWorks. Para um aprendizado maior sobre a linguagem, existem diversos livros gratuitos que podem ser baixados (só lembre-se que podem existir algumas diferenças no ambiente de desenvolvimento e na implementação da linguagem). Pode ser interessante salientar que o Pharo roda no Linux, OS X e no Windows.

Mas vamos voltar ao que interessa. Diversas vezes, e não foram apenas meia dúzia, eu sabia o que queria mas não lembrava de como chegar lá. Como fazer para calcular 2 ao cubo naquela linguagem? Seria 2 ^ 3? ou 2 ** 3 ou era uma função do tipo pow(2,3)? No Pharo basta abrir a janela para localizar, selecionar exemplo, digitar os valores 2. 3. 8 e pronto. Ele retorna, entre outras opções, o raisedTo: que seria o método que eu invocaria em um número com o argumento 3 para retornar 8. Da mesma forma poderíamos procurar pelo método que retornaria o fatorial de 5 entrando com 5. 120 e obtemos factorial. A única observação é colocar um ponto para separar os valores. Um videozinho para facilitar a visualização.

=-=-=-=-=
Powered by Blogilo

Bem, dá para fazer até no papel. Mas como o meu objetivo é aprender J, então vou resolver em J. Mas vou resolver passo a passo conforme o enunciado. Primeiro a geração da sequencia:

>:i.10x
1 2 3 4 5 6 7 8 9 10

Como a sequencia inicia com zero, devemos incrementar os elementos >: e o x foi utilizado para trabalhar com precisão estendida.

^~>:i.10x
1 4 27 256 3125 46656 823543 16777216 387420489 10000000000

O ^ irá elevar um número a um determinado expoente e, como o ~ duplica a lista antes do verbo, significa elevar um número a ele mesmo.

Para somar os elementos de uma lista, inserimos / o verbo + entre cada elemento dela. Como resultado temos:

+/^~>:i.10x
10405071317

Ok, está conforme o enunciado. Para obtermos os últimos dez dígitos do resultado, primeiro deveremos converter o número para um string utilizando “: e, logo em seguida, obter os últimos dez dígitos _10{. (como foi visto na resolução do problema #13, 10{. retorna os 10 primeiros elementos)

_10{.":+/^~>:i.10x
0405071317

A solução não é otimizada e resultou em um tempo mais longo do que eu espera para a sequencia 1…1000. Apesar do problema permitir que eu exclua 100 número dos cálculos (como desejamos os últimos dez dígitos e todo o múltiplo de dez ira gerar um valor como dez ou mais zeros que não seriam significativos na soma), essa exclusão não melhorou muito a performance do cálculo. Após resolver o exercício e entrar no fórum do problema, uma outra forma de resolução do problema em J possui uma performance bem melhor. Enquanto a minha leva 3s, o método lá leva 0.09s. Mas é para quem já está no nível 1 de aprendizado de J.

=-=-=-=-=
Powered by Blogilo

   A=. ?. 6 6 $ 10

   A
6 5 9 2 4 9
0 7 0 4 6 8
3 8 1 2 8 0
0 2 1 6 0 4
4 1 3 3 6 6
5 7 8 8 2 1

   4<\A
┌───────────┬───────────┬───────────┐
│6 5 9 2 4 9│0 7 0 4 6 8│3 8 1 2 8 0│
│0 7 0 4 6 8│3 8 1 2 8 0│0 2 1 6 0 4│
│3 8 1 2 8 0│0 2 1 6 0 4│4 1 3 3 6 6│
│0 2 1 6 0 4│4 1 3 3 6 6│5 7 8 8 2 1│
└───────────┴───────────┴───────────┘

   4*/\A
0 560  0  96 0 0
0 112  0 144 0 0
0 112 24 288 0 0

   >./, 4*/\A 560

   >./,4*/\"1 A
2240

   A
6 5 9 2 4 9
0 7 0 4 6 8
3 8 1 2 8 0
0 2 1 6 0 4
4 1 3 3 6 6
5 7 8 8 2 1

   </.A
┌─┬───┬─────┬───────┬─────────┬───────────┬─────────┬───────┬─────┬───┬─┐
│6│5 0│9 7 3│2 0 8 0│4 4 1 2 4│9 6 2 1 1 5│8 8 6 3 7│0 0 3 8│4 6 8│6 2│1│
└─┴───┴─────┴───────┴─────────┴───────────┴─────────┴───────┴─────┴───┴─┘

   >./,4*/\"1]/.A
1152

   </.|.A
┌─┬───┬─────┬───────┬─────────┬───────────┬─────────┬───────┬─────┬───┬─┐
│5│7 4│8 1 0│8 3 2 3│2 3 1 8 0│1 6 6 1 7 6│6 0 2 0 5│4 8 4 9│0 6 2│8 4│9│
└─┴───┴─────┴───────┴─────────┴───────────┴─────────┴───────┴─────┴───┴─┘
   >./,4*/\"1]/.|.A
1152

Juntando tudo temos o que poderíamos chamar de ‘one liners’.

   (>./,4*/\"1]/.|.A) >. (>./,4*/\"1]/.A) >. (>./,4*/\"1 A) >. >./, 4*/\A
2240

A=: ".;._2(0 : 0)
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
...
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
)

E aplicar o nosso programa de uma linha.

Inicialmente temos que 0, 1 e 2 pode ser traduzido para J como i.3. O número de permutações para três elementos seria dada pelo fatorial de 3 ou !3 em J que é 6. Para resolver as permutações e selecionar uma das sequências utilizamos A. (Anagram Index). Como no exemplo são três elementos e seis possíveis combinações, para obtermos todas as combinações podemos utilizar:

0 1 2 3 4 5 A. 0 1 2

0 1 2
0 2 1
1 0 2
1 2 0
2 0 1
2 1 0

Apesar do número de permutações aumentar rapidamente e não ser interessante visualizar todas, uma forma mais genéria poderia ser:

(i.!3) A. i.3

0 1 2
0 2 1
1 0 2
1 2 0
2 0 1
2 1 0

Então, para sabermos a quinta permutação, usamos diretamente 4 A. i.3 que retorna 2 0 1. Para saber a décima sexta permutação onde os elementos são os números inteiros de 0 a 9, podemos escrever:

15 A. i.10

0 1 2 3 4 5 8 7 9 6

Até aqui tudo bem, só que o problema deseja um número sem espaços. A solução mais complicada seria copiar a lista gerada e apagar manualmente os espaços. Outra forma é utilizar a #. (base) utilizando 10 como base. Como exemplo: 10#.2 3 4 => 234. A resposta para o problema ficaria como 10#.999999 A.i.10.

Como uma string é uma lista de caracteres (como pode ser visto no final do artigo sobre programas em uma linha), o problema também poderia ser resolvido usando uma string. No exemplo do problema ficaria:

(i.6) A. '012'

012
021
102
120
201
210

Facinho né?

=-=-=-=-=
Powered by Blogilo

Legal para ler. Fala do Colin Hughese e da criação do Projeto Euler. Lembrei dos velhos tempos do Ruby e do Code Kata do Dave Thomas. Basicamente, o treino leva a prefeição. Uma mente brilhante e preguiçosa pode ser ultrapassada por uma nem tão brilhante mas ativa.

Como já fiz algumas coisas do Projeto Euler e coloquei aqui, decidi resolver o problema #29. Em J é claro. Após ler o enunciado e pensar um pouquinho (saiu um cheirinho de queimado mas não estragou nada ) verifiquei que seria muito fácil resolver em J. Nem impressionaria os seus amigos pois não poderia ser considerado ‘uma linha‘. Talvez alguns caracteres.

A primeira coisa seria gerar uma seqüência para efetuar as operações, no caso elevar os números a uma determinada potência. No caso do exemplo do exercício que tem como base de 2 a 5, a seqüência seria dada por 2+i.4 que resultaria na lista 2 3 4 5. e seria assumida por a e b para efetuar a^b. Então:


^/ ~2+i.4

4   8  16   32
9  27  81  243
16  64 256 1024
25 125 625 3125

Não preciso explicar, mas sabemos que i.x gera uma seqüência de números inteiros entre 0 e x-1, ~ duplica o operador a esqurda do verbo (+~2=4), ^ é para exponenciação e o advérbio / insere o verbo entre cada elemento da lista.

O próximo passo seria eliminar os elementos duplicados. Para tanto nos poderemos converter a matriz gerada pelo resultado em uma lista utilizando , (Ravel) e selecionar os elementos não duplicados utilizando ~. (Nub). Fica:

~. , ^/ ~ 2+i.4

4 8 16 32 9 27 81 243 64 256 1024 25 125 625 3125

Agora é só verificar quantos elementos possui a lista para obtermos a resposta para o problema. Vamos de # (Tally). Temos então, para a resolução do problema conforme o enunciado:

# ~. , ^/ ~ 2+i.4

15

São 15 termos distintos para a=b=2 3 4 5. É só substituir o 4 por (aqui fica por sua conta) para obter o resultado do problema onde a=b=2…100. Como não sabemos os valores resultantes, pode ser interessante colocar o sufixo x no número para trabalhar com precisão extendida e garantir que não haverá conflitos onde o ponto flutuante for assumido. Por exemplo:

32^45

5.39199e67

32^45x

53919893334301279589334030174039261347274288845081144962207220498432

=-=-=-=-=
Powered by Blogilo