Rodrigo Sendin

Testar antes (TDD) ou depois?

noreply@blogger.com (Rodrigo Sendin) — Thu, 25 Feb 2010 20:38:00 +0000

Sei que esse assunto está mais do que batido, mas gostaria de colocar aqui minhas impressões sobre o tema.

Testes automatizados de software estão se tornando requisitos obrigatórios para qualquer projeto que tenha algum tipo de controle de qualidade. Assim como em qualquer ramo da industria, um controle de qualidade implica no aumento dos custos de produção. Para o consumidor isso é claro, e se resume naquela conhecida frase: "O Barato saí caro". O produto mais barato geralmente tem uma qualidade pior, o que significa um controle de qualidade inexistente ou tolerante à falhas.

Do lado de cá dessa controversa industria que é o desenvolvimento de software, há uma certa resistência quanto à necessidade de um controle de qualidade, principalmente aqui no Brasil.

Na minha visão sobre esse assunto, o problema está na forma como os projetos são gerenciados atualmente. Hoje, na maioria dos projetos, o custo de desenvolvimento de um software se resume à simples conta: ValorTotalDaHoraDoDesenvolvedor * QtdeHorasDoProjeto.

Levando em consideração que o desenvolvimento de uma rotina de testes (teste unitário), geralmente consome a mesma quantidade de tempo necessária para se escrever a própria rotina à qual o teste avalia, em alguns cenários, um projeto com 100% de cobertura de testes pode levar o dobro do tempo para ser desenvolvido. Isso se complica ainda mais se a equipe não está acostumada com a ideia de se escrever testes.

E é aí que o TDD faz o maior sentido do mundo. Assim como em qualquer indústria, bons gestores se esforçam para reduzir os custos nos processos de produção. Enquanto aqui no Brasil isso parece se refletir únicamente na redução direta do Valor/Hora citado acima, outras esferas procuram soluções mais efetivas e inteligentes.

No TDD (Test Driven Development), o teste unitário deve ser escrito antes da rotina que ele deve avaliar, e este geralmente reflete uma definição de como a rotina deve funcionar, servindo inclusive como uma especificação. Após escrito, o teste é então executado com a certeza de que irá falhar, já que a rotina não foi implementada ainda. Em seguida é escrita a rotina alvo do teste, que deve seguir a especificação definida no mesmo. Uma nova execução vai agora indicar se a rotina atende à especificação, e caso não atenda ela deve ser refatorada até que tenhamos um resultado positivo na execução do teste.

Mas qual é o motivo lógico de se criar um teste unitário antes da própria rotina? Ao longo do tempo, um desenvolvedor que adota TDD, se acostuma com esse "jeito de pensar", e passa a naturalmente pensar numa rotina de testes antes de pensar na própria rotina alvo. Isso, certamente agiliza o seu trabalho, já que passa a ser uma reação automática do desenvolvedor, assim como um motorista muda de marchas sem ter que raciocinar a respeito.

TDD é uma cultura, um mindset, uma sacada gerencial para reduzir o tempo gasto na escrita de testes unitários. Porém, TDD só dá resultados a longo prazo, depois de muita prática.

E note que TDD não é para todos, existem certamente casos em que ele não se aplica, como por exemplo quando temos um departamento ou pessoa responsável pelos testes do projeto. As responsabilidades neste cenário é dividida entre o desenvolvedor do teste e o desenvolvedor da rotina. E se o teste é escrito antes ou depois, não tem mais importância, já que não faz diferença em termos de redução de custos.

Miguel Sendin

noreply@blogger.com (Rodrigo Sendin) — Mon, 09 Nov 2009 19:46:00 +0000

Na manhã do dia 6 de novembro de 2009 faleceu Miguel Sendin, meu avô.

Tenente Coronel da Policia Militar do estado de São Paulo, professor, vendedor (e consumidor) de livros, autodidata e poeta. Não havia uma única conversa com ele que não fosse uma aula.

Na minha infância/adolescência ele foi mais do que um Google para mim. Se ele não tinha uma resposta pronta para uma pergunta, logo ia buscar na sua biblioteca, no segunda andar da casa.

Quando eu tinha apenas 10 anos de idade (1989), ele me deu o seguinte livro:

Eu já sabia o que queria fazer da vida. Lembro de várias tardes digitando código BASIC em um CP 200 ligado em uma velha televisão Philips. Aprendi a programar com esse livro.

Visionário, já naquela época ele falava da importância que os computadores iriam ter no futuro. Além de me influenciar, também patrocinou vários cursos (BASIC, Dbase, Clipper, VB, etc) e os meus dois primeiros PCs (386, Pentium 166Mhz).

Aprendi muito com meu avô, e por influencia direta dele hoje eu sou programador.

Não basta achar a Verdade, e preciso ter:
Sabedoria para reconhecê-la
Humildade para aceitá-la
Coragem para vivê-la e

Caridade para ministrá-la

Miguel Sendin

(14/12/1915 -- 06/11/2009)

Visual Studio e TFS 2010 Beta 2 Lançado!

noreply@blogger.com (Rodrigo Sendin) — Tue, 20 Oct 2009 00:01:00 +0000

Hoje, dia 19 de outubro de 2009 a Microsoft lançou a versão Beta 2 do Visual Studio 2010 e do Team Foundation Server 2010. Para os assinantes do MSDN o download já está disponível. Para quem não é assinante, precisará esperar mais alguns dias aí.

Se quiser se inteirar de algumas novidades, principalmente da instalação destes produtos, assista ao vídeo do Brian Keller no Channel 9

Seguem os pontos que eu achei mais interessantes:

Instalação do TFS2010
1. Não tem mais toda a burocracia dos usuários. Podemos usar apenas um único usuário para toda a instalação.
2. Primeiro instalamos para depois configurar.
3. Existe uma configuração Basica que permite a instalação do TFS2010 em Cliente VISTA ou Windows 7 (com SQLServer Express). Essa é a grande novidade, pois permite montar um ambiente totalmente caseiro do TFS. As restrições são a inexistencia do Reporting Services e do SharePoint para este ambiente.
4. Temos agora um Console de Administração, que ajuda (E MUITO) o trabalho de configuração e gerenciamento do servidor.
5. Foi introduzido o conceito de "Team Project Collection" que aparentemente permite varios ambientes com configurações diferentes no mesmo servidor.
6. A Configuração do TeamBuild muito mais fácil também.

Resumindo, a Microsoft atendeu as preces de todos nós que já sofremos com a instalação do TFS2005 e TFS2008, e finalmente apresenta uma ferramenta de fácil instalação e configuração. Certamente o TFS vai ganhar muitos adeptos a partir de agora.

A instalação do VS2010 Ultimate não tem muito o que falar.
1. O Ultimate é o nome da edição mais completa do Visual Studio, equivalente ao Visual Studio Team System 2008.
2. NNF (Next, Next Finish) Total. Pode ir de olho fechado.
3. Assustou um pouco o espaço que ocupa = 5.1GB.
4. O Team Explorer já vem instalado junto.

Deu pra perceber um foco muito grande no TFS, tanto que na Start Page do Visual Studio, a primeira task sugerida é a conexão com o TFS.

Apesar de muita gente estar falando por aí que o Beta 2 já é uma versão estável, a ponto de entrar em produção, eu ainda tenho minhas dúvidas. O próprio Brian Keller, no vídeo acima, não fala nada disso, e ainda sugere a instalação em um ambiente virtual. Tenho a mesma opinião que a dele, instalem o Beta 2 (TFS ou VS) em máquinas virtuais, ou em equipamentos onde você pode correr riscos.

A medida do possível vou colocando mais novidades do Beta 2 aqui.

Grande Abraço e até a próxima.

Microsoft “Courier”

noreply@blogger.com (Rodrigo Sendin) — Wed, 23 Sep 2009 19:47:00 +0000

Já não é mais novidade que o futuro vai ser cheio de “surfaces”. Iremos interagir com o mundo através de telas multi-touch, seja nas nossas mesas de trabalho, televisão, painéis de automóveis e até nas paredes.

Essa pelo menos, é a visão de futuro que a Microsoft vem demonstrando em vídeos e palestras que vemos por aí. Um desses vídeos mostra o Courier, uma espécie de tablet. Bem interessante, confira abaixo:

Eu cheguei neste vídeo pelo blog do Ayende e achei interessante a observação que ele fez. Note no vídeo acima, que em um determinado momento o usuário escreve um texto com uma caneta.

Qual foi a última vez que você usou uma caneta para escrever um texto? Será que pega uma tecnologia que sugere abandonarmos o teclado e voltar a usar a caneta?

TFS 2008 - Arremate

noreply@blogger.com (Rodrigo Sendin) — Tue, 04 Aug 2009 18:46:00 +0000

Para quem acompanhou o post anterior, onde detalhei os passos para se instalar o Team Foundation Server 2008 no Windows Server 2008 com o SQL Server 2008, vai neste post um arremate.

Seguem algumas dicas finais e também algumas ferramentas que você pode instalar para completar o ambiente.

SQL Server 2008 Service Pack 1: Depois de tudo instalado você já pode aplicar o Service Pack 1 do SQL Server 2008, inclusive pode e deve fazer todas as atualizações pendentes do seu Windows Server.

Team Explorer: Ele também é conhecido como TFC(Team Foundation Client), e precisa ser instalado no servidor e nas estações que vão acessar o TFS pelo Visual Studio 2008. O ideal é que nas estações, o SP1 do Visual Studio 2008 ainda NÃO esteja instalado. Mas se já estiver com o SP1, instale o TFC e depois reaplique o SP1 do Visual Studio 2008, ele vai corrigir alguns problemas do TFC. Além disso, se você usa o Windows VISTA, execute o setup do TFC como administrador (run as administrator). Se tentar instalar direto pelo Auto-Paly do DVD, vai ter um erro durante a instalação, por falta de permissão.

TS WebAccess: Baixe e instale o Team System Web Access no servidor. Esta é uma aplicação Web que expõe os seus Team Projects em um site, que você pode abrir para ser acessado via Web. A instalação é simples e você só precisa definir se vai usar autenticação integrada do windows ou um "forms authentication". Essa última opção é mais interessante se você pretende liberar o acesso externo. Lembre-se de abrir a porta 8090 no Firewall do servidor.

Estes foram os passos finais que realizei para deixar o ambiente completo. Também existe o TFSPowerTools, que é um conjunto de ferramentas para auxiliar na configuração e customização do TFS. Ainda não o explorei, e tão logo o faça coloco minhas dicas aqui.

Depois de tudo instalado e funcionando, você vai notar que tem um conjunto enorme de ferramentas na mão. Junto com a edição Team System do Visual Studio, a quantidade de funcionalidades é gigantesca.

O próximo passo é aprender como usar e administrar tudo isso. Na medida do possível vou postar maiores detalhes dessa minha jornada pelo TFS. E se você pensa em montar um ambiente destes na sua empresa, fale comigo. Eu estou junto com a Taunet Consulting realizando implantações deste tipo. Grande Abraço e até a próxima!

TFS 2008 no Windows 2008 com o SQL Server 2008 – DETONADO!

noreply@blogger.com (Rodrigo Sendin) — Mon, 13 Jul 2009 14:24:00 +0000

Se você gosta de desafios, tente fazer o seguinte: Instale o TFS 2008 (Team Foundation Server) em um Windows Server 2008 com o SQL Server 2008. É uma experiência única, pela qual todo desenvolvedor .NET deveria passar. A sensação de completar essa tarefa é a mesma que se tem ao chegar no final do God of War, ou do Assassins Creed. Impagável!

Escolha o Nível de dificuldade:

Primeiro defina o ambiente que você quer instalar. Você pode optar pelo Single-Server, onde todos os recursos são instalados no mesmo servidor. Ou o Dual-Server, onde temos um servidor de Dados (SQL Server 2008), e um servidor de aplicação (TFS e seus recursos). Você ainda pode optar por uma instalação “Multi-Server”, onde além do servidor de aplicação temos um servidor de Build e outro de Proxy. Esse é o nível mais alto de dificuldade, e não aconselhável para iniciantes.

Fase 1: Domínio ou Workgroup?

Você vai instalar o servidor TFS em uma rede com domínio ou em um WorkGroup? Decida isso antes de prosseguir. No caso de uma rede com domínio, o TFS não pode ser instalado no Domain Control (é claro).

Fase 2: 64-bits com Hyper-V?

O TFS 2008 NÃO pode ser instalado em um Windows Server 2008 64-bits. Se seu servidor é x64, a sugestão é instalar um Windows Server 2008 x64 nele, e habilitar o Hyper-V (Servidor de virtualização que vem no 2008). No Hyper-V você cria uma VM com Windows Server 2008 32-bits, e nele sim você instala o TFS.

Dica 1: O Hyper-V só pode ser instalado se seu hardware atender a determinados requisitos. Use este software para verificá-los.

Dica 2: Para instalar um Windows Server 2008 86x em uma VM do Hyper-V, utilize a edição classificada como “Without Hiper-V”.

Fase 3: Application e Web Roles

Com o Windows Server 2008 32-bits instalado para o TFS, habilite as Roles Application Server e Web Server (IIS). Além disso, coloque seu servidor na rede, é claro. Se estiver no Hyper-V você deve usar uma rede de conexão externa. E se sua rede tiver um DC, coloca o servidor no domínio. Feito isso, Windows Update nele!

Fase 4: Criando os Usuários do TFS

Você deve basicamente criar dois usuários. Um chamado TFSSETUP que será usado para a instalação. E outro chamado TFSSERVICE, que será usado para os serviços. Ambos podem ter nomes diferentes, e você pode opcionalmente criar uma conta de serviço para cada um dos demais serviços do TFS, como TFSREPORTS e TFSPROXY. Mas o TFSSERVICE sozinho dá conta do recado, principalmente em um Single-Server.

Se você está em uma rede com domínio, estes usuários precisam ser criados no Active Directory do seu DC, senão eles devem ser criados como usuários do próprio servidor. O TFSSETUP precisa estar no grupo de Administradores Locais do Servidor TFS (não do domínio). E o TFSSERVICE (e de demais contas de serviço) precisam ter a permissão para se logar como um serviço, no servidor TFS. Você faz isso através dos seguintes passos: Administrative Tools / Local Security Policy / Local Policies / User Rights Assignments / Log on as a service.

Faça um log-off, e a partir daqui utilize o TFSSETUP para as demais operações.

Fase 5: SQL Server 2008

Esse é dureza, e grande parte do truque está aqui. Você não pode instalar o SQL Server 2008 com o Service Pack 1, e nem aplicar o Service Pack 1 após a instalação! O TFS não vai reconhecer o SQL 2008 SP1 como um servidor de dados válido, portanto faça a instalação apenas do SQL 2008. Além disso, você deve utilizar a edição Standard ou Enterprise, nunca a Express. Uma dica é ter um SQL Server 2008 dedicado ao TFS.

Faça uma instalação completa do SQL Server 2008, sem dó. Reporting, Analysis, Full Text Search, etc. O TFS vai precisar de tudo isso. Utilize o TFSSERVICE para os serviços que o SQL Sever solicitar um usuário. Pode ser o mesmo para todos, não tem problema. Instale o SQL Server apenas com o Windows Authentication Mode, e defina o TFSSETUP como um dos administradores.

Fase 6: Verificar o SQL Server 2008

Após a instalação e um reboot, vá ao SQL Server Configuration e defina todos os serviços como “Iniciados” e “Inicialização Automática”. E certifique-se de que o TCP esteja habilitado. Abra o Management Studio e tente se conectar no Database Engine. Se a conexão estiver ok, passe para a fase seguinte.

Fase 7: Sahrepoint

O TFS precisa do SharePoint, seja o Windows SharePoint Services (WSS que é parte do Windows Server), ou do MOSS 2007 (Microsoft Office Sharepoint Server, também conhecido como Sharepoint Products and Tecnologies). O WSS pode ser instalado e configurado pelo próprio instalador do TFS. Já o MOSS 2007 precisa ser instalado antes. Você pode instalá-lo no mesmo servidor do TFS ou em um outro servidor. No meu caso eu instalei o MOSS 2007 no mesmo servidor do TFS, logo após a instalação do SQL Server 2008. Seguem os passos da instalação do MOSS:

Passo 1: Execute o instalador e na primeira tela escolha o tipo de instalação AVANÇADA.

Passo 2: Em Server Type escolha a opção COMPLETE.

Passo 3: Ao pedir para reiniciar os serviços, clique em YES.

Passo 4: Na Janela “Connect to Server Farm” escolha a opção “No, I want to create a new server farm”.

Passo 5: Em “Specify configuration Database Settings”, informe o nome do servidor TFS no “Database Server”, mantenha o nome padrão para o “Database name”, e em “Specify Database Access Account” escolha o usuário TFSSERVICE.

Passo 6: Na janela "Configure SharePoint Central Administration Web Application", escolha um número de porta para a Central de Administração do Sharepoint, e guarde este número. E em “Configure Security Settings” escolha NTLM

Passo 7: Ao término da instalação do Sharepoint, abra o prompt de comando como administrador (run as adminstrator). Vá até a pasta: C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\bin\ e execute o seguinte comando:

stsadm.exe -o extendvs -exclusivelyusentlm -url http://WSSServerName:80 -ownerlogin Domain\TFSSERVICE –owneremail "admin@localhost" -sitetemplate sts -description "Default Web Site".

Substituindo o “WSSServerName” pelo nome do seu servidor, e o “Domain” pelo nome do seu domínio.

Passo 8: Ainda no prompt de comando, execute mais esse:

stsadm.exe -o siteowner -url http://WSSServerName:80 -secondarylogin Domain\TFSSETUP

Passo 9: Para finalizar a configuração do MOSS2007 você ainda deve ir na central de administração e configurar todos os serviços para iniciarem automaticamente. Siga as prórprias orientações nas tasks da Central de Administração do Sharepoint. Assim que finalizar tudo, faça um reboot no servidor.

Fase 8: Aplicando o Service Pack 1 no instalador do TFS 2008

Você chegou na fase mais difícil. Se passar por aqui está com o jogo ganho. Como disse antes, o TFS 2008 não reconhece o SQL2008 SP1, mas ele também não reconhece o SQL2008 (sem o SP1). Porém, o SP1 do TFS, esse sim reconhece o SQL2008 (sem o SP1). Mas não existe uma instalação do TFS com o SP1. Muita gente morre aqui e usa o SQL 2005 mesmo.

O truque é aplicar o SP1 do TFS no Setup, antes da instalação. Sim isso é possível. Exige uma certa destreza mas dá pra fazer. Siga exatamente estes passos:

Passo 1: Faça o Download do SP1 do TFS, e salve-o em uma pasta chamada C:\SP1Download

Passo 2: Abra o DVD de instalação do TFS e salve o conteúdo da pasta AT na pasta C:\InstallMedia

Passo 3: Abra o Prompt de Comando como administrador (run as administrator) e execute o seguinte comando: C:\SP1Download\TFS90SP1-KB949786-ENU /extract:C:\SP1Extract

Passo 4: Crie uma pasta chamada C:\MergeFolder

Passo 5: Ainda no prompt de comando execute: msiexec /a C:\InstallMedia\vs_setup.msi /p C:\SP1Extract\TFS90sp1-KB949786.msp TARGETDIR=C:\MergeFolder

Passo 6: na pasta C:\MergeFolder teremos o Setup do TFS com o SP1 já aplicado a ele. Se você chegou até aqui, execute o "Setup.msi" e seja bem vindo a fase nove.

Fase 9: Instalando o TFS

Passo 1: Aceite os termos de licença. (aquele que chegar até aqui e não aceitar os termos de licença será amaldiçoado pela eternidade)

Passo 2: Em Destination Folder pode aceitar o padrão e seguir com Next.

Passo 3: Em "Team Foundation Database Server", indique o nome do servidor do banco de dados.

Passo 4: Em "System Health Check" o setup vai verificar se todos os pré-requisitos estão ok. Caso haja algum problema, é sinal de que você não completou corretamente alguma coisa nas fases anteriores. Neste caso, é um jogo de paciência onde você terá que identificar o problema e repetir alguns passos feitos anteriormente. Use o Guia Oficial de Instalação do TFS para identificar o problema e tomar as ações necessárias. Caso todos os pré-requisitos estejam ok, você poderá continuar com a instalação.

Passo 5: Em "Team Foundation Server Service Account" use o TFSSERVICE.

Passo 6: Em "Reporting Services Data Source Account" use o TFSSERVICE.

Passo 7: Em "Windows SharePoint Services Service Account" selecione "Use Team Foundation Server service account".

Passo 8: Em "Specify Alert Settings" opcionalmente habilite os alertas e defina o servidor SMTP. (opcional)

Passo 9: Inicie e aguarde o término da instalação.

Fase 10: Team Explorer

Instale o Team Explorer nos computadores de desenvolvimento da sua rede, que já tenham o Visual Studio 2008 (Standard, Enterprise ou TeamSystem) instalado. A versão Express é incompatível com o TFS. Instale o Team Explorer no Servidor também, pode parecer sem sentido, mas ele é pré-requisitos para pacotes como o Srcum Process Template da Conchango

É isso aí! Esses foram os passos que eu segui para detonar o TFS2008 no Windows2008 com o SQLServer2008. Agora com tudo já instalado você pode aplicar o SP1 do SQLServer2008, sem problemas.

São muitas as variáveis que envolvem a instalação deste ambiente, e por isso você pode chegar ao mesmo resultado de formas variadas. Caso você tenha alguma dica, ou tenha passado por algumas dessas fases de uma maneira diferente, deixe seu comentário aqui.

Grande Abraço e até a próxima!

Qual é a sua Meta?

noreply@blogger.com (Rodrigo Sendin) — Thu, 25 Jun 2009 16:39:00 +0000

Nunca fui fã de livros de administração. Não gosto daqueles textos enfadonhos que, ou falam o óbvio, ou alguma coisa que nunca entenderei direito. Mas tem um livro muito famoso que estava na minha lista há tempos: “A META” de Eliyahu M. Goldratt e Jeff Cox.

Sabe aqueles livros que todo mundo fala que você tem que ler, mas que você fica com um pé atrás, achando que vai se arrepender? Deste eu não me arrependo não. Ele não é bom só porque aborda gerencia e administração através de um Romance, com ele eu aprendi coisas realmente interessantes. E é perfeitamente possível traçar um paralelo entre os problemas tratados na história do livro (que foca uma indústria), com problemas de empresas de desenvolvimento de Software.

Vamos a um breve resumo para eu iniciar meu raciocínio: A Meta conta a história de Alex Rogo, um gerente de uma fábrica de uma cidadezinha do interior dos EUA. A Fábrica está literalmente numa pior, com muitos pedidos atrasados, clientes reclamando, problemas vindos de todos os lados, pressão de diretores, e por aí vai. Alex tem três meses para reverter a situação, senão a fábrica fecha. E para piorar um pouco, a mulher está a ponto de abandoná-lo, pois ele não tem mais tempo para a família.

A história começa apresentando este cenário, e vai mostrando como o Alex vai conseguindo conquistar melhorias, tanto na vida profissional, quanto na pessoal, com a ajuda de um velho conhecido chamado Jonah.

A partir daí, se você se interessou, sugiro que leia o livro. Vale à pena, pode acreditar. Abaixo vou acabar colocando alguns spoilers, mas nada que inviabilize a leitura. (mesmo assim, se você não quiser saber mais detalhes da história, pare de ler por aqui).

A primeira tarefa do Alex para sair do buraco é descobrir qual é a verdadeira META da sua fábrica, ou melhor: Qual é a verdadeira meta de qualquer organização?

No começo eu achei essa questão muito óbvia, e não entendia porque o Alex demorou e sofreu tanto para achar a resposta. Até que eu refiz essa pergunta da seguinte forma: Qual é a META de um departamento de desenvolvimento de software?

Aí eu entendi a dificuldade. Pare aí um minuto para pensar, você que trabalha com desenvolvimento de software. Qual é a verdadeira META que a sua empresa, ou o seu departamento deve seguir?

As respostas mais comuns são:

- Criar software de qualidade;
- Atender às necessidades dos usuários;
- Cumprir os Requisitos no prazo combinado;
- Fazer Software para Durar (essa é a preferida dos Arquitetos);
- Criar Software reutilizável;
- Zero Bug! (preferida dos adeptos do TDD);
- Entregar um produto de qualidade, que agregue valor e sinergia aos processos de negócio dos nossos clientes (é sério, tem gente que fala desse jeito);
- etc.

Enfim, nenhuma dessas é a resposta correta. A verdadeira META de uma empresa é GANHAR DINHEIRO! É óbvio, e provavelmente você já chegou a essa resposta lá atrás.

Mas e quando falamos especificamente de um departamento de desenvolvimento de software, de uma empresa que não comercializa software? A resposta é a mesma. Se a Meta de qualquer empresa é o Ganho, todos os departamentos dessa empresa devem seguir a Meta. Ou seja, o software que fazemos, direta ou indiretamente, deve levar a organização em direção ao Ganho. Pense um pouco, o software que o seu departamento faz, ajuda a empresa a alcançar sua Meta? Direta ou indiretamente é o que deveria acontecer.

O fato é que quando estamos muito envolvidos nos processos operacionais do nosso trabalho, é difícil enxergar que tudo o que fazemos, no final das contas tem o único objetivo de se converter em Dinheiro.

E se a META de uma organização é ganhar DINHEIRO, a produtividade dessa organização só pode ser medida com relação a este GANHO.

Então, a próxima pergunta que eu lhe faço é: Você, como desenvolvedor de software, é produtivo com relação à META da sua empresa? As tarefas que você executa diariamente estão especificadas e priorizadas para atender a verdadeira META da organização onde você trabalha?

Essa visão pode parecer capitalista demais, mas é assim que as coisas funcionam. O primeiro passo para sermos mais produtivos, é admitir qual é a verdadeira META do nosso Trabalho.

É claro que não para por aí. Essa foi a primeira lição que o Alex aprendeu na história. Existem muitas outras questões que aprimoram e evoluem essa idéia, e o livro trata delas de uma forma muito ilustrativa, sempre deixando uma questão no ar: Será que estamos no caminho certo?

Na media do possível vou tentar explorar mais sobre essas questões aqui neste Blog. A Teoria das Restrições (TOC – Theory of Constraints), com o processo de melhoria contínua, é particularmente interessante, e podemos aplicá-la no desenvolvimento de software. Mas se você não quiser esperar meu próximo post, leia o livro!

Agora, se você faz software e não ganha dinheiro (direta ou indiretamente), você provavelmente possuí outro emprego e software é apenas um hobby, já é milionário e não sabe o que fazer com o tempo livre, é sustentado pelos seus pais ou cônjuge, ou mora num país verdadeiramente comunista. :)

Grande Abraço e até a próxima!

CRUD no ADO.NET

noreply@blogger.com (Rodrigo Sendin) — Wed, 03 Jun 2009 12:32:00 +0000

Nós que trabalhamos na borda da tecnologia, sempre procurando por novidades, avaliando versões betas, ctps, etc, acabamos esquecendo um pouco das coisas simples e básicas. Notei isso recentemente quando algumas pessoas que estão começando a aprender C# me pediram por um exemplo simples de rotinas de inclusão, alteração, exclusão e consulta de registros em uma tabela de um banco de dados SQL Server. Me assustei quando notei que não tinha tal exemplo pronto, para poder enviar.

É em nome da simplicidade, e para que sempre que possível, possa ajudar quem tem interesse em aprender C#, que vou começar a postar aqui alguns exemplos e conceitos básicos. Começando hoje com um exemplo de CRUD, usando os recursos mais simples do ADO.NET.

Para quem não é familiarizado com a sigla, CRUD é o acrônimo de: Create, Read, Update e Delete. Referencia às quatro operações básicas de qualquer banco de dados.

O código deste exemplo que vou mostrar aqui, pode ser executado em um aplicação do tipo Console Application, e precisa do database Northwind da Microsoft. É claro que você deve adaptá-lo para que funcione no seu banco de dados e no tipo de aplicação que deseja: ASP.NET, Windows Forms, WPF, Silverlight, etc.

Comecemos então com o código necessário para abrir a conexão com o banco de dados. Veja na Listagem abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using System.Data;
using System.Data.SqlClient;

namespace Algorama.Exemplos.CRUDSimples.AppConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            string ConnString =
            "Data Source=(local);Initial Catalog=Northwind; Integrated Security=True";
            SqlConnection Conn  = new SqlConnection(ConnString);
            try
            {
                Conn.Open();
                InsertShippers(Conn, "ALGOARAMA", "123456");
                //UpdateShippers(Conn, "ALGORAMA - ALTERADO", "55555555", 4);
                //DeleteShippers(Conn, 4);
                SelectShippers(Conn);
                Console.ReadKey();            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                Console.ReadKey();
            }
            finally
            {
                Conn.Close();
            }
        }
    }
}

Note nas linhas 6 e 7, que precisamos importar os namespaces System.Data e System.Data.SqlClient, para que possamos utilizar os recursos do ADO.NET para SQL Server. Em seguida dentro do método Main (que é executado quando rodamos uma aplicação console), veja que estamos criando um objeto da classe SqlConnection (linha 17), através de uma ConnectionString (linha 16), que possuí as credenciais para acessar o banco de dados no servidor.

Quando vamos abrir uma conexão com um banco de dados, precisamos garantir que o nosso código vá fechá-la corretamente, depois de usada. É por isso que usamos a estrutura try/catch/finally. Com ela, mesmo que ocorra um erro durante o acesso ao banco, estamos garantindo que a linha 33 sempre será executada, fechando a conexão.

Depois que abrimos a conexão com o banco, na linha 20, note que temos a chamada de 4 métodos. Esses são os métodos correspondentes às quatro operações CRUD. Alguns estão comentados, pois para efeito de testes, é interessante que você execute um por vez. Vamos então ao código de cada um destes métodos, a começar pelo Insert.

private static void InsertShippers(
    SqlConnection Conn, 
    string Name, string Phone)
{
      SqlCommand Comm = new SqlCommand();
           
      Comm.CommandText =
      "INSERT INTO Shippers( CompanyName, Phone ) Values(@Name, @Phone)";
      Comm.Parameters.Add(new SqlParameter("@Name", Name));
      Comm.Parameters.Add(new SqlParameter("@Phone", Phone));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Inserido(s)",
            nroReg.ToString());
}

Todos os quatro métodos recebem como parâmetro o objeto de conexão aberto no método Main. Com este objeto, no método Insert podemos criar um objeto da classe SqlCommand (linha 5), e definir um comando no formato texto (linha 7). É claro que você poderia estar usando uma stored procedure aqui.

Veja que nas linhas 9 e 10, estamos alimentando os parâmetros do comando que será executado. Essa prática garante que nossa aplicação esteja segura quanto a possíveis ataques de SQL Injection. Por fim o comando é executado e uma mensagem exibida na console.

Note que para que você utilize essa rotina em uma aplicação Windows Forms ou ASP.NET, poucas adaptações devem ser feitas. A essência da operação de inclusão não muda.

O próximo método que segue na Listagem abaixo, é o método que faz a operação de Select. Veja que também usamos um SqlCommand, porém, neste caso o SqlCommand é executado por um SqlDataAdapter (linha 11), que é usado para preencher um DataSet (linha 13).

private static void SelectShippers(
    SqlConnection Conn)
{
      SqlCommand Comm = new SqlCommand();

      Comm.CommandText = "SELECT * FROM Shippers";
      Comm.CommandType = CommandType.Text;
      Comm.Connection  = Conn;

      DataSet ds = new DataSet();
      SqlDataAdapter da = new SqlDataAdapter();
      da.SelectCommand = Comm;
      da.Fill(ds);

      Console.WriteLine(
          "Total de: {0} registros",
          ds.Tables[0].Rows.Count);

      foreach (DataRow item in ds.Tables[0].Rows)
      {
          Console.WriteLine(
                    "Id: {0} - Name: {1} - Phone: {2}",
                    item["ShipperID"],
                    item["CompanyName"],
                    item["Phone"]);
      }
}

O dataset é uma representação em memória de parte do nosso banco de dados. Com ele podemos recuperar e manipular os dados do database de forma desconectada. Esse é um assunto a parte, que deve ser explorado em mais detalhes em outra ocasião.

Por fim, ainda no método Select, depois de recuperados todos os registros, estamos imprimindo-os na Console através de um foreach (linha 19), que irá percorrer por todas as linhas da tabela do nosso dataset.

Por último, temos agora os métodos de Update e Delete, que seguem nas próximas duas listagens. Eles tem comportamento muito parecido com o Insert, que usa o SqlCommand e parâmetros, dispensando qualquer comentário adicional.

private static void UpdateShippers(
    SqlConnection Conn, 
    string Name, string Phone, int ID)
{
SqlCommand Comm = new SqlCommand();

      Comm.CommandText =
      "UPDATE Shippers SET CompanyName = @Name, Phone = @Phone WHERE ShipperID = @ID";
      Comm.Parameters.Add(new SqlParameter("@Name", Name));
      Comm.Parameters.Add(new SqlParameter("@Phone", Phone));
      Comm.Parameters.Add(new SqlParameter("@ID", ID));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Alterados(s)",
            nroReg.ToString());
}

private static void DeleteShippers(
    SqlConnection Conn, int ID)
{
      SqlCommand Comm = new SqlCommand();

      Comm.CommandText = "DELETE FROM Shippers WHERE ShipperID = @ID";
      Comm.Parameters.Add(new SqlParameter("@ID", ID));

      Comm.CommandType = CommandType.Text;
      Comm.Connection = Conn;

      int nroReg = Comm.ExecuteNonQuery();

      Console.WriteLine(
          "{0} Registro(s) Deletados(s)",
            nroReg.ToString());
}

É importante notar que o código apresentado aqui serve como teste para estas quatro operações. Se você pretende usar este código em uma aplicação Windows ou Web, terá que realizar algumas adaptações. Se você quiser, pode ainda fazer o download desse exemplo aqui.

Espero que este post ajude quem procura por um exemplo básico de ADO.NET.
Grande Abraço e até a próxima!

Visual Studio 2010 e .NET Framework 4.0 BETA

noreply@blogger.com (Rodrigo Sendin) — Sun, 17 May 2009 15:49:00 +0000

Esta previsto para essa semana que começa hoje, o lançamento de uma versão beta do Visual Studio 2010 e .NET Framework 4.0. Até então tínhamos disponível uma versão CTP em máquina virtual, de outubro de 2008, mas que não mostra nem metade das novidades que virão nessa nova versão da plataforma.

A expectativa é que até quarta-feira (20/05) já tenhamos uma versão pública deste BETA. Se você for um assinante do MSDN, poderá baixar logo na segunda feira.

Nas últimas semanas eu tenho pesquisado bastante sobre as novidades que virão na nova versão da plataforma de desenvolvimento da Microsoft. E posso afirmar que muita coisa boa esta por vir. Teremos muitas novidades, em uma versão tão revolucionária quanto foi o VS2005/.NET 2.0, com relação ao seu antecessor.

Se você quiser sentir um gostinho do que está pra vir nessa nova versão, recomendo que assista uma série de vídeos disponíveis no Channel 9 (http://channel9.msdn.com/shows/10-4/). Eu mesmo estou terminando um artigo que será publicado em breve na .NET Magazine, tratando exclusivamente das novidades do Visual Studio 2010 e .NET Framework 4.0. E na medida do possível também colocarei aqui neste blog algumas dessas novidade.

Para não passar este post em branco, mostro agora uma das novidades do Visual Studio 2010 que eu achei mais útil. Não é nada de outro mundo, mas algo que há muito tempo fazia falta para quem vive oito horas por dia na frente do Visual Studio. É o chamado QuickSearch.

Sabe aqueles projetos com centenas de itens, onde perdemos um precioso tempo na Solution Explorer, só procurando pelo item que precisamos abrir? Pois é, agora no Visual Studio 2010 vamos ganhar o QuickSearch que vai simplificar e muito essa tarefa.

Basta estar com alguma janela de código aberta e utilizar o atalho: CTRL + , (sim, é CTRL + vírgula). Isso irá chamar a janela de Quick Search, que como você pode conferir na imagem abaixo, irá buscar qualquer item do projeto que satisfaça a condição textual.

Note que além de uma pesquisa textual simples, podemos fazer uma pesquisa apenas das letras maiúsculas utilizadas no padrão de nomenclatura CamelCase. Veja que só a utilização das siglas como GUN irá trazer como resultado da pesquisa o método GetUserName. Ao Selecionar o item desejado e clicar em OK, será aberto o arquivo onde o item selecionado se encontra.

Esta é só uma pequena e útil amostra do enorme conjunto de novidades que encontraremos no Visual Studio 2010 e .NET 4.0.

Grande Abraço e até a próxima!

Quem vem em primeiro lugar?

noreply@blogger.com (Rodrigo Sendin) — Mon, 11 May 2009 23:07:00 +0000

Como já expressei aqui e em outros lugares, sou um grande fã da DevExpress (http://www.devexpress.com/). Não só por ter um ótimo produto, mas por ter um atendimento e tempo de resposta formidável.

Mas esse POST não é sobre a DevExpress, e sim sobre a Newsletter que eles começaram a veicular recentemente, e pela mensagem deixada pelo CTO, Julian M Bucknall. Não vou falar mais nada, traduzo a mensagem dele aqui abaixo:

"Como desenvolvedores, nós nunca devemos perder de vista o fato que nós escrevemos software para nossos usuários finais, e não para nós mesmos. São os nossos usuários que pagam nossos salários. Seja literalmente, contratando nossos serviços ou comprando nossos produtos, ou indiretamente, contratando-nos como funcionários.

Muitas vezes, nós nos perdemos com o impressionante potencial do código que estamos escrevendo ou da tecnologia que estamos usando, e esquecemos que nossos usuários finais, na verdade não se importam. O que eles querem é uma experiência (user-experience) de qualidade, que os ajudem no seu trabalho, e que seja o mais simples possível; nada mais do que isso. Eles querem um software performático (ou software que dê ilusão de performance) para que se sintam produtivos. Eles não querem ver seu trabalho desaparecer no ar, por causa de uma falha de energia ou de rede. Eles querem fazer o seu trabalho em qualquer lugar onde possam estar.

Como desenvolvedores, é nosso trabalho atuar como intermediários entre as novidades tecnológicas e estas necessidades. Algumas vezes isso significa que temos que colocar de lado as novidades para satisfazer as necessidades, e ter um usuário feliz. Se os usuários ficarem felizes, eles vão voltar pedindo por mais e nós teremos uma nova chance com as novidades tecnológicas.

Então, coloque seus usuários em primeiro lugar, e as novidades tecnológicas é claro, vem em seguida.

Julian M Bucknall, CTO”

Precisa dizer mais alguma coisa? Grande Abraço e até a próxima!

E os vencedores são...

noreply@blogger.com (Rodrigo Sendin) — Mon, 04 May 2009 17:41:00 +0000

Os cinco vencedores da assinatura da Engenharia de Software Magazine são:

Miguel Henley

Alexandre Caneo

Rob Ranches

Ricardo Bernardino Augusto

Rodrigo Machado Santos

Parabéns a todos! Em breve o pessoal da DevMedia entrará em contato com vocês.

Grande Abraço e até a próxima!

Mais 5 assinaturas da Engenharia de Software aqui!

noreply@blogger.com (Rodrigo Sendin) — Wed, 29 Apr 2009 21:58:00 +0000

Olá Pessoal, Ótimas notícias!

A DevMedia cedeu mais 5 assinaturas da revista digital: Engenharia de Software Magazine, para sortear aqui no Blog. Sendo assim, da mesma forma que foi feito anteriormente, as cinco primeiras pessoas que incluírem um comentário neste POST, irão ganhar a assinatura.

Nesse comentário é necessário que você inclua o seu nome completo, E-Mail e Telefone, para que o pessoal da DevMedia entre em contato com você.

E não esqueça que nos dias 22 e 23 de maio acontecerá o Engenharia de Software Conference. O evento que abordará os temas mais atuais sobre engenharia e arquitetura de software. Confira a grade de palestras no seguinte site: http://www.devmedia.com.br/es_conference/, e não perca essa oportunidade!

Grande Abraço e até a próxima!

Reflection

noreply@blogger.com (Rodrigo Sendin) — Mon, 27 Apr 2009 20:33:00 +0000

Apesar de o C# se destacar por ser uma linguagem estática, de código gerenciado e fortemente tipada, volta e meia nos deparamos com a necessidade de acessar recursos que estão fora deste ambiente gerenciado, de uma forma um pouco mais dinâmica.

Essa não é uma necessidade nova, porém recentemente muito tem se falado de linguagens dinâmicas na plataforma .NET, como os IronPhyton e IronRuby, e até um Dynamic C#, que parece que vai estar aí na versão 4 da linguagem.Enquanto essas novidades não chegam e mostram serviço, a solução mais comum que temos para esse tipo de necessidade é o famoso Reflection do .NET.

O Reflection nos oferece uma forma de encapsularmos assemblies. Ou seja, você pode utilizar o Reflection para acessar um assembly que não esteja diretamente referenciado em seu projeto, e obviamente, utilizar as classes e métodos do mesmo, fazendo um acesso dinâmico a estes recursos.

Veja na listagem abaixo um exemplo clássico de como acessar um assembly através de Reflection. O resultado você confere na figura logo a seguir

System.Reflection.Assembly o = 
    System.Reflection.Assembly.Load(
        "mscorlib.dll");
MessageBox.Show(o.GetName().ToString());

Mas qual a vantagem de utilizarmos o Reflection? O exemplo mais prático e útil que eu conheço do uso do Reflection, é a chamada dinâmica de métodos, seja de um assembly externo ou não.

Imagine que durante a execução da sua aplicação você tenha que calcular os Impostos de uma Nota Fiscal. Porém, o calculo do Imposto depende diretamente do Estado de Destino desta Nota. Sendo assim temos uma rotina ou método para cada Estado.

Que tal colocar essas informações na tabela de Estado, e fazer uma chamada dinâmica à estes métodos. Veja na próxima figura como ficaria a nossa tabela de Estados.

Note que a coluna Metodo armazena apenas uma string que irá representar o nome do método a ser chamado. Sendo assim, podemos ter estes métodos onde desejarmos, veja o exemplo da próxima listagem:



private void button1_Click(object sender, EventArgs e)
{
    // Essa informacao pose ser pesquisada no 
    // database
    string NomeMetodo = "Imposto_MG";

    // Você pode enviar quantos parametros quiser
    object[] Parametros = new object[1];
    Parametros[0] = 100.00;

    double Vr_Imposto = 0;
            
    // Procurando metodo pelo Nome, no assembly 
    // atual
    System.Reflection.MethodInfo metodo = 
        this.GetType().GetMethod(NomeMetodo);
    if (metodo != null)
        Vr_Imposto = 
            (double)metodo.Invoke(this, Parametros);

    MessageBox.Show(Vr_Imposto.ToString());
}
        
/// Rotina para calculo do Imposto para SP
public double Imposto_SP(double Vr_Nota)
{            
    return Vr_Nota * 0.12;
}

/// Rotina para calculo do Imposto para RJ
public double Imposto_RJ(double Vr_Nota)
{            
    return Vr_Nota * 0.07;
}

/// Rotina para calculo do Imposto para MG
public double Imposto_MG(double Vr_Nota)
{            
    return Vr_Nota * 0.18;
}

Veja que temos três métodos para o calculo do Imposto, um para cada Estado cadastrado na tabela. Em todos os métodos recebemos como parâmetro o valor da Nota Fiscal, e retornarmos o imposto calculado.

Neste exemplo estamos fazendo a chamada no evento click de um botão qualquer. Veja que o nome do método foi colocado como Imposto_MG, mas esta informação obviamente deve ser recuperada do database, ou da onde você desejar.

Note que estamos criando um objeto para encapsular os parâmetros, e em seguida através do método GetMethod, criamos uma referencia ao método com o nome que está na variável NomeMetodo. Em seguida estamos fazendo a chamada deste método através do método Invoke.

Faça alguns testes e veja que o método chamado será sempre o indicado na string NomeMetodo.

É claro que o Reflection não se resume a isso, temos um namespace inteiro dedicado a ele (System.Reflection). Mas essa é sem dúvida uma ótima forma de fazer chamadas dinâmicas, tornando a lógica da sua aplicação bem mais flexível.

ASP.NET: WebForms X MVC

noreply@blogger.com (Rodrigo Sendin) — Fri, 17 Apr 2009 19:57:00 +0000

No começo deste mês de Abril foi o lançamento da versão numero 1 do ASP.NET MVC Framework. Você pode realizar o download gratuito através do seguinte site: http://www.asp.net/mvc/. Além do instalador, você também pode baixar uma infinidade de material de apoio, e também o código fonte que é aberto.

A Microsoft anuncia o MVC Framework como uma alternativa ao modelo tradicionalmente utilizado no ASP.NET, baseado no conceito de WebForms. Mas não significa que o MVC vem pra substituir os WebForms, ele vem como uma opção adicional no desenvolvimento de aplicações ASP.NET. O que em minha opinião é muito acertado.

E nesse contexto surge uma polêmica, quase que uma “briga” entre os que defendem os WebForms, e os que agora são a favor do modelo MVC.

Resumindo um pouco a história, o ASP.NET (WebForm) surgiu à oito anos atrás como uma forma de popularizar o desenvolvimento de aplicações Web, adotando o mesmo conceito de eventos que já tínhamos no Windows Forms.

Muita gente não gostou (e ainda não gosta). Reclamam dos eventos, do complexo request, da linguagem baseada em tags, das Sessions, Postbacks e por aí vai. Todas as reclamações, em um grau ou outro tem seu fundamento.

Mas apesar dos defeitos (muitos deles contornáveis), os WebForms sempre tiveram ótimas qualidades, tanto que muita gente utilizou e ainda utiliza. Eu diria que a grande vantagem do ASP.NET WebForms são as ferramentas que o acompanham. Tanto ferramentas da Microsoft quanto de terceiros, que aumentam muito a produtividade.

Ferramentas que oferecem recursos visuais para o desenvolvimento da aplicação, ou os famosos Wizards! Ahh... Esse sim, o grande mal dos desenvolvedores! (rsrsrs) Essa inclusive é outra “briga”. Ou você nunca ouviu (ou disse) a frase: “Programador de verdade não usa Wizard, faz tudo na unha!”. (rsrsrs) É hilário.

Eu sou plenamente a favor de Wizards, geradores de código ou qualquer ferramenta que automatize partes ou todo o processo do desenvolvimento de software! É claro que como desenvolvedores, temos a obrigação de saber fazer sozinhos o que os Wizards fazem, e também saber o momento certo de utilizá-los (tem muita ferramenta ruim por aí, deve se saber identificar).

Mas toda automação se converte em produtividade, que por sua vez se converte em lucro. Qualquer programador com um pouco de visão empreendedora sabe tirar proveito disso. E parte da popularidade e do sucesso do ASP.NET WebForm está aí, na facilidade e produtividade que trouxe no desenvolvimento de aplicações Web.

É nesse cenário que chega o ASP.NET MVC. Como uma opção da casa, para criar no ASP.NET aplicações sob o cultuado padrão MVC (Model-View-Controller). E é claro que ele trás algumas vantagens, como:

- Facilidade para implementação de testes unitários, e possibilidade de um desenvolvimento TDD (Desenvolvimento orientado à testes);

- Maior controle sobre o código HTML gerado, o que agrada bastante aquele povo ali de cima que não gosta das taglibs;

- Uma arquitetura baseada no mapeamento de rotas (ASP.NET Routing), em substituição aos eventos, o que realmente é uma forma mais elegante de se controlar as requisições.

Isso só pra citar as mais evidentes.

Porém, se você está acostumado a utilizar os controles de interface dos WebForms, como GridView, FormsView, etc. Ou usa alguma bilblioteca de terceiros como o DevExpress, esqueça do MVC por enquanto. No MVC nenhum controle desses funciona! E isso vai de encontro ao quesito produtividade. Porque por enquanto meu amigo, o desenvolvimento de aplicações ASP.NET MVC é todo baseado em código.

Até existem alguns Wizards (vejam só.. rsrs) pra facilitar a geração de parte desse código, mas nada comparado ao resultado final que um XtraGrid do DevExpress oferece (http://demos.devexpress.com/ASPxGridViewDemos/Default.aspx), só pra citar um exemplo.

No final das contas essa discussão entre WebForms X MVC é ótima e tomara que perdure. O ASP.NET nunca foi tão democrático. Não importa se um é melhor que o outro, o que importa é que você pode usar qualquer um deles, então faça a sua escolha e siga em frente.

Vamos esperar para, quem sabe um dia, o ASP.NET MVC oferecer a mesma produtividade que os WebForms oferecem hoje. Esse sim seria o ASP.NET ideal!

Mas eu ainda vou fazer uma camiseta: “Eu uso Wizards, e daí?”. Aceito pedidos, alguém topa? (rsrsr)

Os vencedores são...

noreply@blogger.com (Rodrigo Sendin) — Tue, 24 Mar 2009 12:26:00 +0000

Os cinco vencedores da assinatura da Engenharia de Software Magazine são:

Ronaldo Camacho

Rodolfo Sabatin

Flávio da Maia Jr.

Paulo Gilson da Costa

Marcus Vinícius Moreira

Em breve o pessoal da DevMedia entrará em contato com vocês.

Grande Abraço e até a próxima!

Sorteio de Assinaturas da Engenharia de Software Magazine

noreply@blogger.com (Rodrigo Sendin) — Mon, 23 Mar 2009 13:47:00 +0000

Como combinado, hoje estou sorteando 5 assinaturas da revista digital da DevMedia: Engenharia de Software Magazine.

As cinco primeiras pessoas que incluírem um comentário neste POST, irão ganhar a assinatura. Nesse comentário é necessário que você inclua o seu nome completo, E-Mail e Telefone, para que o pessoal da DevMedia entre em contato com você.

Grande Abraço!

Engenharia de Software Conference

noreply@blogger.com (Rodrigo Sendin) — Wed, 18 Mar 2009 20:06:00 +0000

Nos dias 22 e 23 de maio, acontecerá o Engenharia de Software Conference. Essa é uma daquelas raras oportunidades que não se pode perder.

Este evento, promovido pela DevMedia (editora da .NET Magazine e Engenharia de Software Magazine - www.devmedia.com.br), abordará os temas mais atuais sobre engenharia e arquitetura de software. São mais de 30 palestras que vão desde o projeto até o último teste de um software, passando pelos mais modernos conceitos de gerenciamento.

Entre outras informações você pode conferir a grade de palestras no seguinte site: http://www.devmedia.com.br/es_conference/, que também pode ser acessado pelo banner aí ao lado.

É uma oportunidade única de entrar em contato com renomados profissionais do mercado de desenvolvimento de software. Não deixe de participar!

Outra ótima noticia é que estarei sorteando aqui neste Blog, 5 assinaturas da revista digital da DevMedia: Engenharia de Software Magazine (http://www.devmedia.com.br/canais/sobre.asp?site=43).

Na próxima segunda-feira (23/março) vou colocar um POST aqui no BLOG, e as primeiras 5 pessoas que colocarem um comentário neste POST, irão ganhar a assinatura. Fique atento e não perca essa!!

Grande Abraço e até Segunda!!

ASP.NET MVC eBook – Free Download!

noreply@blogger.com (Rodrigo Sendin) — Mon, 16 Mar 2009 20:38:00 +0000

O ASP.NET MVC é uma nova framework que vem sendo desenvolvida pela Microsoft com o objetivo de viabilizar o desenvolvimento de aplicações Web no padrão MVC (Model x View x Controller).

Atualmente o MVC Framework está disponível para download na versão Release Candidate 2 (http://www.asp.net/mvc/), que certamente estará na versão final em breve.

Mas este POST não é para falar a respeito do ASP.NET MVC, e sim de um livro escrito por feras no assunto: Scott Guthrie, Scott Hanselman, Rob Conery, e Phil Haack.

O livro ainda não está disponível, mas já é possível fazer um “pré-pedido” com desconto: http://www.amazon.com/gp/product/0470384611?ie=UTF8&tag=scoblo04-20&linkCode=xm2&camp=1789&creativeASIN=0470384611

Porém, jóia mesmo foi o Scott Gunthrie disponibilizar para download o capítulo que ele escreveu. Através desse site aqui: http://www.wrox.com/WileyCDA/Section/id-321793.html?cid=0311hottopics3 você faz o download do capítulo inteiro em PDF, e ainda tem acesso ao código fonte que é feito no exemplo.

Vale à pena baixar! Ele mostra ao estilo passo-a-passo como construir uma aplicação inteira com o ASP.NET MVC Framework. São 186 páginas de conteúdo de excelente qualidade. Imperdível!

db4o (parte 6) – LINQ to db4o

noreply@blogger.com (Rodrigo Sendin) — Mon, 09 Mar 2009 17:34:00 +0000

Para finalizar esta sequencia de Posts sobre como realizar Queries no db4o, veremos como é possível utilizar a linguagem LINQ do .net para consultar dados em databases do db4o.

LINQ é a linguagem de queries integrada do .NET Framework, e o db40 também oferece compatibilidade com a linguagem LINQ. A vantagem do LINQ é a capacidade de criar queries em C# com as mesmas funcionalidades da linguagem SQL.

A primeira coisa que você precisa fazer é adicionar uma nova referencia ao seu projeto. Como neste exemplo estamos utilizando um projeto do tipo Console Application, basta adicionar uma referencia neste projeto, à DLL Db4objects.Db4o.dll como você confere na Figura abaixo.

Veja que essa DLL está no mesmo lugar que a Db4objects.Db4o.dll, e ela é que vai adicionar capacidade de criar queries LINQ no db4o.

Em seguida basta importar o namespace Db4objects.Db4o.Linq na classe Program.cs, e já estamos prontos para criar nossas queries com LINQ. Veja na Figura abaixo uma query que vai retornar todos os países com população acima de 1 milhão, e ordenada em ordem alfabética.

O resultado você vê na próxima figura.

Na minha opinião essa é a forma mais fácil e com maiores recursos que temos, para realizar queries no db4o. Além das capacidades de query, que são muito similares à linguagem SQL, com o LINQ temos a adição de uma série de métodos extendidos.

Veja, por exemplo, na Figura abaixo. Note que temos acesso à uma enorme quantidade de métodos da plataforma LINQ. Neste exemplo estamos utilizando o método Take, que funciona como um TOP, e neste caso irá limitar a nossa pesquisa à apenas os 5 primeiros registros encontrados.

Veja o resultado na próxima figura.

Deu pra notar que as possibilidades são muitas com o LINQ. Com isso somamos quatro possíveis formas de se executar queries no db4o: QBE, NQ, SODA e LINQ. Com todas essas possibilidades, dá pra notar que query é um ponto bem forte neste database.

Nos próximos POSTs pretendo falar de alguns assuntos mais avançados, e alguns exemplos práticos de como começar a utilizar o db4o em nossas aplicações. Grande abraço e até a próxima!

db4o (parte 5) – Queries SODA

noreply@blogger.com (Rodrigo Sendin) — Tue, 03 Mar 2009 14:03:00 +0000

SODA é a API interna do db4o para a execução de Queries. Ela oferece compatibilidade com antigas versões, e pode ser utilizada para a criação de queries dinâmicas, enquanto a NQ é fortemente tipada.

A API SODA pode ser utilizada para queries dinâmicas, pois identifica os campos das classes como strings. Para a maioria das aplicações o ideal é utilizar uma API fortemente tipada, como é o caso da NQ e do LINQ, mas em certas aplicações a construção de queries dinâmicas pode ser necessária. A API SODA preenche essa lacuna.

Para escrever Queries com a API Soda precisamos da interface IQuery, e para isso é preciso importar o seguinte namespace: using Db4objects.Db4o.Query; Adaptando para o nosso exemplo, uma Query SODA para retornar todos os países ficaria assim:

Note que a constraint da query é uma “meta descrição” dos objetos que queremos retornar. O resultado é a lista de todos os países cadastrados, o mesmo resultado que obtivemos com o QBE e NE nos outros POSTs.

A única restrição das Queries SODA que eu particularmente não gosto, é que as constraints precisam ser criadas apontando para os atributos privados da classe (private fields), e não para as propriedades. Isso inviabiliza o uso das Queries SODA quando usamos as propriedades automáticas (recurso incluso no C#3.0), conforme fizemos no exemplo da classe Country.

Porém, se nossa classe tivesse sido declarada sem o recurso das propriedades automáticas, como neste exemplo abaixo:

Poderíamos então executar uma Query SODA com uma condição aplicada aos atributos, conforme você pode ver no exemplo abaixo:

Esses exemplos mostram apenas o básico que se pode fazer com as Queries SODA. É possível criar queries bem mais avançadas. Mas o importante a notar aqui é que esse é um mecanismo bem mais complexo de se criar Queries, se comparado com as NQs. Porém, toda NQ por debaixo dos panos, é convertida em SODA, o que significa que as Queries SODA são mais performáticas.

No fim vamos notar que cada estilo de Query atende à uma necessidade, e não será incomum usar mais do que um estilo na mesma aplicação. No próximo POST vou falar do LINQ e fechar a sequencia de posts sobre as Queries em db4o.

Grande Abraço e até o próximo!

db4o (parte 4) – NQ: Native Queires

noreply@blogger.com (Rodrigo Sendin) — Sat, 21 Feb 2009 17:35:00 +0000

Native Query, ou NQ para os íntimos, é a principal interface para realização de queries no db40. As NQs do db4o tem o mesmo apelo que a linguagem LINQ do .NET Framework possuí: criar queries usando a própria linguagem gerenciada.

Eu sou fã incondicional da linguagem LINQ, e como veremos em POSTs futuros o próprio db4o tem suporte para o LINQ, o que torna as NQs a minha segunda opção para queries neste database.

Porém é importante vermos como as NQs funcionam, e é isso que veremos aqui. Se você quiser entender mais a fundo os conceitos e princípios por trás das NQs, sugiro a leitura dos seguintes artigos:

http://www.cs.utexas.edu/users/wcook/papers/NativeQueries/NativeQueries8-23-05.pdf

http://www.cs.utexas.edu/users/wcook/papers/SafeQuery05/SafeQueryFinal.pdf

Seguindo a nossa linha de exemplos que acessa o database algoritma.yap e consulta os objetos da classe Country, veja como fica na listagem abaixo uma query que retorna todos os países com população maior que 100 milhões, usando NQ:

Note que em C# uma NQ é feita com o uso de um delegate, e retorna um lista genérica. Assim como o LINQ, uma NQ tem o benefício da tipagem forte, o que facilita a criação da query para o desenvolvedor. Veja na Figura abaixo o resultado da execução do código acima:

É inegável que esta é uma forma muito eficiente de se construir queries, principalmente as complexas. Veja, por exemplo, que na listagem a seguir temos uma condição que seria impossível de se realizar usando QBE (Query By Examplo visto no post anterior).

Essa query deve retornar todos os países que tenham população entre 100 e 200 milhões, e que também contenham a letra “a” no nome. Pode parecer uma pesquisa inútil, mas ilustra bem o grau de complexidade que podemos atingir com as NQs. O resultado da execução desta Query você vê na figura a seguir:

O efeito colateral das NQs pode ser a baixa performance. Por debaixo dos panos, o db4o vai analisar as NQs e convertê-las em queries SODA (que veremos em detalhes no próximo POST). Isso é claro, deve variar conforme a complexidade das queries.

Além das NQs e QBEs, ainda temos outras duas formas possíveis de se realizar queries no db4o. A API Soda e a linguagem LINQ, que veremos nos próximos dois posts.

Grande Abraço e até o próximo!

db4o (parte 3) – QBE: Query-By-Example

noreply@blogger.com (Rodrigo Sendin) — Sun, 15 Feb 2009 19:58:00 +0000

O db4o oferece quatro formas diferentes de se realizar queries: Query By Example (QBE), Native Queries (NQ), SODA API e LINQ. Neste POST veremos como funciona o QBE.

Query-By-Example, ou simplesmente QBE é a forma mais simples e indicada para usuários que estão iniciando com o db4o. Este é um conceito de construção de queries antigo, que foi criado em paralelo com a linguagem SQL nos anos 70.

A idéia é criar um protótipo que servirá de exemplo para os registros que devem ser retornados pela pesquisa. Este tipo de query é muito comum na orientação a objetos. Se quiser conhecer mais sobre o conceito, dê uma olhada neste artigo publicado no Wikipédia: http://en.wikipedia.org/wiki/Query_by_Example

No db4o quando você usa o QBE, deve fornecer como parâmetro um objeto de template. O db4o irá retornar todos os objetos que tiverem as propriedades iguais aos do objeto template, ignorando apenas as propriedades que contiverem valores defaults.

Fazendo uma consulta na base de dados criada no POST anterior, veja o exemplo abaixo:

Neste exemplo estamos executando uma Query By Example, passando “como exemplo” um objeto da classe Country que possuí a propriedade ID = “BR”. O valor null para strings e o zero para inteiros, são considerados valores defaults, e portanto essas propriedades não entram como condição para esta pesquisa. Sendo assim, o resultado dessa query irá retornar apenas o país Brasil, veja na imagem abaixo:

Obviamente esse tipo de Query é bastante limitado, já que restringe as nossas possibilidades de pesquisa a retornar apenas objetos que tenham as propriedades iguais às do objeto template. Além disso, você não pode utilizar operadores lógicos como OR, AND ou NOT. Porém, é uma forma muito útil e fácil de pesquisar um determinado objeto, através de propriedades chaves, como um ID.

O QBE também pode ser utilizado como uma forma simples e rápida de retornar todos os objetos de uma determinada classe, veja o exemplo do código abaixo:

O resultado é a lista de todos os países armazenados no database. Veja na figura a seguir:

Como disse no início, essa é uma forma bem simples para realizar consultas no db4o, e indicada quando estamos iniciando. No próximo POST veremos como funcionam as Native Queries (NQ), para principalmente endereçar tipos de pesquisa não suportados pelo QBE.

Grande Abraço e até o próximo!

db4o – CRUD (parte 2)

noreply@blogger.com (Rodrigo Sendin) — Sun, 08 Feb 2009 23:12:00 +0000

Vamos agora ver como criar o nosso primeiro banco de dados no db40, e como realizar as quatro operações básicas de qualquer banco de dados: Inclusão, Alteração, Exclusão e Consulta (CRUD = Create, Read, Update e Delete).

A primeira coisa que fazemos quando vamos criar um banco de dados é definir a sua estrutura. Porém aqui estamos falando de um banco de dados orientado a objetos, e não um database relacional como o SQL Server ou Oracle.

A primeira coisa que você tem que saber sobre os databases OO é que a estrutura de dados é definida através de Classes e não de Tabelas. Na prática, o que temos que fazer é criar nossas classes em C#, no próprio Visual Studio.

Vou começar com um exemplo muito simples, porém preparado para comportar os exemplos mais avançados que veremos nos posts futuros. Sendo assim, criei no Visual Studio uma Solution chamada Algoritma, e dentro dessa solution adicionei um projeto do tipo Class Library, chamado Algoritma.Model. Será aqui que iremos criar as classes que definirão a estrutura de dados do nosso database.

Você pode criar suas classes usando o diagrama de classes do Visual Studio. Com ele o processo de modelagem fica bem mais simples e prático. Veja na imagem abaixo que eu criei uma classe chamada Country.

Através do Diagrama do Visual Studio nós podemos criar a nossa estrutura de classes, porém não vamos fugir de por a mão no código, para fazer alguns ajustes nestas classes. Sendo assim, edite a classe Country.cs para que fique como mostra o código abaixo:

Note que criamos três propriedades simples, que irão armazenar o ID do país, que será uma simples sigla, o Nome e um inteiro que irá representar a população daquele país. Em seguida temos um construtor simples que apenas inicializa as propriedades do objeto que está sendo instanciado.

Mais abaixo temos outros dois métodos. O AddPopulation() que simplesmente adiciona valores à População. Não tem um objetivo muito prático, mas vai nos ajudar a entender que apesar de estarmos falando de armazenamento, podemos definir métodos nas nossas classes.

E por fim o método ToString(), que foi sobrecarregado da classe Objects, e aqui irá retornar uma string que exibe todas as propriedades do país.

A princípio essa será a única classe que iremos criar. Veremos agora como criar um banco de dados no db4o e armazenar instancias da classe Country nele.

Antes disso você deve ter observado que até agora não utilizamos nenhum recurso do db4o. Esse é um diferencial importante, pois podemos definir nossas classes da maneira que quisermos, e o db4o se encarregará de armazenar os objetos no database.

Para criarmos nosso banco de dados no db40, vamos adicionar um novo projeto na Solution, agora do tipo Console Application. Neste exemplo eu criei um projeto chamado Algoritma.ConsoleApp.

De cara, neste projeto devemos adicionar duas referencias. Uma referencia ao projeto Algoritma.Model, para que possamos ter acesso à nossa classe Country. E uma referencia à DLL Db4objects.Db4o.dll, que como foi dito no post anterior, é a DLL principal do db4o. Essa DLL você provavelmente irá encontrar no seguinte caminho: C:\Program Files\Db4objects\db4o-7.4\bin\net-3.5.

Com as duas referências criadas, vamos agora ao processo de criação e abertura do banco de dados, que nada mais é do que uma simples linha de código na classe Program.cs, veja a seguir:

Como você pode notar estamos criando uma instancia da interface IObjectContainer, através do método estático OpenFile() da classe Db4oFactory. Veja que este método aponta para um arquivo com extensão .yap. Esta é a extensão dos databases do db4o, que neste caso foi nomeado como Algoritma.yap. Caso o arquivo não exista, ele será criado e aberto, caso exista será apenas aberto.

Em seguida temos uma estrutura try/finally que irá garantir que o database seja devidamente fechado assim que terminarmos de utilizá-lo.

Muito bem, com isso já podemos fazer nossos primeiros testes CRUD. Comecemos com um método de inclusão. Basta incluir o método do código abaixo e fazer a sua chamada no método Main, conforme você vê na própria listagem a seguir:

O Método InsetCountries está criando 3 instancias da classe Country, e armazenando-as no database através do método Store() que temos no IObjectContainer. Note que ao final estamos chamando o método Commit(). Este método está implicitamente concluindo a transação. A partir do momento em que abrimos o database, já estamos em uma transação. E após a chamada do método Commit() a transação atual foi concluída, e outra iniciada.

Execute sua aplicação e veja que os países são inclusos e exibidos na Console. Confira na Figura abaixo.

De tão simples parece estranho não é? Parece que não aconteceu nada, que estes objetos estão apenas na memória, e que ao finalizar a aplicação eles vão ser perdidos. Mas não, eles foram gravados em disco, lá no arquivo Algoritma.yap, e portanto estão armazenados no database db4o.

Vamos à prova. Voltando ao código da classe Program.cs, inclua agora o método SelectCountries conforme mostra o código abaixo, e no método Main(), substitua a chamada do método InsertCountries(), pelo SelectCountries().

Note que estamos fazendo uma consulta que irá retornar um IList contendo dos os objetos da classe Country que existirem no database. Essa é uma das diversas formas que existem para a realização de queries no db40. Veremos no decorrer dos exemplos outras formas.

Execute a aplicação e veja como mostra a imagem abaixo, que é exibido o total de países cadastrados, juntamente com os dados detalhados de cada país.

Abaixo temos o método UpdateCountry, que como você pode ver está realizando um outro tipo de pesquisa, utilizando o padrão QBE. QBE quer dizer Query By Example, ou “Consulta por Exemplo”. Isso significa que o db4o deverá nos retornar todos os objetos armazenados que forem iguais ao do exemplo passado no parâmetro.

A condição é realizada ignorando as propriedades definidas como null, ou zero no caso do inteiro. Com isso estamos recuperando apenas um objeto, no caso o com o ID igual a “FR”.

Com o objeto recuperado do database, podemos fazer a alteração que desejarmos e salvarmos essa alteração através do mesmo método Store(). Veja o resultado da execução deste código na figura a seguir:

Para finalizar segue o código do método DeleteCountry, que também usa QBE para recuperar o país US do database, e excluí-lo do banco.

O resultado da execução deste método você confere na figura abaixo:

Este foi apenas um exemplo básico de como criar um database db4o e realizar as operações mais simples com ele.

Mas aqui nós já podemos ver que o processo de gravação e recuperação dos dados é muito simples, bem mais simples do que estamos acostumados em ambientes de mapeamento objeto / relacional. Veremos muito mais facilidades nos próximos exemplos.

Nos próximos POSTs iremos ver quais são as principais formas de realizar Queries com o db40. Grande Abraço e até lá!

db4o – Baixando e instalando (parte 1)

noreply@blogger.com (Rodrigo Sendin) — Mon, 02 Feb 2009 11:13:00 +0000

Caso ainda não tenha lido, sugiro que leia o post anterior para que saiba sobre o que vamos ver na seqüência de posts que começo hoje.

Começaremos com o download e instalação do db4o nesta parte 1. Nas partes seguintes iremos ver desde recursos básicos até avançados, deste banco de dados orientado a objetos.

A primeira coisa que você deve fazer para iniciar o uso do db4o é o seu download no site da comunidade de desenvolvedores: http://developer.db4o.com/. Como você pode ver na figura abaixo, o download pode ser feito logo na primeira página, no canto direito.

Note que existem duas versões para a plataforma .NET. Uma para .NET 2.0 e a outra para o .NET 3.5. Vamos fazer o download e instalação da versão 7.4 do db4o para .NET 3.5.

O download é simples e rápido, e ao seu final basta executar o pacote db4o-7.4-net35.msi, para iniciar a instalação do db4o em seu computador.

A instalação também é extremamente simples, pode aplicar a técnica NNF que não tem erro. (NNF = Next - Next – Finish). Só peço a sua atenção para a segunda tela do Wizard de instalação, que você vê na figura a seguir:

Aqui você pode ver o diretório onde o db4o vai ser instalado, e também pode modificar esse caminho se quiser. A importância de saber onde o db4o vai ser instalado, é que para utilizá-lo em nossos projetos .NET, precisaremos apontar para as DLLs que estarão aqui.

Com isso você pode notar que a instalação do db4o é praticamente uma simples descompactação. Nada é registrado em GAC ou nos registros do Windows. Essa é uma característica que eu particularmente gosto, pois torna o uso e principalmente a distribuição muito mais fácil e portável.

Terminada a instalação, abra o Windows Explorer e vá até o diretório onde o db4o foi instalado na sua máquina. Veja na parte esquerda da figura abaixo, a estrutura de diretórios criada:

Note que temos três pastas principais aqui:

~\Db4objects\dv4o-7.4\src\ é onde você vai encontrar todo o código fonte do db40. Sim, você já tem acesso ao código fonte da ferramenta.

~\Db4objects\dv4o-7.4\doc\ uma vasta documentação para que você possa dar os primeiros passos com o db4o. A maioria dos exemplos que você verá neste blog será adaptada dessa documentação.

~\Db4objects\dv4o-7.4\bin\ é onde encontramos os binários para o .net 3.5 e compact framework. Note na figura acima, que a DLL Db4objects.Db40.dll está em destaque. Esta será a DLL que mais iremos utilizar para por em prática os exemplos do db4o.

Outra observação importante é que ao término da instalação, você teve a opção de iniciar o tutorial que vem junto com o db40. Esse tutorial também pode ser acessado pelo menu iniciar, na pasta db4objects.

O tutorial é bem interessante e nele encontramos as principais funcionalidades do db4o. Ele usa um exemplo bastante simples e didático de Pilotos e Carros de Fórmula 1. Os exemplos que veremos nos próximos posts serão baseados neste tutorial. Espero você aqui no próximo post.

Grande Abraço!

db4o

noreply@blogger.com (Rodrigo Sendin) — Tue, 27 Jan 2009 16:54:00 +0000

Muita gente me faz a pergunta: “Que solução utilizar para persistência de dados?” Eu inclusive já abordei esse assunto aqui no Blog quando falei do futuro do LINQ to SQL:

http://www.algoritma.com.br/rodrigo.sendin/2008/11/e-o-linq-to-sql.html.

Minha resposta na maioria das vezes é: Depende do Projeto.

Se você tem um projeto de pequeno ou médio porte ou de prazo apertado, eu sugiro as soluções que vão simplificar o trabalho e aumentar a produtividade. Particularmente eu uso os DataSets Tipados do ADO.NET que atendem bem a estes cenários.

Agora, se você tem prazo sobrando e vai desenvolver um projeto relativamente grande, vale a pena investir tempo em frameworks de mapeamento objeto/relacional, como nHibernate e ADO.NET Entity Framework. Vale também planejar sua aplicação em camadas, utilizando algum padrão de projeto que vise à reutilização de código. Certamente você terá ganhos a longo prazo.

Mas no geral eu sempre tive um pé atrás com soluções de mapeamento objeto/relacional, ou padrões que criam complexos mecanismos de gravação/recuperação de dados. Além de tornarem tudo mais trabalhoso, o mercado está inundado de soluções que visam resolver o problema de incompatibilidade entre a orientação a objetos e os bancos de dados relacionais. O que dá a entender que não existe “A solução definitiva”. O que temos são variadas formas de se driblar este problema, cada uma delas com seus benefícios e defeitos.

Recentemente eu tenho dado atenção a outro tipo de solução para este problema: Os Bancos de Dados Orientado a Objetos. Não vou entrar nos detalhes de siglas e definições deste tema, basta saber que há muita gente desenvolvendo databases ou frameworks que armazenam os dados na forma de Objetos, e não em estruturas relacionais.

Um deles que dou destaque neste post, é o db4o (sigla de db4objects) http://developer.db4o.com/. Este database orientado a objetos foi criado inicialmente para Java, mas hoje tem uma ótima versão para .NET. No link citado você encontra o download da última versão, logo na primeira página.

De forma bem resumida posso dizer que as principais características do db4o são:

• É simples de usar, basta usar uma única DLL para as operações básicas;

• Comporta soluções locais e também Client/Server;

• É Open Source, e GPL pra quem é GPL;

• Compatível com varias formas de Query, como QBE e o LINQ do .NET;

• Possuí ferramentas de gerenciamento e configuração para ambientes de servidor;

• Comporta ambientes de replicação;

• Possuí uma versão para o .NET Compact Framework e para o Projeto Mono;

• Tem uma comunidade de desenvolvedores e usuários muito ativa;

Hoje se alguém me faz a pergunta lá de cima, eu sugiro considerar essa opção também, principalmente se o uso de um Banco de Dados Relacional não é pré-requisito do projeto.

Com certeza é difícil vender essa idéia, afinal os bancos de dados relacionais tem dominado o mercado ja a algum tempo. Mas de modo prático pro cliente final não muda nada. O que certamente vai melhorar com o uso de uma ferramenta como o db4o, é a sua produtividade, e esse benefício pode ser repassado para o cliente final em forma de redução de custos.

Mas vale a pena ficar por dentro de como um banco de dados orientado a objetos funciona, e quais são os benefícios e problemas frente aos relacionais. É por isso que eu vou começar a abordar este assunto aqui em futuros posts, de forma mais detalhada e com demonstrações técnicas. Se você tiver interesse em conhecer mais, também começarei a publicar alguns artigos nas edições impressas da .NET Magazine sobre esse tema. E também vídeo-aulas no Portal da DevMedia (www.devmedia.com.br). Aguarde e confira!

Grande Abraço!