Lab4 Leandro Lima

aluno: Leandro Lima
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 07/11/2008 (5)

Introdução

Nesse 4o laboratorio de ces-22 foi introduzido conhecimentos da linguagem Ruby de
tipagem dinâmica. Portamos o lab2 da linguagem Java para Ruby e, com isso,
encontramos uma série de funcionalidades dessa nova linguagem.

Desenvolvimento

A grande diferença de Java para Ruby certamente reside no fato de uma ser de tipagem
estática (Java) enquanto a outra é de tipagem dinâmica (Ruby). Com isso, queremos
dizer que não é necessário declarar o tipo das variáveis no momento de sua criação.
Ao mesmo que tempo que isso dá ao programador uma liberdade muito grande para
trabalhar, deve-se ter cuidado (inclusive isso foi uma das grandes dificuldades ao
realizar esse lab) para não se misturar os tipos, e para saber ao certo que tipo de
objeto está sendo utilizado em um determinado momento.

A classe RelaQueue, por exemplo, não necessita mais dos indexadores inteiros para acessar as posições da fila. Tudo é feito automaticamente.

class RelaQueue
      @array
 
    def initialize
      @array = []
      @array = Array.new
    end
 
    def queue(rela)
      @array.unshift(rela)
    end
 
    def dequeue
      @array.pop
    end
 
end

O fato das classes todas estarem num mesmo arquivo também é interessante, pois a organização do código fica a critério do programador. A tradução dos comandos não é tão simples quanto parece. Os acessores de atributos poupam muito tempo, já que não é preciso ficar declarando vários getters e setters. A classe Comportamento não é mais necessária, pois podemos alterar o tipo dos objetos.

Desse modo algumas mudanças foram feitas nas classes Aluno.

class Aluno
      attr_accessor :conhecimento, :nome, :queue
 
              @conhecimento 
              @nome
              @queue
              @comportamento
 
      public
      def initialize(nome, queue)
              @nome = nome
              @queue = queue
              @conhecimento = 0
              @comportamento = Esforcado.new(self)
      end
 
      def inteligencia
        @comportamento.inteligencia
      end
 
      def dedicacao
        @comportamento.dedicacao
      end
 
      def comportamento=(comp)
        @comportamento = comp
      end
 
    . . .
 
end

A classe Relatorio sofreu poucas mudanças devido às atribuições de variáveis de instâncias serem as únicas operações.

class Relatorio
    attr_reader :aluno, :originalidade, :qualidade
 
    def initialize(qualidade, originalidade, aluno)
        @qualidade = qualidade
        @originalidade = originalidade
        @aluno = aluno
    end
 
end

A classe de testes foi a que sofreu menos alterações. Basicamente foi feita uma tradução direta dos comandos.

require 'classes'
require 'test/unit'
 
class Teste < Test::Unit::TestCase
 
    def testeFuncionaComoOLab1
        #criando os objetos
        queue = RelaQueue.new
        prof = Professor.new(queue)
 
        aluno1 = Aluno.new("John Smith", queue)
        aluno2 = Aluno.new("Mark Smith", queue)
        aluno3 = Aluno.new("Joseph Smith", queue)
        aluno4 = Aluno.new("Robert Smith", queue)
 
        begin
            aluno3.comportamento = SafoPreguicoso.new(aluno3)
            aluno4.comportamento = SafoPreguicoso.new(aluno4)
        rescue
            fail("Nao deveria lancar erro!")
        end
 
        . . .
 
        #teste de burro
        assert_equal(0.0, burro.inteligencia, 0.01)
        assert_equal(0.0, burro.dedicacao, 0.01)
 
        #teste de summa
        assert_equal(1.0, summa.inteligencia, 0.01)
        assert_equal(1.0, summa.dedicacao, 0.01)
 
        begin
            alunoITA.comportamento = SafoPreguicoso.new(alunoITA)
            alunoITA.comportamento = Summa.new(alunoITA)
            alunoUSP.comportamento = Burro.new(alunoUSP)
            alunoUnicamp.comportamento = Burro.new(alunoUnicamp)
        rescue
            fail("Nao deveria lancar erro!")
        end
 
        . . .
end

Screenshot do Teste

1.JPG

Conclusão

Sem dúvida foram encontradas algumas dificuldades para realizar esse lab, principalmente porque algumas classes deixaram de existir e outras foram severamente "enxugadas". Contudo, percebemos que a redução no número de linhas foi bastante significativa. Aproximadamente 40% das linhas foram retiradas e o programa em si permaneceu o mesmo. Isso é extermamente útil, pois não só o processo de criação do código fica mais fácil, como a depuração também. É mais fácil encontrar os erros em Ruby do que em Java. Só por isso, já se torna extremamente vantajoso usar Ruby.

Add a New Comment
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License