Lab4 Italo Aguiar

aluno: Italo Fernandes Aguiar
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 04/10/2008 (6)

Introdução

Para um primeiro momento de aprendizado prático sobre o padrão de linguagem Ruby, concluiu-se que seria de bom rendimento adaptar o labortório 2, feito em Java, para Ruby. Dessa forma, procedeu-se a seguinte adaptação de linguagens de tal forma que o usuário final não tenha noção de qual linguagem esteja sendo executada.

Desenvolvimento

As classes Java do laboratórios 2, adaptadas para Ruby, ficaram da seguinte forma:

# => CLASSE ALUNO
class Aluno
  attr_accessor :comportamento
  attr_reader :nome, :conhecimento
 
  def initialize(nome, queue)
    @nome = nome
    @queue = queue
    @conhecimento = 0
 
    @comportamento = Esforcado.new(self)
    @comportamento.aluno=(self)
  end
 
  def inteligencia
    comportamento.inteligencia
  end
 
  def dedicacao
    comportamento.dedicacao
  end
 
  def faz_e_entrega_relatorio
    qualidade = (2 * self.dedicacao + 1 * self.inteligencia ) / 3
    originalidade = (1 * self.dedicacao() + 2 * self.inteligencia ) / 3
 
    rela = Relatorio.new( qualidade ,originalidade, self)
    @queue.queue(rela)
 
    @conhecimento += 1
  end
end
 
# => CLASSE ALUNOITA
class AlunoITA < Aluno
  def initialize(nome, queue)
    super(nome, queue)
  end
 
  def comportamento=(comportamento)
    if(comportamento.is_a?(Burro))
      raise "aluno do ITA nao pode ser burro!"
    end
 
    # => IMPLEMENTANDO RELACIONAMENTO NAS 2 DIRECOES
    super(comportamento)
    comportamento.aluno=(self)
  end
end
 
# => CLASSE ALUNOUNICAMP
class AlunoUNICAMP < Aluno
  def initialize(nome, queue)
    super(nome, queue)
  end
 
  def comportamento=(comportamento)
    if(comportamento.is_a?(Summa) || comportamento.is_a?(SafoPreguicoso))
      raise "Aluno UNICAMP nao pode ser Summa nem Safo Preguicoso!"
    end
 
    # => IMPLEMENTANDO RELACIONAMENTO NAS 2 DIRECOES
    super(comportamento)
    comportamento.aluno=(self)
  end
end
 
# => CLASSE ALUNO USP
class AlunoUSP < Aluno
  def initialize(nome, queue)
    super(nome, queue)
  end
 
  # => IMPLEMENTANDO RELACIONAMENTO NAS 2 DIRECOES
  def comportamento=(comportamento)
    if(comportamento.is_a?(Summa) || comportamento.is_a?(SafoPreguicoso))
      raise "Aluno USP nao pode ser Summa nem Safo Preguicoso!"
    end
 
    super(comportamento)
    comportamento.aluno=(self)
  end
end
 
# => CLASSE COMPORTAMENTO
class Comportamento
  attr_accessor :aluno
 
  def initialize(aluno)
    @aluno = aluno
    aluno.comportamento=(self)
  end
 
  def dedicacao
 
  end
 
  def inteligencia
 
  end
end
 
# => CLASSE ESFORCADO
class Esforcado < Comportamento
 
  def initialize(aluno)
    super(aluno)
  end
 
  def dedicacao
    1
  end
 
  def inteligencia
    0.5
  end
end
 
# => CLASSE BURRO
class Burro < Comportamento
 
  def initialize(aluno)
    super(aluno)
  end
 
  def dedicacao
    0
  end
 
  def inteligencia
    0
  end
end
 
# => CLASSE IMPREVISIVEL
class Imprevisivel < Comportamento
 
  def initialize(aluno)
    super(aluno)
  end
 
  def dedicacao
    rand
  end
 
  def inteligencia
    rand
  end
end
 
# => CLASSE PEMBA
class Pemba < Comportamento
 
  def initialize(aluno)
    super(aluno)
  end
 
  def dedicacao
    (rand/2)
  end
 
  def inteligencia
    (rand/2)
  end
end
# => CLASSE SAFO PREGUICOSO
class SafoPreguicoso < Comportamento
 
  def initialize(aluno)
    super(aluno)
  end
 
  def dedicacao
    (rand/2)
  end
 
  def inteligencia
    1
  end
end
# => CLASSE SUMMA
class Summa < Comportamento
 
  def initialize(aluno)
    super(aluno)
  end
 
  def dedicacao
    1
  end
 
  def inteligencia
    1
  end
end
 
# => CLASSE RELATORIO
class Relatorio
  attr_reader :aluno, :qualidade, :originalidade
 
  def initialize(qualidade, originalidade, aluno)
    @qualidade = qualidade
    @originalidade = originalidade
    @aluno = aluno
  end
 
end
 
# => CLASSE RELAQUEUE
class RelaQueue
 
  def initialize
    @array = []
  end
 
  def queue(obj)  
    @array.push(obj)
  end
 
  def dequeue
    @array.shift
  end
 
end
 
# => CLASSE PROFESSOR
class Professor
 
  def initialize(queue)
    @queue = queue
  end
 
  def corrigir_relatorio(rela)
    nota = (rela.qualidade + rela.originalidade + rand)*10/3
  end
 
  def corrigir_relatorios
    i = 1
    while( (rela = @queue.dequeue) != nil )
      puts "Relatorio #{i}: " + rela.aluno.nome + " obteve nota " + self.corrigir_relatorio(rela).to_s
      i += 1
    end
  end
 
end

Como resultado de uma breve simulacao do programa, obteve-se o seguinte resultado:

Simulador.jpg

Como resultado dos testes, obteve-se o seguinte resultado:

Testes.jpg

Conclusão

Percebeu-se nesta prática de laboratório que a linguagem dinamica tem algumas características que se mostram vantajosas em relacao ao tradicional padrao estático: é mais ágil na elaboracao do código, nao necessita tanta burocracia, pois a programacao já foi pensada para ser o mais generalista possível, ao contrário das linguagens estáticas, que, de modo geral, prezam pela restrição.
O tamando do código em Ruby ficou nitidamente menor do que em Java, justamente pela agilidade conferida por linguagens dinamicas. A legibilidade em Ruby, no meu ponto de vista, é considerada satisfatória.
Porém, é válido notar que, para quem está iniciando em linguagem dinamica e tem alguma experiencia nas estáticas, se sente bastante inseguro e as vezes até meio perdido nesse começo de aprendizado. Mas com um pouco de prática, começa-se a entender algumas das práticas comuns no meio dinamico e é possível se adaptar a esta nova abordagem. Mas de todo modo, até este ponto do aprendizado, ainda me sinto mais seguro e eficiente em linguagens como Java.

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