Problema Inicial:

Devemos criar um  método que seja capaz de percorrer um array, exibindo seus elementos. (Ok, tudo bem nós sabemos que todo array possui um método each. Mas vamos fingir que esse kra não existe)

lista = ["sergio","roberto", "iuri","luiz"]
def mostra_elementos( array )
  for elemento in array
    puts elemento
  end
end
mostra_elementos(lista)

Ótimo! Atingimos nosso objetivo. O codigo acima exibira os nomes contidos no array.

Os requisitos mudaram:

Agora nós queremos  percorrer o array exibindo cada um de seus elementos ao contrario, por exemplo, "sergio" será exibido como "oigres". Podemos criar um novo método para isso, então vamos ao trabalho:

<span id="more-451"></span>def mostra_elementos_ao_contrario( array )
  for elemento in array
    puts elemento.reverse
  end
end
mostra_elementos_ao_contrario( lista )

Perfeito! Mais uma vez concluímos nossa tarefa.

DRY, mais um princípio de Desenvolvimento de Software:

Os problemas anteriores envolviam operações com elementos de um array (uma lista), e assim acabamos criando dois métodos para resolver os problemas propostos. Existe um princípio de desenvolvimento de software que é focado em reduzir a repetição/duplicação de código, ele é conhecido como: Don't Repeat Yourself - (DRY). Este principio diz que:

"Every piece of knowledge must have a single, unambiguous, authoritative representation within a system."

O que poderiamos traduzir como: "Cada parte do conhecimento deve ter uma representação única e não ambigua dentro de um sistema". Desta forma utilizando o DRY para analisar as funções que escrevemos até agora, podemos notar que a parte do conhecimento de percorrer um array não possui uma representação única em nosso sistema. O ideal seria que o codigo de percorrer um array nao fosse mais repetido, e é exatamente nisso que vamos trabalhar agora.

Aplicando o DRY

A maneira mais simples de resolvemos o problema de duplicação do codigo de percorrer o array, é sem duvida realizar um refactor chamado extract method, e assim isolar a lógica de percorrer arrays em um método. Entao vamos lá:

def percorre_array( array )
  for elemento in array
 
  end
end
def mostra_elementos( array )
   percorre_array( array)
   puts elemento
end
def mostra_elementos_ao_contrario( array )
  percorre_array(array)
  puts elemento.reverse
end
lista = ["sergio","roberto", "iuri","luiz"]
mostra_elementos(lista)
mostra_elementos_ao_contrario(lista)

Pronto! Com este método que acabamos de criar eliminamos o problema de  repetição de código. Porém ao executar este programa receberemos uma mensagem de erro. O grande problema aqui é que agora os métodos mostra_elementos e mostra_elementos_ao_contrario não conseguem mais acessar cada elemento do array. Estes métodos agora usam a função percorre_array, e somente dentro desta função é que a variavel elemento existe. Neste ponto podemos pensar que, ou fazemos a coisa ficar DRY, ou fazemos o programa funcionar. Calma, com Ruby nos poderemos fazer isso funcionar e ainda ser DRY. Para isso só precisamos aprender a usar os famosos blocos do Ruby.

Ruby block's

Com certeza você já ouviu, que tudo em ruby é objeto. Na verdade mesmo, quase tudo em Ruby é objeto, por exemplo blocos de código não são objetos. Mas o importante é  que  em Ruby podemos armazenar trechos de código em um objeto especial que se chama Proc. Veja:

bloco = Proc.new { puts "sou um bloco de codigo" }
bloco.call

Acabamos de criar um objeto, que contem código, e fizemos isso utilizando Proc.new e fornecendo o código através das chaves  "{ }". De posse de uma Proc, podemos executar o código que ela contem a qualquer momento. Basta pra isso usar o método call da Proc. No exemplo acima ao chamar bloco.call veremos o texto sou um bloco de codigo. O interessante disso é que agora podemos passar código como parametro, veja um exemplo:

def faco_o_que_mandar( block )
  block.call
end
bloco = Proc.new {puts "sou um bloco de codigo"}
faco_o_que_mandar(bloco)
faco_o_que_mandar Proc.new{puts "Mais um bloco"}

Mas podemos fazer como os rubistas fazem na maioria das vezes. Eles chamam a função e passam o bloco como parametro, para isso precisamos fazer uma pequena alteração em nossa função, basta colocar um & a frente do nome do nosso parametro. Outra coisa é que geralmente os rubistas utilizam a plavara yield ao invés de coisas como bloco.call, vamos mudar isso também:

def faco_o_que_mandar( &block )
  yield
end
faco_o_que_mandar {puts "sou um bloco de codigo tipo rubista"}
faco_o_que_mandar do
  puts "blocos do end sao usados quando vc quer"
  puts "fazer coisas que precisem de mais de uma"
  puts "linha =)"
end

O grande barato é que agora escrevemos uma função que recebe e executa um código "visitante". Este é um recurso muito poderoso, e é graças a ele que vamos conseguir resolver o problema de percorrer um array para fazer coisas diferentes com seus elementos, sem precisar repetir código.

Tirando vantagem dos blocos

Bem, nós já temos uma função que sabe andar em um array. Agora só precisamos fazer esta função receber um bloco de código "visitante" e assim teremos tudo resolvido. Vamos então ao trabalho:

def percorre_array( array, &block )
  for elemento in array
    yield
  end
end
lista = ["sergio","roberto", "iuri","luiz"]
percorre_array(lista) { puts elemento }
percorre_array(lista) { puts elemento.reverse }

Neste momento você pode estar se perguntando o porquê do bloco de código estar fora dos parênteses. Por mais estranho que possa parecer é desse jeito que funciona mesmo. Os blocos são informados depois dos parametros "convencionais".

Agora seria ótimo se isso funcionasse, não é? Pena que não vai funcionar. Ao executar esse código veremos o seguinte erro: undefined local variable or method `elemento' for main:Object (NameError).

Repare no erro, ele diz que a variavel elemento não está definida. Isso aconteceu porque esta variavel é local do método percorre_array, ou seja só existe, e só é visivel naquele método. Nós precisamos manipular esta variavel, para que isto seja possível o método que possui a variavel precisa permitir que os blocos visitantes utilizem esta variavel. Fazer isso é simples, basta que no yield nos passemos a variavel em questão como parâmetro.

Quando colocamos o  yield na função é como se dissesemos: "Rode o codigo visitante agora". E quando colocamos a frente do yield parâmetros é como se dissessemos: "Ei código vistante, se você quiser pode usar estes caras aqui que eu tenho". Vejamos como fica isso no nosso codigo:

def percorre_array( array, &block )
  for elemento in array
    #agora estamos expondo a variavel elemento
    # para o codigo visitante
    yield elemento
  end
end
lista = ["sergio","roberto", "iuri","luiz"]
# uma pequena alteracao é necessaria aqui
percorre_array(lista) { |elemento| puts elemento }
percorre_array(lista) do |elemento|
  puts elemento.reverse
end

Agora sim o código funciona. A linha yield elemento, tem o efeito de enviar para o bloco visitante a variavel elemento como parametro. Assim a cada iteracao do loop for um novo valor é enviado ao código visitante através da variavel elemento. Com isso nosso trabalho está terminado, implementamos as funcionalidades solicitadas, sem repetir código, e de quebra aprendemos sobre DRY e blocos de código em Ruby.

Bloco de código é um assunto bem interessante, e aqui nós abordamos só uma pequena parte. Tem ainda um lance de lambdas, enfim como disse antes o assunto é muito interessante, e se você quiser saber mais pode olhar um post do Anderson Leite sobre isso, o link é este.

Abraços.

O Restfulie teve sua versão original implementada em ruby e logo depois foi lançada a versão para Java, mas ainda não havia nenhuma versão para .Net. Foi então que eu e o Sergio Junior aqui do blog resolvemos escrever uma versão para C# da api.
Começamos a implementar a parte cliente do Restfulie e fizemos isto utilizando as características dinâmicas da versão 4.0 do C#.
A idéia é que podemos fazer o client em C# bem próximo da idéia inicial que foi escrita em Ruby.

Aqui vamos mostrar alguns exemplos de utilização desta versão em C#.
Um recurso Pedido pode ter sua representação em xml como a que segue:

<pedido>
        <data>26/12/2009 11:40</data>
        <total>300.00</total>
	<atom:link rel="refresh"
          href="http://www.caelum.com.br/pedidos/1"
          xmlns:atom="http://www.w3.org/2005/Atom"/>
        <atom:link rel="update"
          href="http://www.caelum.com.br/pedidos/1"
          xmlns:atom="..."/>
        <atom:link rel="pagar"
		  href="http://www.caelum.com.br/pedidos/1/pagar"
          xmlns:atom="..."/>
        <atom:link rel="excluir"
          href="http://www.caelum.com.br/pedidos/1
          xmlns:atom="..."/>
         <atom:link rel="GetCliente"
          href="http://www.caelum.com.br/pedidos/1/cliente
          xmlns:atom="..."/>
</pedido>

Respare que a representação deste recurso além de conter  os dados do recurso, possui também  todas as possíveis transições de estado do recurso.
Além  disso, ainda é possível seguir os links e obter outros recursos relacionados: este é o conceito de Hipermedia tanto utilizado na web humana.

Utilizando o Restfulie client C#

Primeiro começamos fazendo o download da DLL e então para obter a representação de um recurso em C#, podemos utilizar algo bem parecido com ruby, o acesso a um entry point:

dynamic  pedido = Restfulie.At(“www.caelum.com.br/pedidos/1.xml”).Get();

Uma vez com a representação do recurso em mãos, podemos obter as informações do mesmo e seguir seus links.

Console.WriteLine(
   string.format(“O valor total do pedido é:{0}”, pedido.Total ) );
Console.WriteLine(
   string.format(“A data do pedido é: {0}”, pedido.Data) );

É possível invocar métodos e alterar o estado do pedido, além de navegar em suas relações com outros recursos.

   pedido.Pagar();
   pedido.Cancelar();
   pedido.Excluir();

Estas chamadas de métodos são remotas, baseadas nos links fornecidos pelo xml e nos protocolos http e media types bem conhecidos.
Para recuperar um recurso relacionado através dos links:

  dynamic cliente = pedido.GetCliente();
  Console.WriteLine(
     string.format(“Nome do cliente {0}”, cliente.nome));

Ainda podemos obter as informações sobre sua resposta web, para analisar headers ou response codes:

  Console.WriteLine(pedido.WebResponse.StatusCode);

As vezes a representação xml do recurso pode conter tags com o caracter “-”.
Por exemplo:

<city>
    <name>Sao Paulo</name>
    <population>
         <size>18000000</size>
         <growth>10</growth>
    </population>
    <updated-at>10/01/2010</updated-at>
    <link rel="next_largest" href="http://localhost:3000/cities/18.xml" />
</city>

Obtendo o recurso:

dynamic city = Restfulie.At(“http://localhost:3000/cities/17.xml”).Get();

Acessando o atributo “update-at”:

  Console.WriteLine(
     string.format(“A data de atualização é {0}”,city.Update_At));
  Console.WriteLine(
     string.format(“População {0}”, city.Population.size));

Note que em na vesão C#, não acessamos o atributo update-at com caracter “-”, este é substituído por “_”. Então quando for necessário acessar um atributo ou método que utilize o “-”, substituída por “_”.
Com as novas capacidades dinâmicas do C# 4.0, conseguimos atingir um resultado bem próximo ao que é possível na versão ruby.
Aqui segue um comparativo básico:

Em Ruby:

  pedido = Restfulie.at(“http://restfulie-test.heroku.com/orders/14”).get
  puts pedido.customer-name
  pedido.cancel

Em C#

  pedido = Restfulie.At(“http://restfulie-test.heroku.com/orders/14.xml”).Get();
  Console.WriteLine(pedido.customer_name);
  pedido.Cancel();

Por enquanto só temos a versão do client em C#. Ainda falta uma série de features a serem implementadas. No site do projeto, tem uma lista de coisas que necessitam de ser feitas no cliente
para que ele fique tão maduro quanto as versões em ruby ou Java. Vamos continuar trabalhando no cliente para isso.

Se você está interessado em ajudar neste projeto, deixe um comentário ou mande um e-mail para nós.

Para saber mais:

http://github.com/caelum/restfulie-csharp
http://restfulie.caelumobjects.com/

Para saber mais sobre as idéias por trás do Restfulie, segue o link do artigo na infoq.
http://www.infoq.com/articles/webber-rest-workflow

Até a Próxima
Luiz Costa
Sérgio Júnior.

Para analizar um código, assim como qualquer outra coisa, nós precisamos de parâmetros. Precisamos nos basear em algo que saibamos que seja bom, para assim podermos determinar se outra coisa é tão boa quanto, melhor, ou até pior.

Com código não é diferente. Então antes de respondermos a pergunta feita no inicio deste texto, precisamos definir o que é um código bom, ou melhor, que caracteristicas deve ter um codigo para ser considerado bom. Vamos agora recorrer a alguns principios OO para nos municiar de paramêtros para assim julgarmos o codigo em questão

Robert Martin, o uncle Bob, escreveu a muito tempo sobre os principios OO num documento chamado: PrinciplesOfOod. Dos principios OO descritos neste artigo, pelo menos 5 ficaram bastante famosos, e são conhecidos pela sigla SOLID, são eles:

Single Responsibility Principle (SRP) - A classe deve ter uma única responsabilidade, uma única razão de existir.

Open Closed Principle (OCP) - A classe deve ser aberta para extensão (sublcasses e sobrescrita de metodos) e fechada para modifiação *

Liskov Substitution Principle (LSP) - Resumidamente ele serve para nos aletar para heranças sem sentido.

Interface Segregation Principle (ISP) - Defende que uma classe deve depender apenas dos métodos que usa de uma outra classe. Interfaces são um mecanismo para isso.

Dependency Inversion Principle (ISP) - Defende que componentes maiores devem depender não de componentes menores, mas sim de uma abstração deles.

*Pode ser discutido, principalmente se você estiver trabalhando em um modelo de dominio incremental, ou seja, você vai descobrindo as necessidades de suas classes durante o desenvolvimento de software. Neste cenário o principio OCP pode ser radical demais. Lembre-se é preciso ter bom senso.

Dos principios descritos por Robert Martin, ficaremos apenas com o SRP. Sabendo agora que uma classe deve possuir apenas uma úncia responsabilidade. Quantas responsabilidades podemos identificar na classe Principal do post anterior?

Podemos identificar facilmente 3 responsabilidades. São elas:

1 - Controla a execução da aplicação.

2 - Cadastra um novo DVD

3 - Lista todos os DVD's cadastrados

Agora ficou facil ver que a classe Principal está ferindo o SRP. A resposabilidade desta classe deveria ser apenas: Controlar a execução da aplicação. Precisamos retirar da classe Principal as demais responsabilidades. Como faremos isso?

A melhor solução é remover todo o código "extra" da classe Principal. Mas o grande problema, é que sem esse codigo nossa aplicação vai parar de funcionar! Este código não pode simplesmente desaparecer. O que nós precisamos fazer e leva-lo para outro lugar. E como estamos programando segundo o paradigma de Orientação a Objetos, vamos precisar de novas classes para cada uma das responsabilidades descritas acima.

Teriamos as seguintes classes com as seguintes responsabilidades:

Classe: Principal

Responsabilidade: Controlar a execucao da aplicação

Classe: CadastrarDvd

Responsabilidade: Cuidar da lógica de inclusao de um dvd

Classe: ListarTodosDvds

Responsabilidade: Cuidar da lógica de exibicao dos dvd's

Após estas alterações vamos perceber que a classe Principal ficou bem melhor.

Mas será que isso foi suficiente? Apenas esta alteração terá salvado a vida de nossa pequena aplicação?

Tente aplicar você mesmo o SRP em nossas novas classes e comente a respeito. No proximo post continuamos nossa saga.

Abraços.

Sergio Azevedo Junior

Confira abaixo como ficaram nossas classes:

Principal

public class Principal {
  public static void main(String[] args) throws IOException {
    Scanner scan = new Scanner(System.in);
    int opcao = 0;
    do {
      System.out.println("--------------- Controle de Dvds e Cds ---------------");
      System.out.println("   1 - Cadastrar Novo Dvd ");
      System.out.println("   2 - Listar Dvd's ");
      System.out.println("   3 - Terminar ");
      System.out.println("------------------------------------------------------");
      System.out.println(" Escolha uma opção:--> ");
 
      opcao = scan.nextInt();
      switch (opcao) {
      case 1: {
        new CadastraDvd().executa();
        break;
      }
      case 2: {
        new ListaTodosDvds().executa();
        break;
      }
      }
    } while (opcao < 3);
  }
}

CadastraDvds

public class CadastraDvd {
 
  public void executa() throws IOException {
    PrintStream ps = null;
    File file = new File("Dvds.txt");
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    try {
      ps = new PrintStream(file);
 
      Dvd dvd = new Dvd();
      System.out.println("Titulo.: ");
      dvd.setTitulo(br.readLine());
      System.out.println("Sinopse: ");
      dvd.setSinopse(br.readLine());
      System.out.println("Genero.: ");
      dvd.setGenero(br.readLine());
      System.out.println("Ano....: ");
      dvd.setAno(br.readLine());
      System.out.println("Duracao: ");
      dvd.setDuracao(br.readLine());
 
      ps.println(dvd.getTitulo());
      ps.println(dvd.getSinopse());
      ps.println(dvd.getGenero());
      ps.println(dvd.getAno());
      ps.println(dvd.getDuracao());
    } finally {
      br.close();
      if (ps != null)
        ps.close();
    }
  }
}

ListaTodosDvds

public class ListaTodosDvds {
  public void executa() throws FileNotFoundException {
    System.out.println("------------- Lista de Dvd's -------------");
    Scanner reader = new Scanner(new File("Dvds.txt"));
    while (reader.hasNext()) {
      System.out.println(reader.nextLine());
    }
    reader.close();
  }
}

Bom artigo amigo, porém penso que esteja havendo alguma confusão sobre o que é “tipagem forte” e o que é “type casting implícito”, em minha opinião a linguagem é fracamente tipada, haja visto que se pode atribuir uma referência de qualquer TIPO de objeto a uma variável, porém a linguagem não realiza o TypeCasting de tipos de forma implícita e arbritária como caso de algumas “Linguagens Chatas” (tomei a liberdade de utilizar seu termo…).

Como o post era antigo acabei demorando para ver o comentário e consequentemente enviar uma respota, porém o comentário aborda um assunto tão interessante, que resolvi escrever um post para esclarecer o assunto, por tanto gostaria antes de mais nada  agradecer o seu comémtario, e aqui vai a minha resposta

O Fato de não precisar definir um tipo para uma variavél, não é necessáriamene uma caracterísica de uma tipagem fraca, pois quando estamos atribuindo algo a uma variável, estamos apenas passando uma refêrencia, por exemplo:

nome = "Iuri"
puts nome
>> "Iuri"

O que eu fiz no exemplo acima, foi atribuir a instancia de um objeto do tipo string a variavel nome, não preciso dizer que a variavel nome é do tipo string, isso é uma característica de uma linguagem dinâmica. porém as vezes as pessoa confundem isso com tipagem fraca por causa do exemplo abaixo:

 nome = "Iuri"
 puts nome
>> "Iuri"
 nome = 1
 puts nome
>> 1

Nesse exemplo o que eu fiz foi atribuir a referência de um objeto string "Iuri" para a variavel nome, imprimir seu valor na tela, em seguida atribui a referência de um objeto FixNum 1 para o varivel nome e imprimir o seu valor. O fato de eu conseguir passar um valor string para uma variavel e em seguida um valor FixNum, não quer dizer que a minha linguagem tem tipagem fraca, ruby tem tipagem implicita o que é bem diferente de tipagem fraca, o minha variavel apenas trocou de referência no processo acima e por ela ser dinâmica automaticamente trocou de tipo.
Agora vamos ver outro exemplo para provar de vez que Ruby possui tipagem forte:

nome = "Iuri"
soma = nome + 1
>> TypeError: can't convert Fixnum into String

Viu?? deu erro!
Isso por que Ruby tem tipagem forte, eu não posso somar um objeto do tipo string com um objeto do tipo FixNum. Isso é tipagem forte
Se excutarmos o mesmo algoritimo em javascript ,que esse sim possui tipagem fraca, o resultado seria bem diferente:

  nome = "Iuri"
  soma = nome + 1
  document.write(soma)

O resultado desse exemplo será Iuri1

Referencias:

http://en.wikipedia.org/wiki/Type_system#Duck_typing

http://en.wikipedia.org/wiki/Type_system#Dynamic_typing

http://en.wikipedia.org/wiki/Type_system#Strong_and_weak_typing

Depois de ler livros, ou fazer cursos, essas "dificuldades operacionais" desaparecem, afinal aprendemos a usar melhor a linguagem e passamos a conhecer melhor suas apis. Nesse ponto já somos capazes de por exemplo converter um String em um numero, criar e organizar listas de elementos, usar arquivos para realizar operações de leitura e escrita.

Uma vez que já sabemos criar aplicações em Java, precisamos nos perguntar outras coisas:

• "As aplicações que criamos foram constuidas da melhor maneira possível?"
• "Meu código está orientado a objetos, ou é apenas procedural Java?"
• "Como eu identifico o que deve e o que nao deve ser uma classe no meu sistema?"

A boa noticia é que estas perguntas possuem respostas. A má noticia é que eu não vou dar todas as respostas de bandeja a vocês. Ao invés disso vamos aprender a ter "senso critico" sobre o código que escrevemos. Para isso vamos começar simplesmente criando uma pequena e simples aplicação Java para cadastro e consulta de Dvd's.

Em geral, nos preocupamos primeiramente em escrever uma aplicação que funcione, e talvez esta atitude nos leve a não ter uma aplicação bem construida. Existem várias "desculpas" que podemos utilizar para justificar esse tipo de construção, mas dentre elas destacam-se as classicas: "nao tenho tempo" e "o cronograma está apertado". =)

Nesta primeira etapa estamos interessados em escrever uma aplicação que funcione. ( Talvez porque estejamos sem tempo =p )

Bem, para isso nos vamos precisar da classe Dvd, entao:

public class Dvd {
	private String titulo;
	private String sinopse;
	private String genero;
	private String ano;
	private String duracao;
	private boolean emprestado;
        //Gets e Sets
}

Agora vamos a nossa classe "principal":

public class Principal {
	public static void main(String[] args) throws FileNotFoundException {
		Scanner scan = new Scanner(System.in);
		int opcao = 0;
		do {
			System.out
					.println("--------------- Controle de Dvds e Cds ---------------");
			System.out.println("   1 - Cadastrar Novo Dvd ");
			System.out.println("   2 - Listar Dvd's ");
			System.out.println("   3 - Terminar ");
			System.out
					.println("------------------------------------------------------");
			System.out.println(" Escolha uma opção:--> ");
 
			opcao = scan.nextInt();
 
			switch (opcao) {
			case 1: {
				BufferedReader br = new BufferedReader(new InputStreamReader(
						System.in));
				PrintStream ps = new PrintStream(new File("Dvds.txt"));
				try {
					Dvd dvd = new Dvd();
					System.out.println("Titulo.: ");
					dvd.setTitulo(br.readLine());
					System.out.println("Sinopse: ");
					dvd.setSinopse(br.readLine());
					System.out.println("Genero.: ");
					dvd.setGenero(br.readLine());
					System.out.println("Ano....: ");
					dvd.setAno(br.readLine());
					System.out.println("Duracao: ");
					dvd.setDuracao(br.readLine());
 
					ps.println(dvd.getTitulo());
					ps.println(dvd.getSinopse());
					ps.println(dvd.getGenero());
					ps.println(dvd.getAno());
					ps.println(dvd.getDuracao());
					ps.close();
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				break;
			}
			case 2: {
				System.out
						.println("------------- Lista de Dvd's -------------");
				Scanner reader = new Scanner(new File("Dvds.txt"));
				while (reader.hasNext()) {
					System.out.println(reader.nextLine());
				}
				reader.close();
			}
			}
		} while (opcao < 3);
	}
}

É isso ai gente! Nossa aplicação está pronta e funcionando. Porém eu faço a vocês duas perguntas:
Este codigo está bom? Porque?

No proximo post, vamos analisar este codigo responder a estas perguntas. Porém você que leu este post nao precisa esperar, pode escrever seu comentario aqui respondendo esta pergunta.

Abraços,
Sergio Junior

Confira a sequencia deste post aqui.

Acho que isso a maioria das pessoas já sabia, mas o que tenho visto por aí em projetos que trabalhei é exatamente o contrário: um modelo de objetos exatamente igual ao modelo de dados.

Por que ainda utilizamos uma abordagem assim?
Em minha opinião, o principal problema é que muitos desenvolvedores ainda não entenderam corretamente Orientação a Objetos. A prova disso são os sistemas escritos de forma totalmente procedural.

Tentarei exemplificar algumas destas diferenças. Este exemplo é uma adaptação de um problema real que eu presenciei. Vamos imaginar um sistema de cursos onde nós temos as tabelas:

Curso
id
nome
data Inicio
data Fim
idInstrutor

Instrutor
id
nome

Esta é uma simplificação, mas vai ajudar a explorar o problema.
A abordagem comum que eu tenho visto é ter um modelo de objetos que represente as tabelas do banco de dados, pois é necessário persistir as informações destes objetos. Para persistência, em java podemos utilizar o Hibernate/JPA, em Rails podemos utilizar o framework Active Record (que aliás, te induz a fazer exatamente o que eu descrevi acima) e em C# podemos utilizar o NHibernate.

Vamos ver algum código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Curso{
    private int id;
    private String nome;
    private Date dataInicio;
    private Date dataFim;
    private Instrutor instrutor;
 
     ..gets e sets
}
 
public class Instrutor{
    private int id;
    private String nome;
 
    .. gets e sets
}

Em um primeiro momento, não há nada de errado com esta abordagem, certo? Apesar de nosso modelo de objetos refletir exatamente nossas tabelas no banco de dados, ele parece razoável.

Neste sistema, ao cadastrar um curso, temos que assegurar que não existe sobreposição de datas entre cursos com o mesmo instrutor. Exemplo:

Curso: Orientação a Objetos
Instrutor: Zé Bedeu
período: 18/07/2009 até 10/08/2009

Curso: Java
Instrutor: Zé Bedeu
período: 25/07/2009 até 20/08/2009

Reparem que estes dois cursos vão se sobrepor em algum momento. Até o dia 24/07/2009 o Zé Bedeu está ministrando o curso de OO e a partir de 25/07 ele também estará ministrando o curso de Java. Isso pode até fazer sentido, mas no nosso sistema de cursos isso não pode acontecer.

Então o que podemos fazer para evitar isso?
Podemos criar uma verificação para não deixar o mesmo instrutor ser alocado para outro curso se ele já tem aulas previstas dentro daquele período.

Para validar esta regra de negócio, poderíamos escrever um teste:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

@Test
public void naoDeveSerPossivelTerDoisCursosParaUmInstrutorEmPeriodosSobrePostos(){
    // para simplicar, vamos utilizar strings para as datas
    // utilizando um buider.
    Curso oo = Curso.de("Orientacao a Objetos")
                               .comInstrutor("Ze Bedeu")
                               .comecandoEm("18/07/2009")
                               .ate("25/07/2009")
                               .Build();    
 
    Curso java = Curso.de("Java")
                               .comInstrutor("Ze Bedeu")
                               .comecandoEm("25/07/2009")
                               .ate("20/08/2009")
                               .Build();
 
     boolean existeSobrePosição =
                           DataUtils.existeSobrePosicaoDeDatas(
                                          oo.getDataInicio,
                                          oo.getDataFim,java.getDataInicio,
                                          java.getDataFim);
    assertFalse(existeSobrePosicao,
                   "não deve haver dois cursos com períodos sobrepostos");
}

Nosso teste faz a validação da regra de negócio, mas tem um problema nesta abordagem. Quem faz a verificação de datas é um objeto totalmente separado do nosso domínio. Reparem que o objeto DataUtils tem um método estatico que recebe 4 parâmetros. Podemos melhorar este exemplo atribuindo a responsabilidade de validar sobreposição para a classe curso, já que é ele quem tem as informações do período.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Curso{
    private int id;
    private String nome;
    private Date dataInicio;
    private Date dataFim;
    private Instrutor instrutor;
 
     ..gets e sets
 
    public boolean estahNoMesmoPeriodo(Curso outroCurso){
      return  DataUtils.existeSobrePosicaoDeDatas(
                                           this.getDataInicio(),
                                           this.getDataFim(),
                                           outroCurso.getDataInicio(),
                                           outroCurso.getDataFim());
 
    }
}

Vamos refatorar nosso teste:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

@Test
public void naoDeveSerPossivelTerDoisCursosParaUmInstrutorEmPeriodosSobrePostos(){
    // para simplicar, vamos utilizar strings para as datas
    // utilizando um buider.
    Curso oo = Curso.de("Orientacao a Objetos")
                               .comInstrutor("Ze Bedeu")
                               .comecandoEm("18/07/2009")
                               .ate("25/07/2009")
                               .Build();
 
    Curso java = Curso.de("Java")
                               .comInstrutor("Ze Bedeu")
                               .comecandoEm("25/07/2009")
                               .ate("20/08/2009")
                               .Build();
 
    boolean existeSobrePosição = oo.estahNoMesmoPeriodo(java);
    assertFalse(existeSobrePosição,
                    "não deve haver dois cursos com períodos sobrepostos");
}

Começou a melhorar, repare que agora o próprio curso sabe validar se está no mesmo período de outro. Isso é começar delegar responsabilidades para os objetos de domínio, e evitar de se ter objetos fantoches. Nosso modelo de objetos deve ser rico e não anêmico.

Mas ainda temos algo pra melhorar. Existe um conceito que sempre falamos aqui até agora e ainda não foi explorado. Este conceito é o "Período". Mas o que é o Período?
O período nada mais é que uma representação do tempo transcorrido entre duas datas.

Um curso ocorre em um Período. Se vocês observarem a classe curso, temos data inicial e data final. O que temos na verdade é um período, e este conceito está implícito nesta classe. Em uma boa modelagem de objetos, nós temos que tornar os conceitos explícitos. Para isso podemos refatorar a classe curso e criar a classe período. Podemos também refatorar o método existeSobrePosicaoDeDatas da classe DataUtils para utilizar um período.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Periodo{
    private Date dataInicio;
    private Date dataFim;
}
 
public class Curso{
    private int id;
    private String nome;
    private Periodo periodo;
    private Instrutor instrutor;
 
     ..gets e sets
 
    public boolean estahNoMesmoPeriodo(Curso outroCurso){
     return  DataUtils.existeSobrePosicaoDeDatas(
                                this.getPeriodo(),
                                outroCurso.getPeriodo());
 
    }
}

Agora a classe Curso na verdade tem um Período. Mas qual a vantagem de se ter o Período ao invés da data Inicio e data Fim? A vantagem é que período agora é uma classe, pode ter responsabilidades, pode tirar vantagens dos conceitos de OO. Além disso este período é altamente reutilizável por várias classes, qualquer uma que precisar do conceito de período pode utilizá-lo.

Mas ainda podemos melhorar mais. Na verdade quem tem a reponsabilidade de verificar se um período sobrepoe outro é o próprio período. A classe período é que sabe quem são as datas de início e de fim. Logo podemos fazer mais um refactoring atribuir a responsabilidade a classe período.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Periodo{
    private Date dataInicio;
    private Date dataFim;
 
   public Periodo(Date dataInicio, Date DataFim){
      this.dataInicio = dataInicio;
      this.dataFim = dataFim;
   }
 
    public boolean estahNoMesmoPeriodo(Periodo outroPeriodo){
      /// código de validação
    }
 
    public int quantidadeDeDias(){
      // código
    }
    .. gets
}
 
public class Curso{
    private int id;
    private String nome;
    private Periodo periodo;
    private Instrutor instrutor;
 
     ..gets e sets
 
    public boolean estahNoMesmoPeriodo(Curso outroCurso){
     return  this.getPeriodo().estahNoMesmoPeriodo(
                outroCurso.getPeriodo());
    }
}

Após este refactoring, podemos observar algumas coisas:

• A classe período tem um construtor que recebe 2 datas e não tem sets. Não faz sentido você instanciar um objeto período sem data de inicio e data de fim, pois ele (o objeto período)ficararia em um estado inválido.
• A classe período agora é quem sabe validar sobreposição de datas.
• A classe período agora também sabe dizer quantos dias tem no período, já que ela conhece o início e o fim.
• A classe curso agora somente delega a responsabilidade para a classe período validar as datas.
• E o mais importante, eliminamos a necessidade da classe DataUtils. Uma classe como essa é sintoma de um código procedural. A classe dataUtils tem somente procedimentos que lidam com dados separados. A grande sacada de Orientação a Objetos é colocar junto Dados + Operações sobre estes dados.

Agora voltando ao assunto do início do tópico. A classe período não tem necessidade de ser persistida, ela é apenas um Value Object. Os dados da classe período podem ser persistidos junto com a tabela curso. Mas isso não nos limita a ter uma classe que representa um conceito do domínio.
Com JPA vc pode fazer isso facilmente utilizando anotações @Embeddable.

A utilização de uma Fluent Interface nos testes foi de propósito, pois pretendo voltar ao assunto logo logo aqui no blog.

Valeu pessoal,

Luiz Costa

1) jQuery é um FrameWork JavaScript, que utiliza uma DSL simples e objetiva, que ajuda o desenvolvedor a abstrair uma grande quantidade de código que não fazem parte da lógica no seu negocio, como problemas de compatibilidade de navegadores por exemplo.

2) Alem disso tem uma grande capacidade de manipular elementos de uma página com pouco código.
Exemplos:
Deixar um elemento invisível:

1

  $("#id_do_meu_elemento").hide();

Manipular o css de um elemento:

1

  $("#id_do_meu_elemento").css("background-color","Blue");

Manipular o conteúdo de um elemento:

  $(p).append("inserindo esse conteúdo em todos os parágrafos");

A lista e exemplos que poderia exibir aqui é enorme, mas esse não é o foco no momento

3) Possibilita uma grande reutilização de código através de plugins.
Exemplo: podemos criar um código para validar campos numéricos, uma função chamada "validaNumeros()".
Agora vamos supor que você possua um formulário com 8 campos do tipo numérico, ao invés de você replicar esse código no evento "onkeypress" de cada input do seu formulário, você pode transformar esse função em um plugin e no carregar da página, você simplesmente escreve o seguinte código:

1
2

  $(".campo_numerico").validaNumeros();
 //.campo_numerico seria a classe css atribuída aos inputs.

4)Atualmente existem uma quantidade enorme de plugins, disponíveis na internet que nos facilita em N tipos de tarefas e que economizam nosso tempo de escrever linhas e linhas de código javascript, muita das vezes para simplesmente fazer uma validação de formulário .

5) jQuery tem um ótimo suporte a Ajax.
Exemplos:
Carregar o conteudo de uma url em um determinado div.

1

  $("#id_do_meu_div").load("pagina_que_eu_quero_carregar.html");

Pegar um determinando valor via ajax e atribuir esse valor para um campo:

1
2
3

  $.get("retornavalor.php",function(valor) {
    $("#id_do_meu_imput").val(valor);
  });

Também temos suporte a JSON

1
2
3

  $.getJSON("retornavalor.php",function(objeto) {
    $("#id_do_meu_imput").val(objeto.valor);
  });

Nesse post, eu listei cinco motivos, mas tenho certeza que quando você começar a utilizar jQuery, nos seus projetos, você vai encontrar muito mais!

Pretendo escrever mais artigos, detalhando determinadas funcionalidades do jQuery , mas atualmente já existe bastante conteúdo disponivel sobre o assunto, no próprio site oficial temos uma documentação bem legal com bastante exemplos: http://docs.jquery.com.

Até a próxima!

Iuri Menescal

Estrutura

O Método em Ruby é declarado da seguinte forma:

1
2
3

def nomeDoMetodo
   #código
end

Só isso?
Não tenho que dizer o que ele retorna?
Ou dizer que ele não retorna nada "void" ?
É isso mesmo, no Ruby você não precisa definir o que o seu método retorna, também não temos obrigação de utilizar "return" o nosso método sempre vai retornar o ultimo valor atribuído.
É tão simples que deve ter ficado difícil de você visualizar:). Vamos ver um exemplo:

1
2
3
4
5
6
7

# criando um método chamado teste
def teste
  valor = 1
end
#chamando esse método
teste
=> 1

Parâmetros

O modo de passar parâmetros para um método em Ruby, é quase parecido com o das linguagens chatas:

1
2
3

 def nomeDoMetodo(parametro1,parametro2)
    valor = parametro1 + parametro2
 end

Ok! a similaridade com as linguagens chatas para por aqui.
Uma das coias legais de se trabalhar com uma linguagem dinamica é essa, note que não precisamos definir tipos para o parâmetro, isso nos da uma grande flexibilidade!
Você não acha?
Não!? e se eu disser para você que a flexibilidade não se limita a isso, e se eu disser que podemos também, passar um numero indeterminado de parâmetros para o nosso método?
você não acredita? vamos ver um exemplo então:

1
2
3
4
5
6
7
8
9
10

  # note como declaro o parâmetro no método
  def teste(*parametros)
    parametros.each { |parametro| puts parametro }
  end
  #chamando o método
  teste(1,2,3)
  1
  2
  3
  => [1,2,3]

Para finalizar esse post, vou dar um exemplo que os programadores Delphi vão adorar.

Caramba senti muita falta disso, quando comecei a programar em Java

Nos métodos em Ruby é possivel definir um valor default para o parâmetro. Heeeee!!!

1
2
3
4
5
6
7

  def teste(parametro="Não foi passado nenhum valor")
    parametro
  end
  teste("novo valor")
  => novo valor
  teste
  => Não foi passado nehum valor

pode falar... agora eu consegui te impressionar!

Por enquanto vamos ficar por aqui, mas ainda temos muito para ver sobre métodos em Ruby.
Aguardem o próximo post.

Abraço!

Iuri Menescal

Mas depois de publicar o último post, tive um retorno tão bom que fiquei empolgado em escrever outro logo .
Alem disso, fiquei com uma sensação de que estava faltando alguma coisa, como disse antes o foco não é mostrar os métodos de cada classe do Ruby, mas o Array em Ruby é tão maneiro que eu tinha que mostrar mais algumas coisas legais.

No post anterior eu disse que uma das coisas que me desanimou no Array, quando comecei a programar, era a dificuldade de recuperar os dados, então aqui vai mais alguns exemplos de como o Ruby resolve esse problema:

Ordenação

1
2
3
4
5
6
7

#o método sort ordena os valores em ordem alfabética
meuArray = %w(Alagoas Rio\ de\ Janeiro Brasília) 
=> ["Alagoas","Rio de Janeiro","Brasilia"]
#presto atenção na "\" para escrever algo com espaço dentro do mesmo item do array?
#agora vamos ordenar por nome
meuArray.sort
=> ["Alagoas","Brasilia","Rio de Janeiro"]

Grande coisa o exemplo acima, qual é a linguagem que não faz isso, né?
Então, vamos jogar um pouco do pó mágico do Ruby e deixar o próximo exemplo mais atraente.

1
2
3
4
5
6
7
8
9

meuArray = ["Alagoas","Brasilia","Rio de Janeiro"]
=> ["Alagoas","Brasilia","Rio de Janeiro"]
#olha o que podemos fazer acrescentando um bloco no final
#vamos ordenar ao contrario agora 
#mas lembre-se que você pode passar N condições 
#pois estamos trabalhando com blocos!
 
meuArray.sort {|x,y| y <=> x}
=> ["Rio de Janeiro", "Brasília", "Alagoas"]

Pesquisa

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

estados = ["RJ","MG","SP"]
=> ["RJ","MG","SP"]
#Quero confirmar se nesse Array 
#realmente existe o estado "Rio de Janeiro"
estados.include?("RJ")
=> true
 
#Agora queremos saber se algum item do meu array possui a letra "S"
estados.any? { |item| item.include?("S") }
=> true
#e se eu quiser saber se todos os itens do meu array possui a letra "S"?
#simples!
estados.all? { |item| item.include?("S") }
=> false
 
#quero separar do meu array os estados com letra "S"
estadosComS, estadosSemS = estados.partition { |item| item.include("S") }
estadosComS
=> ["SP"]
estadosSemS
=> ["RJ","MG"]

Olha só que linguagem linda! Notem a expressividade desse código: "include?"
Eu quero saber se o meu array de estados contem o estado "RJ". Se eu quero saber algo sobre o meu array, eu tenho que perguntar para ele e uma pergunta deve terminar com interrogação, então: estados.include?("RJ").

Pode falar... da vontade de congelar esse projeto, que você ta desenvolvendo ai na sua empresa e reescreve tudo em Ruby, não é? rs...

Mais uma vez utilizei bastante o conceito de blocos, que é um dos grandes baratos do Ruby.

Logo irão surgir outros conceitos que vão me obrigar a ter a mesma postura, no próximo post vamos ver um pouco sobre lambdas, que é um outro recurso bem bacana.
É importante fixar bem esses conceitos para programadores que vem de linguagens como Java, Delphi, C#, pois é mais difícil se acostumar com algo tão fora do trivial do seu dia a dia, é importante isso ficar na "veia", para que você consiga lembrar de utilizar esses tipos de recursos quando precisar. Tenho certeza que isso vai facilitar muito a sua vida quando estiver programando em Ruby.

Acho que agora deu para fechar com chave de ouro o nosso estudo sobre arrays.

Até a próxima!

Iuri

Acho que agora as coisas começam a ficar mais divertidas

Não é minha intenção, ficar explicando cada classe básica do Ruby, acho que mais importante focarmos no conceito da linguagem, acredito que a melhor forma de aprender a programar é praticando, por tanto vou usar alguns exemplos utilizando funcionalidades da String e do Array, para explicar os conceitos e ao mesmo tempo mostrar como é produtivo programar em Ruby.

Para entender os recursos de cada classe, basta olhar a documentação do Ruby que é bem abrangente.

Vamos ver alguns exemplos, de como podemos concatenar valores em uma string:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

variavel = "um dois tres"
variavel = variavel+" quatro cinco seis"
 
#pode ser assim também
variavel = "um dois tres"
variavel += " quatro cinco seis"
 
#Também podemos fazer assim
variavel = "um dois tres"
variavel.concat(" quatro cinco seis")
 
#ou melho ainda, esse é muito maneiro, o código fica claro!
variavel = "um dois tres"
variavel << " quatro cinco seis"
#alem de claro, esse tipo de atribuição é mais rápido.

Viu por que Ruby é agil?
- Até minha mãe entende que com esse simbolo "<<" estou inserindo uma valor na String
É claro que em java temos outros modos de concatenar valores em uma String, mas provavelmente alguns deles nos obriga a instanciar alguma classe utilitária como o StringBuilder, por exemplo.

Gostou? você ainda não viu nada, olha só que F0D@! :p

Delete

1
2
3
4
5
6
7
8

#aqui eu quero remover todas as vogais de uma String
"a b c d e f g h i ".delete "aeiou"
=> "b c d f g h"
 
#podemos utilizar exceções.
#vamos remover todas as vogais, exceto a vogal "i"
"a b c d e f g h i".delete "aeiou", "^i"
=> "b c d f g h i"

Quer ver mais?

#Conversão de case
"saga do programador".upcase
=> "SAGA DO PROGRAMADOR"
"SAGA DO PROGRAMADOR".downcase
=>"saga do programador"

#olha só que maneiro:
#veja como esse código é expressivo!
"saga do programador".include? "programador"
=> true
#é esse tipo de coisa q faz a diferença
#quero saber quantos caracteres diferentes existem entre as Strings
"Iuri" <=> "Iure"
=> 1
#agora eu quero tirar caracteres duplicados de uma String
"google".tr_s("o","o")
=> "gogle"
"google".tr_s("o","")
=> ggle

Arrays:

Na boa! Quando comecei a programar, aprendi sobre Arrays com o velho Pascal, achei muito chato. Pelas dificuldades apresentandas para recuperar os dados.

Com a evolução das linguagens as coisas foram melhorando, mas definitivamente trabalhar com Arrays em linguagens dinâmicas, supera as expectativas!

Vamos aos exemplos:

1
2
3
4

#Criando uma array em Ruby:
meuArray = [“um”, “dois”,3]
=> [“um”,”dois”,3]
#Sim é isso mesmo! Eu posso ter tipos diferentes dentro do mesmo Array

Olha com as coisas ficam ainda mais legais, quando nos aproveitamos das facilidades que a linguagem Ruby nos proporciona com o conceito de blocos:

1
2

meuArray = Array.new(2) {1}
=> [1,1]

Alguma vez você imaginou preencher um Array de maneira tão simples, como no exemplo abaixo:

1
2

meuArray = Array.new(5) {|n| n+1}
=> [1,2,3,4,5]

No post anterior eu finalizei com a seguinte pergunta:
Tenho uma String com seguinte valor “um dois tres quatro cinco”, como você faria em uma linguagem chata para transformar essa String em um array contendo cinco itens?

Bom, existe N maneires de fazer isso em N linguagens, meu exemplo de linguagem chata, será em delphi, vamos a roubada rs.. :

1
2
3
4
5
6
7
8
9
10

//Para facilitar, ao invés de utilizar um Array, vou usar a classe TStringList.
Var
  valor: String;
  listaValor: TStringList;
begin
  valor := 'um dois tres quatro cinco';
  listaValor := TStringList.Create;
  valor := StringReplace(valor,' ',',',[rfReplaceAll]);
  listaValor.CommaText := valor;
end;

Agora em Ruby:

1
2
3

#Preste atenção como é complexo rs...
meuArray = %w(um dois tres quatro cinco)
=> [“um”,”dois”,”tres”,”quatro”,”cinco”]

Outros exemplos:

1
2
3
4
5

#Sim! O operador "<<" também funciona para o Array</p>
meuArray = [1]
=> [1]
meuArray << 2
=> [1,2]

No incio desse topico sobre arrays, comentei que um dos grandes problemas de trabalhar com Arrays nas linguagens chatas, e a dificuldade para manipular os dados, vamos ver agora uma pequena amostra, das facilidades que o Ruby nos oferece para trabalhar com isso:

1
2
3
4
5
6

meuArray = [1,2,3,4,5]
=> [1,2,3,4,5]
 
#Retornar só os numero pares, mais uma vez vou me prevalecer do conceito de blocos.</p>
arrayPares = meuArray.select{ |valor| valor%2==0 }
=> [2,4]

Bom, por enquanto é só!
Acho que agora as coisas estão ficando mais com a cara do Ruby, pois deixamos de lado o bla bla e passamos para a pratica, algo mais produtivo, talvez você ainda não tenha notado, mas nesse post conseguimos trabalhar bastante um otimo conceito do Ruby que são os blocos. A intenção daqui para frente é utilizar exemplos de códigos, para expressar os conceitos das funcionalidades que essa maravilhosa linguagem nos proporciona

Até a próxima!

Iuri Menescal