Um projeto C++ começa por um Makefile, eu estou acostumado com o ANT e não gosto da idéia de listar todos os meus arquivos fonte na configuração de build como a maior parte dos exemplos de Makefiles fazem, então eu criei um Makefile simples, mas bastante flexível para o meu projeto.

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

TESTDIRECTORIES := test
DIRECTORIES := src
SOURCES := $(foreach dir,$(DIRECTORIES),$(wildcard $(dir)/*.cpp))
TESTSOURCES := $(foreach dir,$(TESTDIRECTORIES),$(wildcard $(dir)/*.cpp))
OBJECTS := $(patsubst %.cpp,%.obj,$(SOURCES))
TESTOBJECTS := $(patsubst %.cpp,%.obj,$(TESTSOURCES))
TESTOBJECTS += $(filter-out src/main.obj,$(OBJECTS))
TARGET := example
LINK := g++
CC := g++
CFLAGS := -c
LFLAGS :=
 
all: $(OBJECTS)
	$(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS)
 
test: $(TESTOBJECTS)
	$(LINK) $(LFLAGS) -lcppunit -o $(TARGET)_unit $(TESTOBJECTS) 
	./$(TARGET)_unit
 
%.obj:%.cpp
	$(CC) $(CFLAGS) -o $*.obj $*.cpp

Com este Makefile, todos os arquivos .cpp que estiverem no diretório src farão parte do executável gerado, mais diretórios podem ser adicionados simplesmente atualizando a variável DIRECTORIES, a mesma coisa acontece com o diretório test e a variável TESTDIRECTORIES para os testes unitários.
O truque aqui é a combinação das funções foreach e wildcard, a função pathsubst é usada para alterar as extensões de .cpp para .obj e a função filter-out é usada para remover o main.cpp dos testes unitários pois este arquivo é apenas o ponto de entrada para o executável principal.
Este Makefile é o mais próximo que eu consegui chegar da funcionalidade do ANT para programação C++, claro que ela pode ser melhorada, considerando que eu não sou um especialista em Makefiles.
Mas o Makefile não é o motivo deste post, estou escrevendo para contar para vocês sobre o CppUnit, uma ótima implementação xUnit para C++.
Eu comecei o projeto escrevendo o “executador de testes” do CppUnit:
testRunner.hpp

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

#include <cppunit/CompilerOutputter.h>
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/TestResult.h>
#include <cppunit/TestResultCollector.h>
#include <cppunit/TestRunner.h>
#include <cppunit/BriefTestProgressListener.h>
 
int main (int argc, char* argv[])
{
    // informs test-listener about testresults
    CPPUNIT_NS :: TestResult testresult;
 
    // register listener for collecting the test-results
    CPPUNIT_NS :: TestResultCollector collectedresults;
    testresult.addListener (&collectedresults);
 
    // register listener for per-test progress output
    CPPUNIT_NS :: BriefTestProgressListener progress;
    testresult.addListener (&progress);
 
    // insert test-suite at test-runner by registry
    CPPUNIT_NS :: TestRunner testrunner;
    testrunner.addTest (CPPUNIT_NS :: TestFactoryRegistry :: getRegistry ().makeTest ());
    testrunner.run (testresult);
 
    // output results in compiler-format
    CPPUNIT_NS :: CompilerOutputter compileroutputter (&collectedresults, std::cerr);
    compileroutputter.write ();
 
    // return 0 if tests were successful
    return collectedresults.wasSuccessful () ? 0 : 1;
}

CppUnit é mito flexível, permitindo diversos tipos de saída para os resultados dos testes, mas escreverei sobre isto em outro post, a idéia atrás deste “executador” é a utilização do registro de testes do CppUnit, o que torna a vida muito mais fácil.
O registro de testes é bem próximo ao fileset passado a task junit do ant, mas os testes se registram sozinhos.
Depois do “executador de testes” pronto, podemos começar a escrever os testes unitários.
Em C++ diferente do Java, são necessários dois arquivos para cada classe, um cabeçalho e uma implementação.
Então, vamos começar com o cabeçalho.
mainTest.hpp

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

#ifndef MAINTEST_H
#define MAINTEST_H
 
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
#include "../src/HelloWorld.hpp"
 
using namespace std;
 
class MainTest : public CPPUNIT_NS :: TestFixture
{
    CPPUNIT_TEST_SUITE (MainTest);
    CPPUNIT_TEST (testHello);
    CPPUNIT_TEST_SUITE_END ();
 
    public:
        void setUp (void);
        void tearDown (void);
        void testHello (void);
    private:
        HelloWorld *hello;
};
CPPUNIT_TEST_SUITE_REGISTRATION (MainTest);
#endif

Neste cabeçalho temos uma declaração de classe simples, extendendo TestFixture do namespace do CppUnit.
C++ não possui reflexão, por isto o CppUnit possui algumas macros para definir o teste, que podem ser vistas no início da declaração da classe, será necessária uma linha com CPPUNIT_TEST para cada método de teste que você declarar.
A linha: CPPUNIT_TEST_SUITE_REGISTRATION (MainTest);
Faz a mágica do auto registro dos testes.
Com isto pronto, você pode começar a implementar a classe de testes como faria em java:
mainTest.cpp

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

#include "mainTest.hpp"
 
void MainTest::setUp(){ 
	hello = new HelloWorld("Test");
}
 
void MainTest::tearDown(){
	delete hello;
}
 
void MainTest::testHello(){
	string expected("Hello Test\n");
	CPPUNIT_ASSERT_EQUAL(expected,hello->sayHello());
}

Como no JUnit existem os métodos setUp e tearDown que são executados antes e depois de cada um dos testes, e o método testHello possui o código do teste (ja que só foi implementado um para este exemplo).
As asserções no CppUnit são feitas utilizando macros.
O CppUnit disponibiliza as seguintes asserções:

• CPPUNIT_ASSERT(condition)
• CPPUNIT_ASSERT_MESSAGE(message,condition)
• CPPUNIT_FAIL( message )
• CPPUNIT_ASSERT_EQUAL(expected,actual)
• CPPUNIT_ASSERT_EQUAL_MESSAGE(message,expected,actual)
• CPPUNIT_ASSERT_DOUBLES_EQUAL(expected,actual,delta)
• CPPUNIT_ASSERT_THROW( expression, ExceptionType )

Muito menos do que no JUnit, mas o suficiente para a grande maioria dos casos.
Depois do teste pronto, agora precisamos escrever o código para que os testes passem.
HelloWord.hpp

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

#include <stdio.h>
#include <iostream>
 
#ifndef MAIN_HPP
#define MAINHPP
class HelloWorld{
private:
	std::string name;
public:
	HelloWorld(char* name);
	std::string sayHello();
};
#endif

E a implementação:
HelloWord.cpp

1
2
3
4
5
6
7
8
9
10
11

#include "HelloWorld.hpp"
 
HelloWorld::HelloWorld(char* name){
	this->name = name;
}
 
std::string HelloWorld::sayHello(){
	std::string result("Hello ");
	result = result + name + "\n";
	return result;
}

Para executar os testes, basta você executar no console:
make test
Agora que todos os testes foram escritos e estão passando, o último passo é escrever o código para inicializar a aplicação:
main.cpp

1
2
3
4
5
6
7
8

#include "HelloWorld.hpp"
int main(int argc, char** argv){
	if (argc >= 2) {
		HelloWorld* hello = new HelloWorld(argv[1]);
		std::cout << hello->sayHello();
		delete hello;
	}
}

E você tem a sua primeira aplicação test driven escrita em C++!
PS.: se você esta utilizando o Makefile que escrevi, lembre que o código da aplicação deve ficar no diretório src e o código de testes no diretório test.
PS2.: O exemplo foi testado em um linux com o CppUnit instalado pelo gerenciador de pacotes, se você quiser instalar o cppunit usando o código fonte ou for executar em outra plataforma lembre-se de atualizar o CFLAGS com os caminhos de influde corretos e o LFLAGS com o caminho da biblioteca do cppunit, se você não esta utilizando o g++ como compilador e linker, lembre-se de atualizar as variáveis CC e LINK.

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

name=ARGV[0]
all = []
last = ""
f = File.new(name)
f.each_line do |l|
  l.strip!
  l,command,params = *(/^(When|Then|Given|And) (.*)/.match l)
  if l
    command = last if command == "And"
    last = command
    params = params.gsub /"/, '\"'
    all << "#{last} \"#{params}\" do\n    pending\n  end"
  end
end
all.uniq!.sort!
sym_name = name[File.dirname(name).length+1..-5]
puts %Q{require 'stories/helper'
steps_for(:#{sym_name}) do
}
all.each { |l| puts "  #{l}"}
puts %Q{end 
 
with_steps_for :#{sym_name} do
  run "\#{dir = File.dirname(__FILE__)}/#{sym_name}.txt"
end
}

eu salvei este código em um arquivo txt_to_steps.rb, e para utilizar basta executar:
ruby txt_to_steps.rb

Um exemplo de user story (utilizando o formato do RSpec) seria este texto:

Story: new user
  As a company employee
  I want to register in the CRM
  So that I can see and manage company contacts

Scenario: user with no access to the system
  Given the username user1
  And the password mypassword
  When the login form is submited
  Then the login form should be shown again

Scenario: user registration
  Given the username user1
  And the password mypassword
  And the email user1@company.com
  When the registration form is submited
  And there is no other user with the same e-mail or email
  Then the registration should be OK
  And the user should be redirected to /

Scenario: repeated user registration
  Given the username user1
  And the password mypassword
  And the email user1@company.com
  When the registration form is submited
  And there is already another user with the same name or email
  Then the registration should fail
  And the registration form should apear again

Scenario: existing user login
  Given the username user1
  And the password mypassword
  When the login form is submited
  Then the user should be redirected to /

Se ajudar mais alguem, a única exigência é deixar um comentário aqui dizendo o que poderia ser melhorado no script

PS.: sei que o blog anda meio parado demais, mas é por um bom motivo, acho que daqui a um mes aproximadamente volta tudo ao normal e eu posso contar aqui o motivo deste tempo quase sem posts

Como implementar paginação para listboxes com muitos elementos

by Marcos de Sousa (Maputo - Mozambique)
13/06/2008

Versão

Eu testei os códigos fontes com ZK 2.4.0, pelo que pode usar ZK 2.4.0 e versões recentes

A Questão

O componente listbox é utilizada para exibir uma série de elementos em uma lista. Os componentes listbox e grid suportam a paginação intrinsecamente. Se você tem uma lista com muitos elementos, por exemplo 1.000.000 elementos, isto vai abrandar a sua aplicação web, ele pode potencialmente utilizar uma grande quantidade de memória no servidor, limitando o número de usuários que podem ser suportados em qualquer tempo. Isto é o que nós não queremos que aconteça. Portanto, vamos corrigi-lo.

A Solução

Paginação é a forma mais simples e comum de dividir grandes quantidades de dados em pedaços pequenos. Paginação é uma parte fundamental no desenho duma aplicação web, tanto do ponto de vista de Desenho de Interface como do ponto de vista do servidor (para processar grandes conjuntos de forma eficiente, sem causar atrasos nos serviços recurso). ZK tem um componente básico chamado Paging. O componente paging é usado para separar longo conteúdo em várias páginas. Para resolver o problema temos de especificar um componente paging explicitamente.

A. Criando as Páginas:

Eu irei revisitar o código fornecido em http://en.wikibooks.org/wiki/ZK/How-Tos#ZK_2.x.x_.2B_Spring_2.x.x_.2B_Hibernate_3.x_.2B_JUnit_Test

Primeiro, vamos ver como utilizar um componente listbox com paginação intrinsecamente:

1
2
3
4
5
6
7
8
9
10

<?xml version="1.0″ encoding="UTF-8″?>
<window title="Listbox with Paging Intrinsically" border="normal" use="com.wikibook2.ui.EmployeeUI">
<listbox id="lstEmployee" width="350px" checkmark="true" mold="paging" pageSize="30″>
<listhead sizable="true">
<listheader label="ID" sort="auto" />
<listheader label="Full Name" sort="auto" />
<listheader label="User Name" sort="auto" />
</listhead>
</listbox>
</window>

Agora, nós queremos usar uma listbox com um componente paging explicitamente:

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

<?xml version="1.0″ encoding="UTF-8″?>
 
<window title="Listbox with Paging Explicitly" border="normal" use="com.wikibook2.ui.EmployeeUI">
 
<listbox id="lstEmployee" width="350px" checkmark="true">
<listhead sizable="true">
<listheader label="ID" sort="auto" />
<listheader label="Full Name" sort="auto" />
<listheader label="User Name" sort="auto" />
</listhead>
</listbox>
<paging id="pagEmployee" pageSize="30″ />
 
</window>

A única diferença é, em vez de nós especificar “mold=“paging”” nós não especificamos nada, e em adição nós usamos o componente paging explicitamente “<paging id=“pagEmployee” pageSize=“30″/>“. É tudo no Desenho de Interface.

B. Código – Desenho de Interface:

Vamos dar uma olhadela para a classe EmployeeUI:

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
33
34
35
36
37
38
39
40
41
42

package com.wikibook2.ui;
// Imports Omitted
public class EmployeeUI extends SimpleWindow implements AfterCompose {
private final String LST_EMPLOYEE = "lstEmployee";
private final String PAG_EMPLOYEE = "pagEmployee";
private final String MAN_EMPLOYEE = "employeeManager";
private GenericManager employeeManager;
public EmployeeUI() {
employeeManager = (GenericManager) SpringUtil.getBean(MAN_EMPLOYEE);
}
public void afterCompose() {
Paging pag = getPaging(PAG_EMPLOYEE);
pag.setTotalSize(employeeManager.count().intValue());
final int PAGE_SIZE = pag.getPageSize();
// Show Listbox with first PAGE_SIZE
redraw(0, PAGE_SIZE);
pag.addEventListener("onPaging", new EventListener() {
public void onEvent(Event event) {
PagingEvent pe = (PagingEvent) event;
int pgno = pe.getActivePage();
int ofs = pgno * PAGE_SIZE;
// Redraw current paging
redraw(ofs, PAGE_SIZE);
}
});
}
private void redraw(int firstResult, int maxResults) {
Listbox lst = getListbox(LST_EMPLOYEE);
lst.getItems().clear();
 
List<Employee> list = employeeManager.getAll(DetachedCriteria.forClass(Employee.class), firstResult, maxResults);
 
for (Employee employee : list) {
Listitem li = new Listitem();
li.setValue(employee);
li.appendChild(new Listcell("" + employee.getId()));
li.appendChild(new Listcell(employee.getFullname()));
li.appendChild(new Listcell(employee.getUsername()));
lst.appendChild(li);
}
}
}

Como você pode ver, a ideia principal é Estratégia Baseada em Consulta, onde resultados são colectados da base de dados quando necessário na medida que o utilizador vai navegando sobre as pequenas páginas e enviados para o cliente. Isto significa que uma nova consulta será executada sempre que o usuário navegar entre as páginas, claro que há uma sobrecarga no desempenho com esta abordagem. No entanto, devido ao menor uso de memória, esta solução é também mais escalável e geralmente, esta é a consideração importante quando se trata de aplicações Web. Com a implementação de AfterCompose, nós executamos algumas inicializações:

• Definimos o número total de empregados
• Desenhamos a listbox com os primeiros empregados na página inicial
• Adicionamos o Evento onPaging para o componente paging

O evento onPaging, é enviado com uma instância de PagingEvent para o componente paging, depois, nós recuperamos a página activa (apartir de 0) e o índice dos primeiros empregados visíveis pela multiplicação da página activa pelo tamanho duma página.

Uma vez que sabemos qual é a página actual, nós redesenhamos a listbox; primeiro nós limpamos todos empregados e depois consultamos o novo pedaço de página de empregados. Lembre-se que, o AfterCompose é um pouco mais rápido, uma vez que não necessita de criar uma outra thread enquanto o evento onCreate é livre para suspender e retornar a execução.

C. Conclusão:

Este pequeno artigo introduziu-lhe o poder do componente paging, como implementar a paginação para listbox com bastante performance quando a listbox tiver muitos elementos.

Você pode encontrar as desvantagens de usar um componente paging externo ao listbox em http://en.wikibooks.org/wiki/ZK/How-Tos#How_to_implement_paging_for_listboxes_with_many_items

Espero que tenha gostado deste pequeno artigo e que este artigo o tenha influenciado para iniciar a utilizar a Framework ZK. No meu dia-a-dia a Framework ZK tem sido bastante produtiva no desenvolvimento de aplicações Web tanto para a intranet como para a internet.

Download

Pode baixar o projecto aqui.
Depois de fazer download do projecto, leia o “readme.pdf” para saber como lidar com o projecto wikibook2.

Sobre Marcos de Sousa

Marcos de Sousa, trabalha na área de desenvolvimento a mais de 5 anos. Trabalha como Desenvolvedor Sénior no Banco Comercial e de Investimentos (BCI Fomento), um dos maiores grupos financeiros em Moçambique. Estudou a Licenciatura em Informática (Universidade Eduardo Mondlane – Curso de Informática (5º ano)).
Junho 13, 2008
Maputo – Moçambique

Eu acho incrível a idéia do Highrise, um mini CRM de verdade, nada daquelas ferramentas auto entituladas CRM de enviar SPAM, eles criaram uma ferramenta espetacular para ajudar a lembrar quais assuntos ja foram tratados com cada um dos seus contatos, podendo agrupar contatos (e os respectivos históricos) por empresa e/ou por tags. Isto já me ajudou bastante

No programa de afiliados também entraram o Basecamp, uma ferramenta para facilitar a comunicação dentro de projetos e gerenciamento dos mesmos, e o Backpack basicamente um gerenciador de tarefas e calendário de grupos. Mas estes dois eu só testei, nunca cheguei a usar de verdade.

PS.: sim, este post foi apenas para publicar os links para as apps com o meu referer, mas as ferramentas são boas mesmo (pelo menos o highrise que eu acho espetacular, as outras duas eu ouço falar muito bem)

O primeiro erro que todos cometem ao iniciar em OO é achar que Orientação a Objetos é sobre classes, isto não faz nenhum sentido, Orientação a Objetos como o próprio nome diz, é sobre Objetos, então, qualquer coisa que não seja um objeto não é realmente importante quando se fala em Orientação a Objetos.
OK, mas por que todos caem no mesmo engano então? porque a grande maior parte das linguagens de programação orientadas a objeto, utilizam classes como moldes para objetos, e durante o desenvolvimento se cria os moldes, ja que os objetos só existem em tempo de execução nestas linguagens.
Quais linguagens não funcionam assim? Bom, agora me vem a cabeça SmallTalk, IO e Ruby, mas devem ter outras.
SmallTalk porque não existe realmente distinção entre “tempo de desenvolvimento” e “tempo de execução” em SmallTalk, tudo esta sempre executando.
IO porque não utiliza o conceiro de classes (a não ser que eu tenha entendido a linguagem errado) e sim objetos template.
E Ruby porque as classes em Ruby são objetos também, mas das três é a que mais se aproxima do “padrão” que citei antes.

Outro erro bastante comum, desta vez quando se utiliza alguma tecnologia de mapeamento Objeto/Relacional, é achar que objetos são tabelas, mapeamento Objeto/Relacional serve para salvar o estado de um objeto em um banco de dados relacional, apenas isto, um objeto do tipo Usuario por exemplo, não possui um atributo “grupo_id”, mas pode possuir um relacionamento com um objeto do tipo Grupo. Percebam que eu escrevi atributo e não campo, pois tabelas tem campos e linhas, objetos possuem atributos e métodos.

Uma coisa bastante comum, ainda utilizando mapeamento O/R é achar que um objeto possui os mesmos atributos que a tabela correspondente, mas neste caso até os nomes são diferentes, infelizmente nestes casos, um objeto precisa ter um atributo “id” que mapeia para a chave primária da tabela, mas um objeto não tem uma chave primária, ele tem apenas atributos.

Então, como solucionar estes problemas?
Bom, no geral, um objeto tem comportamento, e alguns atributos também, mas o importante em um objeto é o que ele faz e como ele faz.
Claro que existem objetos que não tem comportamento, objetos em um sistema são a representação binária de alguma coisa do mundo real, e existem coisas no mundo real que não tem comportamento, tem apenas atributos, como por exemplo mesas e cadeiras, mas exceto se você estiver mapeando um destes objetos no seu sistema, todos os objetos tem um comportamento.
Por exemplo, se você criar um objeto do tipo Usuário, se ele não possuir nenhum comportamento, com certeza o seu sistema esta construído de forma errada, pois pelo menos eu, não conheço nenhum usuário que fique parado como uma estátua o tempo todo, e se este for o caso, com certeza ele não é usuário de sistema nenhum, portanto ele não deveria existir no seu sistema.
A mesma coisa se aplica a um carro, você conhece algum carro que não se move? Que não tenha comportamento algum? A única desculpa para um carro que não tem comportamento algum é um sistema para um museu de carros, onde só importa a carcaça do carro e os atributos dele, principalmente o ano de fabricação.

Outra coisa que todos entendem errado é o padrão MVC (Model, View, Controller).
Na definição do padrão, o controlador esta la apenas como ponto de entrada, ele passa parâmetros para um método de um Model, pega o resultado disto e passa para uma View, se ele estiver fazendo mais do que isto, ele possui parte do código que deveria estar dentro do Model, por tanto, o seu Controller esta errado!

Beleza, mas se eu estou dizendo que todos cometem os mesmos erros, como eu posso dizer que OO é fácil então?
Porque a maioria aprende primeiro a programar de forma estrutural, e depois passa para orientação a objetos, e como as pessoas aprendem coisas novas utilizando como base suas experiências anteriores, utilizam os paradigmas procedurais para tentar programar orientado a objetos, esta é basicamente a raiz do problema.
Para tornar a vida de todos mais fácil, o primeiro contato com programação nos cursos e faculdades deveria ser com SmallTalk e não com portugol ou pascal.
Se você aprender primeiro orientação a objetos, conseguira passar para programação procedural com uma facilidade muito maior do que alguem que aprende primeiro programação procedural tentando aprender orientação a objetos.

O pior é que as linguagens de programação que não são 100% OO contribuem ainda mais para aumentar este problema, vamos pegar o Java como exemplo de uma linguagem não 100% OO.
“Mas me disseram que java era uma linguagem de programação OO”
Bom isto também é verdade, eu disse não 100% OO, não disse que não era OO.
Exemplos de coisas que não são OO em Java: tipos primitivos e métodos estáticos
Basicamente eu acho que na linguagem é só isto que não é OO, mas isto ja causa problemas o suficiente confundindo a cabeça de muita gente.
“Perai, métodos estáticos ficam dentro de classes, como podem não ser OO?”
Mérodos estáticos são uma forma porca de programação procedural dentro de uma linguagem OO que teve uma linguagem procedural como origem, como por exemplo o Java e o C++.
Métodos estáticos não fazem parte de uma classe, utilizam a classe apenas como namespace, o que é diferente de fazer parte.
Em um método estático, não é possível nem saber a qual classe ele pertence, como é possível tanto em object pascal quanto em Ruby, ja que estas não possuem métodos estáticos e sim métodos de classe.
E os tipos primitivos estes sim, não tem relação nenhuma com orientação a objetos, só estão la porque quando a linguagem foi criada não era possível fazer uma classe ter a mesma performance do que um tipo mapeado diretamente do processador da máquina, eles existem em Java por problemas de performance e não por serem Orientados a Objeto.

Alguns design patterns foram criados apenas para contornar limitações da pataforma (Exemplo prático, com um banco de dados OO decente não seria necessário criar o pattern DTO), da mesma forma algumas das regras sobre a utilização de OO foram criadas apenas porque a maioria das pessoas não entende OO, como a regra que diz favoreça composição em vez de herança.
Este é um engano terrível cometido por muitas pessoas que eu não consigo entender.
Muita gente acha que estender uma classe é uma forma de compartilhar código, por exemplo:
Existe uma entidade no sistema de nome Cliente, e em algum momento é necessário criar um ClienteDependente que vai possuir todos os mesmos atributos de cliente mais um que aponta para o responsável, não faz sentido algum fazer ClienteDependente estender Cliente para compartilhar este código, porque o comportamento deles não é o mesmo, por exemplo, ClienteDependente não paga a conta, mas Cliente sim, neste caso seria melhor refatorar o sistema e criar uma entidade que pudesse realizar compras (Ou criar objetos do tipo Compra se o sistema foi bem modelado), e fazer com que Cliente e ClienteDependente estendessem desta, pois neste caso elas estariam realmente compartilhando o comportamento e não apenas evitando algum código aparentemente repetido.
Estender uma classe é estender o comportamento, ou seja, só faz sentido estender o comportamento se a classe “filha” tiver todo o comportamento da classe “pai”, ou seja, é um relacionamento o tipo “é um”. Mas como quase ninguém consegue entender que estender uma classe estende o comportamento (não me parece uma coisa tão complexa assim para se entender), foi criada esta regra que diz: Não use herança, use composição. Simplesmente para evitar que pessoas façam porcaria por não entender conceitos que são estupidamente simples, mas que todos tem mania de complicar.

Outro erro bastante comum é tentar colocar em uma classe apenas o comportamento de todo o sistema, se for para fazer isto, utilize programação procedural, pois você vai estar utilizando a classe apenas como namespace mesmo, não vai nem lembrar que em tempo de execução estara trabalhando com diversos objetos criados a partir daquela forma.

Orientação a objetos é simples, é um paradigma de desenvolvimento que modela um sistema transformando conceitos do mundo real como objetos que colaboram entre si para atingir um objetivo.
Acho que o nome Objeto pode ajudar a confundir boa parte das pessoas, pois em um sistema OO, Compra pode ser um tipo de Objetos, mas no mundo real, compra não é um objeto. Mas para resolver isto eu simplesmente assumo que qualquer um que queira ser um programador precisa ter capacidade para trabalhar com abstrações, não tenho uma explicação melhor para alguem que não consegue entender que Compra pode ser um tipo de Objeto em um sistema OO, assim como Viajem também pode ser um tipo de Objeto (estou utilizando “Tipo de Objeto” em vez de classe porque o que importa em um sistema OO são as instâncias e não as classes) dependendo do problema a ser resolvido.

Acho que são estes os erros mais comuns na orientação a objetos, lendo isto você não concorda comigo? OO é simples, as pessoas é que complicam!
Você lembra de algum outro erro muito comum em OO? deixe um comentário.
Se eu lembrar de mais coisas simples que as pessoas tem mania de complicar eu escrevo outro post.

Trial de Ruby on Rails Powered by mod_rails

Você já deve ter ouvido, até mesmo nesse blog, sobre o poder do Ruby
on Rails e suas vantagens para programadores iniciantes e experientes.
Mas provavelmente você também deve conhecer os problemas de
performance de uma aplicação Ruby rodando com Apache e CGI.

A Locaweb inova mais uma vez disponibilizando uma plataforma mais
robusta para Ruby on Rails usando Passenger, também conhecido como
mod_rails. Com mod_rails você pode publicar sua aplicação RoR de
maneira simples em um ambiente estável e de melhor desempenho.

Verifique você mesmo. Estamos oferecendo um período de Trial de 3
meses aos primeiros interessados em experimentar esse novo ambiente.
Para ter um Plano de Hospedagem Profissional I em plataforma Linux
rodando Ruby on Rails com Passenger basta preencher o formulário
abaixo e aguardar nosso contato.

Fonte: http://blog.locaweb.com.br/archives/263

PS.: se se cadastrarem na Locaweb, informem que o cadastro de cliente foi indicação de “usiinformatica”, assim eu ganho bônus

Ele funciona muito bem integrado com qualquer IDE, no eclipse por exemplo, basta adicionar o infinitest.jar no classpath do projeto a mandar executar a classe: org.infinitest.Infinitest
Uma tela parecida com esta vai ficar aberta enquanto você desenvolve:

Quando algum teste falha, aparece na area branca da tela o nome da classe de testes, o método e a linha da falha, e a barra da parte inferior da janela fica vermelha

O Infinitest funciona com Java + JUnit, ou seja, nada de easyb pelo menos por enquanto

Acho que vou fazer um plugin pro infinitest pra usar o Snarl também, como este do Autotest do ruby

Bom, acho que era isto, testem o Infinitest, vocês vão achar bem divertido

===============================================

Caros,

O RSJUG promove neste mês de maio um dia inteiro dedicado a tecnologia Java.
Serão 2 salas com atividades em paralelo sendo elas 6 palestras 1 tutorial e um painel.

Quando:
31 de maio das 8h as 20h

Onde:
Faculdade de Tecnologia SENAC
Rua Coronel Genuíno 130 - 9° andar - Porto Alegre/RS

Grade do evento:
Grade preliminar pode ser acessada no site: www.rsjug.org

Investimento:
Até o dia 20/05:

• R$25,00 para público em geral
• R$15,00 para associados SUCESU-RS.
• R$20,00 para pacotes de 5 inscrições.
• R$15,00 para pacotes de 10 inscrições.

Após o dia 20/05:

• R$30,00 para público em geral
• R$20,00 para associados SUCESU-RS.
• R$25,00 para pacotes de 5 inscrições.
• R$20,00 para pacotes de 10 inscrições.

Certificados serão fornecidos aos participantes ao final do evento.
Estrutura contará com rede Wireless liberada aos participantes.
Um Cyber espaço será montado para facilitar ainda mais a conectividade dos participantes.
Increva-se já!

Muito obrigado…. e espero vocês lá!
Igor Montezano
RSJUG Leader

history | awk '{a[$2]++}END{for(i in a){print a[i] " " i}}' | sort -rn | head

que resultou neste output:

[19:02][urubatan@urubatan-laptop:~]$ history | awk '{a[$2]++}END{for(i in a){print a[i] " " i}}' | sort -rn | head
83 cd
68 sudo
36 git
31 ls
23 vi
20 dpkg
19 tail
16 rake
13 rm
13 gem

O que quer dizer que eu uso bastante o GIT, e o VI, muito muito de diretório, instalo muitas gems, e listo pacotes instalados no meu linux bastante

Então, vocês topam a brincadeira?
A idéia é colocar um link de volta para este post no post que vocês escreverem com a listagem dos comandos, vale qualquer coisa derivada e unix, Linux, Mac, *BSD, OpenSolaris, …
E no mesmo post, indicar mais X pessoas para o meme.
os meus indicados são: Paulo Silveira, ArthurGeek, Carlos Villela, Fabio Akita e Carlos Brando. (Se algum de vocês ainda estiver usando Windows, favor formatar a maquina e instalar um SO decente )

PS.: se não estiverem afim de participar não tem stress, eu nunca participei de um meme antes, acho que deve ser a completa falta do que fazer em um domingo a noite enquanto espero o chimarrão ficar pronto:D

E eu precisava de um campo de texto com auto completar, e mesmo que estivesse utilizando o prototype, não seria muito fácil utilizar o plugin de autocomplete do rails por que eu precisava deste auto complete em um campo de texto que existe diversas vezes dentro do mesmo form, e novos são adicionados via RJS, isto complicava muito a minha vida por que o ID destes campos adicionados automagicamente é o mesmo …

Como estava utilizando o jQuery, atravéz do plugin jRails isto se tornou muito fácil, bastou utilizar o plugin suggest do proprio jQuery …

O processo para habilitar este autocomplete é bem simples como vocês podem ver abaixo.
Primeiro, instalando o plugin jRails:

script/plugin install http://ennerchi.googlecode.com/svn/trunk/plugins/jrails
rake jrails:install:javascripts

Com isto podemos começar a brincar com os plugins do jQuery, para utilizar o plugin suggest, basta fazer o download dele, colocar o css na pasta public/stylesheets e o js na pasta public/javascripts da aplicação …
Ai vamos editar o layout padrão da aplicação, e ter certeza de que ele inclui as seguintes linhas:

1
2
3

  <%= stylesheet_link_tag 'jquery.suggest.css' %>
  <%= javascript_include_tag :defaults %>
  <%= javascript_include_tag "jquery.suggest.js" %>

Depois disto, em qualquer formulário, para ativar o suggest, basta colocar um text_field padrão do rails com o seguinte código (este bloco veio de dentro de um form_for):

1

 <%= inf.text_field :name, :onfocus => "$(this).suggest('#{formatted_examples_url(:js)}')", :index => nil %>

assim, o suggest vai ser ativado para este campo quando o usuário entrar no campo, independente de se ja existe outro campo com o mesmo ID (sim, eu sei que não deveriam existir objetos com o mesmo ID, mas neste caso não tenho muito como evitar isto … )
Agora no controller …
Tenho o controller examples mapeado como um resource padrão no rails, e editei o método index dele para ficar parecido com isto:

1
2
3
4
5
6
7
8
9

  def index
    @examples = Example.paginate :page => params[:page], :conditions => ["name like ?","%#{params[:q]}%"]
 
    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render :xml => @examples }
      format.js
    end
  end

basicamente a única alteração do controller padrão foi adicionar a linha format.js e adicionei a condition para filtrar a consulta …
depois disto criei o arquivo “index.js.erb” com o seguinte conteúdo (sim, eu podia fazer um render :inline mas não gosto muito da idéia )

1

<%= @examples.collect(&:name).join("\n") %>

fazendo com que o resultado desta action quando chamada com a extensão “js” fosse apenas uma listagem com um nome por linha …

Tudo pronto, autocomplete funcionando
Achei mais simples do que o plugin padrão do rails para autocomplete

PS.: cada vez eu acho o jQuery mais legal de trabalhar, to curtindo mais ele do que o prototype.

Suas opiniões são importantes!
Valeus!

Para quem é tão preguiçoso quanto eu, eu criei um plugin para o rails que reutiliza tudo (ou quase) o que você ja definiu na migration para gerar o model, o nome do plugin é mydry.

E para quem trabalha com Grails, e estava triste até agora por não poder utilizar BDD de forma fácil, eu criei o plugin easyb-test que permite utilizar o easyb para escrever testes para a sua aplicação Grails.

Se quiserem um exemplo de como usar este plugin do easyb, é só olhar o material da minha palestra do FISL deste ano.

Eu não transformei a palestra em um screencast como o Akita, mas em pouco tempo o pessoal do FISL deve liberar os videos gravados (quer dizer, as vezes demora bastante, mas eles sempre acabam liberando )

Então é o seguinte, quem quiser o código fonte, disponibilizei ele no Gitorious (Yeap, isto mesmo, usando GIT, quem usa o windows fazer o favor de instalar o git ai e aprender a usar este excelente sistema de controle de versões, sim, é só linha de comando, sim, vale a pena).

git clone git://gitorious.org/fisl-2008-grails-presentation/mainline.git

ou

git clone http://git.gitorious.org/fisl-2008-grails-presentation/mainline.git


Os slides, diferente do que costumo fazer, não vou colocar aqui para download, vou publicar eles pelo google docs, se não gostarem da esperiência me avisem por favor que coloco um PDF aqui disponível …

| View | Upload your own

<UPDATE>
Coloquei os slides no slideshare pra facilitar a visualização e o download para os interessados.
</UPDATE>
Acho que era isto, espero que o material seja útil para alguem.

Tutorial Clusterização e Load Balance de aplicações JEE

Neste tutorial os participantes aprenderão a clusterizar aplicações JEE em servidores distintos com sessões de usuário replicadas.
Exemplos de falhas e contingências serão apresentados para considerar a estabilidade da solução. Na questão de perfomance e acesso implementaremos o load balance de aplicações JEE com apache.
O tutorial será min