Mostrando postagens com marcador Boas Práticas. Mostrar todas as postagens
Mostrando postagens com marcador Boas Práticas. Mostrar todas as postagens

sexta-feira, 14 de maio de 2010

Compilar em apenas um passo




Na serie de arigos sobre o teste do Joel estou escrevendo sobre os pontos que devem ser levados em consideração para a melhor o processo de produção de software.

A segunda  pergunta do 
teste do Joel é saber se você pode compilar todo o projeto em apenas um passo. Essa é uma questão essencial e um desafio para muitas equipes. Em muitos casos perdem-se horas sagradas para gerar um novo Release.

Boas equipes possuem um único script que faz um checkout completo do zero, reconstrói cada linha de código, faz os EXE's, em todas as suas várias versões, linguagens e combinações de #ifdef, cria o pacote de instalação e cria a mídia final -- layout do CDROM, download do website, o que seja.

Se este processo possui mais de uma etapa, ele tende a ter erros. E quanto mais perto você chega da data de entrega, mais você quer ter um ciclo realmente rápido para corrigir o "último" bug, fazer os EXE's finais, etc. Se você leva 20 etapas para compilar o código, executar o construtor de instalação, etc, você vai enlouquecer e cometerá erros bobos.

Para automatizar o processo de compilação existem diversas ferramentas mas duas premissas sempre se mantêm independente da ferramenta escolhida :
  • Deve ser possível compilar o projeto inteiro em um passo
  • Deve ser possível usar qualquer máquina de desenvolvimento para isso

Citando algumas ferramentas:

Cruise Control
 - ferramenta que automatiza o processo de build, provendo várias tarefas que facilitam o controle sobre o código, incluindo uma interface para visualizar os detalhes sobre cada build

Visual Build Professional
-   ferramenta que possui suporte para o Microsoft Visual Studio .NET/2005, Visual Studio Team System, Visual Basic, Visual C++, SourceSafe, eMbedded Tools, Borland Developer Studio, Delphi, JBuilder, C++Builder, ClearCase.  Para sistemas de builds pequenos/medios ele é excelente. Já para builds de grande porte, pode não ser uma boa já que ele não permite o que, em alguns casos, dificulta o reaproveitamento dos scripts.

Além das ferramentas acima ainda merecem ser lembradas o Quick Build e o Luntbuild


Finalizando ...

Seja qual for a sua ferramenta preferida, o que realmente importa é que o processo seja o mais automatizado possivel, para assim diminuir as possibilidades de erros, como também agilizar o processo de deploy de novas versões do sistema.

Para quem desejar saber mais sobre o assunto seguem alguns links que entre outros serviram de base para este post

domingo, 28 de março de 2010

Instalando o Git com o Cygwin

Ola amigos, 


Dando seqüencia nos posts sobre Controle de Código (SCM) hoje vou mostrar como instalar o Git com o Cygwin. 


Pra começar, o  que é Cygwin?


Cygwin é uma coleção de ferramentas de software livre originalmente desenvolvidas por Cygnus Solutions de maneira a permitir que várias versões do Microsoft Windows possam, de certa forma, agir como um sistema Unix. Sua principal intenção é portar softwares que rodam em sistemas POSIX (como sistemas Linux, sistemas BSD, e sistemas Unix) para que rodem em Windows com pouco mais do que uma recompilação. Programas portados com Cygwin funcionam melhor em Windows NT, Windows 2000, Windows XP, e Windows Server 2003, mas alguns podem rodar aceitavelmente bem em Windows 95 e Windows 98. O Cygwin é atualmente mantido por funcionários da Red Hat e outras pessoas.


Então vamos às instruções 


a) Baixe o instalador do Cygwin. (aqui)
b) Execute o programa setup.exe
c) Na primeira tela, clique em Avançar 
d) Selecione "Install from Internet" e clique em Avançar
e) Deixe o root directory como "C:\Cygwin" e clique em Avançar
f) Informe o local package directory como "C:\Cygwin\packages" e clique em Avançar
g) Marque "Direct Connection" e clique em Avançar
h)Após o programa baixar alguns arquivos, selecione o site ftp://mirrors.kernel.org na lista de Available Download Sites e clique em Avançar
i) Após o programa baixar mais alguns arquivos, clique no botão 'View', de forma que passe de 'Category' para 'Full'. Será necessário instalar os seguintes pacotes:


   - git
   - git-completion
   - git-gui
   - gitk
   - openssh
   - subversion
   - subversion-perl
   - subversion-python
   - subversion-ruby


j) Para instalar, clique em cima de 'Skip', de forma que apareça a versão do pacote que vai ser instalada. Após selecionar todos os pacotes acima, clique em Avançar.
k) Se aparecer alguma tela falando sobre instalação de dependências dos pacotes selecionados, clique em Avançar.


O programa vai baixar os pacotes selecionados e após isso ira aparecer uma tela perguntando sobre criação de ícones. Proceda da forma que lhe for mais conveniente e clique em Concluir.


Para testar, acesse o cygwin pelo atalho criado, se tiver algum, ou diretamente via c:\cygwin\cygwin.bat. 


Sendo apenas mais uma janela no ambiente, você continua usando seu Windows normalmente, e com um simples Alt+TAB, terá toda a flexibilidade e poder dos comandos do Linux, como bash, ls, grep, find, awk e amigos.É possível rodar o WindowMaker, KDE ou Gnome, dentro de uma janela do Windows! 


No nosso caso, especificamente, será possivel acessar todas a funcionalidades do Git 




Alguns Links para saber mais sobre o Cygwin 



Aproveito também para lembrar que estou prestando consultoria e treinamento para implantação do Git.  


Abraço e até o proximo post. 

terça-feira, 9 de março de 2010

Controle de Código - Introdução ao GIT




Olá amigos ...

Dando seqüência aos posts sobre SCM (do inglês source code management) ou em bom português Sistema de Gerenciamento de Código, nosso assunto hoje será uma introdução ao GIT

Se esta á a sua primeira vez por aqui, recomendo a leitura dos seguintes posts antes de continuar

O Teste do Joel: 12 Passos para um Código Melhor

O Básico sobre Controle de Código

Sistema de controle de versão (wikipedia) 


Feito isso então vamos falar do GIT

O Git é um software para controle de versão distribuído, liberado sob a licença GPL (Software Livre), inicialmente criado por Linus Torvalds para o desenvolvimento do Kernel do Linux. O atual responsável pela manutenção do projeto Git é Junio Hamano.

O objetivo do Git é atender requisitos como desenvolvimento distribuído, manipulação de grandes conjuntos de arquivos, operações de junção (merge) complexas, rapidez, etc.

Cada diretório de trabalho Git é um repositório com todos os históricos e habilidade total de controle das revisões, não dependente de acesso a uma rede ou a um servidor central.

Vários projetos de software usam Git para controle de versão, exemplos notáveis como Kernel Linux, Servidor X.org, Qt (toolkit), Um laptop por criança (OLPC) e a ferramenta de trabalho web Ruby on Rails são alguns exemplos.

O design do Git foi inspirado por dois outros sistemas de versionamento: BitKeeper e Monotone.

Para aprofundar no assunto, recomendo aos interessados visitarem os seguintes links.

Porque Git é melhor que X
GitSvnComparsion em Inglês 

Aproveito também para avisar que estou prestando consultoria e treinamento para implintação do Git. 



Abraço e até o proximo post. 

terça-feira, 9 de fevereiro de 2010

O Básico sobre Controle de Código



Muitos problemas de desenvolvimento de software são causados por falta de controle de versão. Faça uma avaliação rápida da situação da sua equipe de desenvolvimento:

  1. Alguém já sobrescreveu o código de outra pessoa por acidente e acabou perdendo as alterações?
  2. Tem dificuldades em saber quais as alterações efetuadas em um programa, quando foram feitas e quem fez?
  3. Tem dificuldade em recuperar o código de uma versão anterior que está em produção?
  4. Tem problemas em manter variações do sistema ao mesmo tempo?



Se alguma das perguntas acima teve um sim como resposta, então sua equipe necessita urgentemente de um sistema para controle de versão!

Um sistema de controle de versão (ou versionamento), VCS (do inglês version control system) ou ainda SCM (do inglês source code management) na função prática da Ciência da Computação e da Engenharia de Software, é um software com a finalidade de gerenciar diferentes versões no desenvolvimento de um documento qualquer. Esses sistemas são comumente utilizados no desenvolvimento de software para controlar as diferentes versões – histórico e desenvolvimento – dos códigos-fontes e também da documentação.

Esse tipo de sistema é muito presente em empresas e instituições de tecnologia e desenvolvimento de software. É também muito comum no desenvolvimento de software livre. É útil, em diversos aspectos, tanto para projetos pessoais pequenos e simples como também para grandes projetos comerciais.

Principais vantagens

As principais vantagens de se utilizar um sistema de controle de versão para rastrear as alterações feitas durante o desenvolvimento de software ou o desenvolvimento de um documento de texto qualquer são:
Controle do histórico: facilidade em desfazer e possibilidade de analisar o histórico do desenvolvimento, como também facilidade no resgate de versões mais antigas e estáveis. A maioria das implementações permitem analisar as alterações com detalhes, desde a primeira versão até a última.
Trabalho em equipe: um sistema de controle de versão permite que diversas pessoas trabalhem sobre o mesmo conjunto de documentos ao mesmo tempo e minimiza o desgaste provocado por problemas com conflitos de edições. É possível que a implementação também tenha um controle sofisticado de acesso para cada usuário ou grupo de usuários.
Marcação e resgate de versões estáveis: a maioria dos sistemas permite marcar onde é que o documento estava com uma versão estável, podendo ser facilmente resgatado no futuro.
Ramificação de projeto: a maioria das implementações possibilita a divisão do projeto em várias linhas de desenvolvimento, que podem ser trabalhadas paralelamente, sem que uma interfira na outra.

Não existe nada mais frustrante do que não ter exatamente o código-fonte da versão que está rodando no cliente ou não saber o que mudou desde que a versão foi entregue. Esse tipo de coisa pode acabar com uma empresa ou fazer com que ela fique muito mal vista no mercado.

Porém, independente do mercado, existe um bom motivo para o desenvolvedor possuir algum tipo de controle de código: controle. Se você ou sua equipe não conseguem corrigir todos os bugs, pelo menos saberão o que já foi feito. Se você achou um bug que não existia antes da versão 10, o histórico das mudanças entre a versão estável 9 e a versão não-tão-estável 10 vai te dar uma pista muito boa de onde o problema pode ter sido gerado. Visto dessa forma, não importa muito o tamanho da equipe ou da organização. O importante de um bom código é que suas mudanças estejam sempre registradas, visíveis e disponíveis a qualquer um.



Opções para Controle de Código

Um controle de código para uma pessoa só não precisa ser nada muito sofisticado, sendo que um amontoado de ZIPs pode dar conta do recado. Porém, a partir do momento em que o número de desenvolvedores aumenta para dois ou mais, aí o controle baseado em ZIPs começa a ruir, e é necessário usar uma ferramenta mais apropriada. Existem algumas opções, que vai do gosto e necessidades de cada um:

Visual Source Safe ou VSS: não é gratuito nem robusto o suficiente para agüentar toneladas de código-fonte, mas vem junto do Visual Studio e pode ser apropriado para empresas de porte pequeno ou médio (e empresas de um programador só).

Concurrent Version System ou CVS: é um sistema fonte aberto, gratuito e robusto. Suficiente para agüentar toneladas de código-fonte e equipes de vários andares. Atualmente está sendo substituído gradualmente pelo

Subversion ou SVN: é um substituto moderno do antigo CVS; igualmente gratuito e poderoso, está rapidamente se tornando a opção predominante.
Git: é um sistema de controle de revisão distribuida, rápido e escalável. O Git foi desenvolvido inicialmente por Linus Torvalds mediante uma necessidade de ter um software robusto para controle de versão do kernel linux. O Git, diferente do subversion, por exemplo, não é um repositório de dados centralizado. Assim, cada pessoa que trabalha no mesmo projeto terá uma cópia completa do repositório, portanto, as operções comuns de um repositório de dados são feitas localmente. Isso dá a liberdade total para o usuário trabalhar com o repositório como quiser, criando branches, fazendo merges, etc... Ao final do processo, ele pode enviar um branch mais bem trabalhado e testado ao repositório remoto.

Para aqueles que queiram aprofundar no assunto recomendo a leitura dos artigos abaixo, que entre outros, serviram de base para este post.

http://pt.wikipedia.org/wiki/Sistema_de_controle_de_versão

http://www.pronus.eng.br/artigos_tutoriais/gerencia_configuracao/conceitos_basicos_controle_versao_centralizado_e_distribuido.php

quinta-feira, 4 de fevereiro de 2010

O Teste do Joel: 12 Passos para um Código Melhor


Nas minhas "andanças" pela internet acabei encontrando o Teste do Joel: 12 Passos para um Código Melhor e fiquei impressionado com o que li. 

Antes de falar do teste de Joel, preciso falar do próprio Joel é claro. Quem será esse tal Joel Spolky, então vamos lá: 



Joel Spolsky é um experiente programador, dono do Blog Joel On Software - um dos melhores (senão o melhor) blog sobre gerenciamento e desenvolvimento de software. Também é  o fundador da Fog Creek Software, uma pequena empresa de software na cidade de Nova York. Formou-se na Universidade de Yale, e trabalhou como programador e gerente na Microsoft, na Viacom e no Juno.


O legal do Teste do Joel é que ele consiste de 12 perguntas que deverão ser respondidas com SIM ou NÃO cada questão. Você não precisa realizar cálculos complicados para achar o resultado. Simplesmente atribua à sua equipe 1 ponto para cada "sim" respondido. 

Uma pontuação 12 é perfeita, 11 é tolerável, mas 10 ou menos indica que você tem sérios problemas. A verdade é que a maioria das empresas de software funcionam com uma pontuação 2 ou 3, e elas precisam de uma grande ajuda, porque companhias como a Microsoft funcionam com 12 pontos todo o tempo.

Então vamos lá às perguntas : 

  1. Você usa controle de código?
  2. Você pode compilar em somente um passo?
  3. Você faz compilações diárias?
  4. Você tem uma base de dados de bugs?
  5. Você corrige os bugs antes de escrever código novo?
  6. Você tem um cronograma atualizado?
  7. Você tem uma especificação?
  8. Os programadores tem condições de trabalho tranqüilas?
  9. Você usa as melhores ferramentas que o dinheiro pode comprar?
  10. Você tem testadores?
  11. Novos candidatos escrevem código durante a entrevista?
  12. Você faz testes de usabilidade de corredor?
Se você desejar poderá ler o artigo completo que serviu de base para este post e conhecer um pouco mais sobre cada um dos doze itens clique no link abaixo: 


Diante de tudo que li e do impacto que esse assunto causou em mim, nos proximos posts vou abordar assuntos correlatos aos itens do teste, e o primeiro deles será sobre controle de código, e sobre a ferramenta que uso para esta finalidade o GIT. 

Então ... temos um encontro marcado no próximo post.

Até lá.