Refatoração
Comentários segundo Code Complete(Parte 2)
0Fala galera, voltando aos comentários segundo Code complete uma questão que o livro faz questão de enfatizar é o estilo do comentário. Como estilo você pode entender a maneira(layout) pelo qual os comentários são feitos. O estilo é importante para que comentar seja uma atividade sustentável no desenvolvimento. Caso o estilo seja inadequado a equipe não vai comentar, ou pior vai deixar os comentários obsoletos.Segue abaixo alguns estilos:
1: /**********************************
2: * Nome: FazAlgumaCoisa
3: * Proposito: Executa uma ação desconhecida
4: * Algoritmo: instancia uma classe x e executa x.FazAlgumaCoisa();
5: *
6: * input: -
7: * output: -
8: *
9: * Histórico de modificação: -
10: *
11: * Autor:Higor Ramos
12: * Data: 10/09/2009
13: * Telefone:(555)222-2255
14: * Cor dos olhos:preto
15: * Tipo sangue: A+
16: * Carro Favorito: Pontiac Aztek
17: * **********************************/
18: public void FazAlgumaCoisa()
19: {
20:
21: }
Não preciso falar que o estilo acima é loucura.. Não existe nada sobre o que está sendo feito
1: /// <summary>
2: /// Função que executa uma execução randômica,
3: /// usada quando é necessário gerar uma sequencia
4: /// desconhecida
5: /// </summary>
6: public void FazAlgumaCoisa()
7: {
8:
9: }
O estilo acima é simples e funcional
Agora que você tem um estilo pode comentar cada variável certo? não! calma.. Um bom início é comentar apenas os membros públicos, pois assim podemos fornecer informações aos usuários da classe e o desenvolvimento não fica “pesado”.
Você pode estar esperando ainda mais dos comentários certo? bem, eles ainda podem oferecer mais! Os comentários possibilitam a geração de documentação automática, para isso basta seguir um padrão(sustentável) e utilizar uma ferramenta como o Ndoc ou SandCastle. Eu gosto bastante da idéia de gerar documentação com os comentários, isso permite que eu crie uma documentação sempre atualizada pois sabemos que quanto mais perto do código a documentação mais chances da mesma estar atualizada.Para os praticantes do XP isso ainda pode ser uma boa prática, pois geramos uma documentação simples e sem perda de tempo.
Conclusão
O code complete deixa bem claro através de pesquisas e links que comentar pode ser uma boa prática. Mais uma vez afirmo que comentar não é desculpa para escrever código ruim. Eu uso comentários para descrever interfaces públicas, gerar documentação, reportar contratos e exceções que podem ser geradas.
Indico a leitura do capitulo sobre comentários do code complete, espero que o post ajude a usar comentários de uma maneira inteligente e funcional.
Código que funciona X código legível
0Fala Galera, desta vez vamos falar sobre o famoso “código que roda” e o código legível. Acho que todos vocês já escutaram a famosa frase “se roda não altere”. Acho que nos ultimos anos(se é que posso falar isso) os desenvolvedores de software vem tendo uma preocupação maior com a qualidade do código que é gerado, mas ainda assim encontramos pedações de código que em 5minutos seriam muito mais faceis de ler.Acho que ficar muito tempo aqui refletindo sobre isso não é produtivo pois já existe um material muito bom na internet. Ainda assim quero registrar o seguinte exemplo criado para representar o sexo de uma pessoa
solução usando campo verdadeiro/false
1: class Person
2: {
3: public Boolean sexo { get; set; }
4: }
5:
6: class Program
7: {
8: static void Main(string[] args)
9: {
10:
11: Person person = new Person();
12: person.sexo = true; //true quando é do sexo masculino
13: }
14: }
O exemplo acima funciona normalmente, o comentário ajuda a entender o que está sendo feito.. sem ele as coisas ficam dificeis.. este é o codigo que funciona mas não é muito legível
opção 2:
1: class Person
2: {
3: public Boolean eHomem { get; set; }
4: }
5:
6: class Program
7: {
8: static void Main(string[] args)
9: {
10:
11: Person person = new Person();
12: person.eHomem = true; //true quando é do sexo masculino
13: }
14: }
Ainda usando o campo verdadeiro/false mas com um nome melhor.legibilidade melhorando
opção 3
1: class Pessoa
2: {
3: public enum Sexo
4: {
5: masculino = 1, feminino
6: }
7: public Sexo sexo { get; set; }
8: }
9:
10: class Program
11: {
12: static void Main(string[] args)
13: {
14:
15: Pessoa pessoa = new Pessoa();
16: pessoa.sexo = Pessoa.Sexo.masculino;
17: }
18: }
O código acima continua funcionando e é muito facil de entender. considero este exemplo o melhor dos apresentados
exemplo4(abuso de design)
1: class ISexo
2: {
3:
4: }
5: class Masculino : ISexo
6: {
7:
8: }
9: class Feminino : ISexo
10: {
11:
12: }
13: class Sexo
14: {
15: //construtor privado
16: public static ISexo MASCULINO = new Masculino();
17: public static ISexo FEMININO = new Feminino();
18: }
19: class Pessoa
20: {
21:
22: public ISexo sexo { get; set; }
23: }
24:
25: class Program
26: {
27: static void Main(string[] args)
28: {
29:
30: Pessoa pessoa = new Pessoa();
31: pessoa.sexo = Sexo.MASCULINO;
32: }
33: }
O código acima ainda continua facil pra ler mas é muito exagerado para situação.
Conclusão;
No final de tudo o que importa é usar a abstração aliada ao bom senso. Devemos ser capazes de expressar nosso desejo facilmente sem exageros ou rodeios.
ps: um agradecimento ao guru que vira e mexe me faz refletir sobre como programar melhorHello Folks,we will talk about the famous “code that runs and readable code”. I think everybody at least once had heard “if it is working don’t change it”. I think that in the last years(if I’m able to say it) developers had been a doing some improvements when the subject is software quality. Although this improvement is still possible to find pieces of code that could be simplified in five minutes.I thnk that is a waste of time stay trying to explain this problem. I qant to show you an example of code that was used to represent a person field called gender.
solution using a bool field
1: class Person
2: {
3: public Boolean sexo { get; set; }
4: }
5:
6: class Program
7: {
8: static void Main(string[] args)
9: {
10:
11: Person person = new Person();
12: person.sexo = true; //true when is male
13: }
14: }
subtitle:
sexo means gender.
The example above works as expected, the comments in the code helps to understand what is been done.without this comment the purpose is harder to understand.
example 2
1: class Person
2: {
3: public Boolean eHomem { get; set; }
4: }
5:
6: class Program
7: {
8: static void Main(string[] args)
9: {
10:
11: Person person = new Person();
12: person.eHomem = true; //true when is male
13: }
14: }
subtitle:
ehomem means isMale
Still using a boolean field, but now this fields contains a better name. so the readability is getting better.
example 3
1: class Pessoa
2: {
3: public enum Sexo
4: {
5: masculino = 1, feminino
6: }
7: public Sexo sexo { get; set; }
8: }
9:
10: class Program
11: {
12: static void Main(string[] args)
13: {
14:
15: Pessoa pessoa = new Pessoa();
16: pessoa.sexo = Pessoa.Sexo.masculino;
17: }
18: }
subtitle:
sexo=gender,pessoa=person,masculino = male,feminino= female
The code above still works and is easier to understand. I think that this example is the easiest one.
example 4(too much design considerations)
1: class ISexo
2: {
3:
4: }
5: class Masculino : ISexo
6: {
7:
8: }
9: class Feminino : ISexo
10: {
11:
12: }
13: class Sexo
14: {
15: //construtor privado
16: public static ISexo MASCULINO = new Masculino();
17: public static ISexo FEMININO = new Feminino();
18: }
19: class Pessoa
20: {
21:
22: public ISexo sexo { get; set; }
23: }
24:
25: class Program
26: {
27: static void Main(string[] args)
28: {
29:
30: Pessoa pessoa = new Pessoa();
31: pessoa.sexo = Sexo.MASCULINO;
32: }
33: }
The code below is still easy to understand, but there are too much code for a easy problem.
After all the most important advice is mix abstraction with pragmatism, so we will be able to show our desires easily.
ps:Thank Sidney for your advices.
Testes unitários ASP.NET MVC
0Fala Galera, ontem estava trabalhando em um dos meus projetos pessoais e me encontrei meio perdido, fiquei uns 10 minutos debuggando.. isso porque? bem neste projeto desenvolvemos usando testes unitários, testes são realmente uma ferramente essencial quando estamos falando de refatorações ou até mudanças comportamentais no código.
Eu participo de um grupo de arquitetura que está rolando uma thread sobre testes unitários, acho que a principal pergunta quando falamos de testes é sobre como vamos escrever testes, que comportamentos devemos testar.. Eu já pesquisei bastante sobre testes unitários e achei poucas dicas sobre como escrever testes, depois de um tempo aprendi que este conhecimento é obtido praticando! sim, praticando!
Meu início com os testes unitários não foi facil, eu escrevia testes me baseando no comportamento default esperado com o uso da função testada, acho que no início está é uma maneira eficiente de escrever testes. Depoisde um tempo vi que testes podem fazer mais, podem validar contratos definidos pelos métodos, sendo assim comecei a testar condições comuns que poderiam fazer o método quebrar, foi então que aprendi que testes podem esperar uma exceção.Hoje eu uso testes de maneira muito mais eficiente se comparado quando comecei, e olha que isso tem mais ou menos 1 ano.
Como foi dito no início do post, eu uso testes unitários no meu projeto. Este projeto usa ASP.NET MVC, no MVC é realmente muito mais facil de testar a execução das páginas pois na verdade testamos os controller(no WebForm é melhor usar o selenium). No ASP.NET MVC, é necessário usar objetos Fake para testar os controller de maneira simples, código para fazer é simples e já foi desenvolvido pelo stephenwalther. O código pode ser acessado aqui no meu projeto(Test->WebUI->FakeObjects), nesta pasta estão os arquivos necessários e aqui um exemplo de uso.
É isso galera, espero que a dica seja boa.. uma maneira facil de testar usando asp.net mvc
Refatoração para padrões
0
Fala galera, como mencionei em uns posts anteriores estou comprei o livro refatoração para padrões. Ontem iniciei a leitura e acho que já valeu a pena! Sinceramente esperava um “guia” de refatorações envolvendo padrões, algo similar ao livro de Refatoração do Fowler, mas achei muito mais.
O livro foi escrito pelo Joshua Kerievsky, o cara é evangelista de programação extrema e padrões, sendo assim ele responde uma pergunta que eu vinha me fazendo.
“A programação extrema prega o projeto no momento certo e com a solução mais simples para um dado problema. Os padrões são soluções extensíveis e reutilizáveis e adicionam um pouco de complexidade ao projeto. Como deve ser a utilização de padrões em projetos que seguem o XP?”
A capa do livro responde minha pergunta.
“Refatoração para padrões”
Como?
“O autor prega que durante uma refatoração é um bom momento para inserir ou projetar em direção aos padrões”
Seguindo o método acima conseguimos resolver dois problemas recorrentes no desenvolvimento de software, o primeiro deles o excesso de “projeto” no início do desenvolvimento, este seria o grande investimento em soluções super extensíveis que podem não ser usadas(YAGNI). O segundo problema ainda pode ser pior que o primeiro, esse acontece quando nenhum investimento no projeto foi feito.
O livro é de grande serventia para aqueles que usam XP como metodologia ou ainda todos aqueles que se preocupam com o momento certo de inserir um padrão de projeto no código.
Refatorando Interfaces
0Fala galera, tudo ok? Espero que sim. Estava lendo o grande livro sobre refatoração do M.Fowler e atentei para uma refatoração legal. A refatoração em questão trata de alterações em interfaces publicadas, interfaces publicadas são interfaces que já estão sendo utilizadas por diferentes partes do sistema Nós sabemos que as vezes alterar o nome de um método pode fazer toda a diferença, mas e quando você não tem conhecimento sobre todos os lugares em que a interface foi usada? Bem, o Fowler indica que a nova interface seja criada e que a interface “antiga” seja mantida. A interface antiga deve fazer uma chamada à nova interface e esta deve ser marcada como obsoleta. Não sei quanto a vocês, mas eu realmente altero algumas interfaces durante minhas refatorações, sabendo que eu programo eu.NET procurava uma boa maneira de “marcar” interfaces como obsoletas eu fazia assim
Refatorando um método
0Fala galera, Hoje eu estava refatorando uma “Tela” do sistema em que trabalho quando me deparei com o seguinte problema: Eu possuo um método que tem um parâmetro.
private void LoadServiceOrder(Int32 serviceOrderId)
Esta função usa o serviceOrderId para carregar uma Ordem de serviço. Entretanto os desenvolvedores asp.NET devem saber que as páginas .aspx possuem um recurso chamado ViesState, e que nós podemos armazenar algumas informações na mesma. Eu armazeno o serviceOrderId na ViewState pois recupero esta informação de outra página no load da página corrente.
É claro que poderia fazer isso de outras formas evitando o uso da ViewState porem este é o padrão adotado.Bem, o problema é o seguinte: como vocês podem reparar o meu método recebe um valor como parâmetro que ele mesmo pode obter, visto que é posso acessar a ViewState do mesmo. Vale a pena lembrar que estou falando de métodos usados no aspx, não se tratam de métodos que compõem as regras de negócio. Tendo esta dúvida recorri aos compêndios e obtive a seguinte explicação:
“Veja os parâmetros existentes. Você pode solicitar a informação de que precisa a um desses objetos? Caso negativo, faria sentido dar a eles um método para fornecer esta informação? Para que você está usando a informação?esse comportamento deveria estar em outro objeto, o que possui a informação? ”
Refatoração aperfeiçoando o projeto de codigo existente – M.Fowler
Analisando meu caso eu o enquadro nesta descrição, pois posso obter o valor de dentro do método. Entretanto quando removi o parâmetro do método achei que a interface não ficou boa.
private void LoadServiceOrder()
Não achei que estava claro qual ordem de serviço está sendo carregada. Ainda escrevendo o post achei que se a assinatura fosse:
private void ShowLoadedServiceOrder()
Meu objetivo ficaria claro, exibo uma ordem de serviço que já foi carregada. O que vocês acham? Já passaram por alguma coisa semelhante? É isso até mais.
Refatorando com o visual Studio
0
Fala galera,desculpe a ausência do blog mas fiquei com preguiça de postar mesmo rsrs. Bem,desta vez vou falar sobre o suporte a refatoração fornecido Poe algumas ferramentas.Mesmo que você não seja um entusiasta da refatoração certamente você já precisou renomear um método ou qualquer outra estrutura.Eu sei que existem ferramentas com um amplo suporte para a refatoração.Das IDEs que eu conheço as que fornecem o recurso são: Visual Studio, ZendStudio, Eclipse e NetBeans. Vocês devem saber que o visual Studio possui diversas versões. Eu trabalho com a professional, mas tenho a Team System em casa. Eu realmente não me lembro se no VS Express o suporte a refatoração está disponível.Eu ainda não conheço todas as possibilidades fornecidas pelo visual Studio, mas ando usando muito a opção de renomear.No projeto em que trabalho temos uma arquitetura N-tier, logo fica complicado procurar as possíveis referencias as chamadas de métodos. Trocar o nome de um método pode ser perigoso, este perigo aumenta com o tamanho do projeto. Claro que existem maneiras de facilitar esta alteração, neste post eu falo um pouco sobre uma possível solução.Pra quem quiser conferir como funciona no visual Studio basta selecionar o nome do método, clicar com o botão direito do mouse e selecionar a opção refaoração->renomear. Ele exibe a opção de procurar o método em strings e em outras estruturas.. É isso, eu achei muito legal quando vocês tiverem de renomear um método olhem esta opção. Grande abraço!
CTRL+C & CTRL+V os inimigos do programador
0Fala galera, um post voltando a discutir o que eu gosto.Hoje vamos falar um pouco sobre boas praticas de desenvolvimento de software.Acho que vocês já escutaram alguns dos mais variados apelidos do copiar & colar.Um dos apelidos é multiplicador de erros.Bem, Desenvolvedores devem eliminar codigo duplicado certo? então desenvolvedores não devem utilizar o copiar & colar pois ele faz exatamente isso. No livro Refatoração:Aperfeiçoando o projeto de código existente M.Fowler aborda o codigo duplicado como sendo o pior dos odores. Não estou sugerindo que vocês retirem as teclas de copiar e colar. Estou sugerindo muita atenção quando usarem este recurso.Até mais galera..
Refatorar ou ganhar desempenho?
0Ola, Neste post colocarei em questão duas muito importantes no processo de desenvolvimento de software,A refatoração e a busca do melhor desempenho.Muitas pessoas acreditam que refatorando o código, tornando-o mais simples e estável podem estar perdendo ou desperdiçando um pouco do desempenho de sua aplicação.Porém pouco tempo antes de estar criando este post tomei nota de algumas informações importantes, Entretanto acredito que nos, desenvolvedores, não tenhamos conhecimento, pois aprendi este conceito na aula de arquitetura de computadores(quem disse que estudar hardware não é importante?!).Existe um conceito relacionado ao processamento que dita o seguinte: na maior parte das vezes somente de 10% a 20% de código fonte de um programa é realmente “executado”(requer alto desempenho),Então, com tal informação podemos chegar a conclusão que se tentamos melhorar o desempenho de 100% do nosso código e até 90% pode ter sido perda de tempo. Portanto podemos concluir que se apostarmos na refatoração, dando valor a clareza e a qualidade do código e projeto produzido obteremos resultados mais interessantes. Quais os benefícios? a resposta é facil, conseguiremos um projeto de código simples e estável, além de obtermos um código simples, fácil de alterar para depois caso seja necessário obter desempenho.Creio que fica claro que estou do lado da refatoração.Como já contei no post anterior ando lendo um livro do M.Fowler, e acredite que no livro dele li “exatamente” o que estou aqui postando para vocês, como encontrei este assunto em um bom livro de programação achei que seria interessante compartilhar esta informação com os outros desenvolvedores.Prezados este post termina por aqui, espero que ele tenha sido de grande utilidade para vocês julgarem o que é mais importante no processo de desenvolvimento que estão trabalhando.Acredito que grande parte dos proximos posts sejam relacionados com os processos de desenvolvimento e engenharia de software, assunto este que está me causando grande interesse.Até o proximo post
Refatorar,Obrigação ou Arte?
0O que é: É o processo de alteração de um software de modo que o comportamento externo do código não mude(interfaces inalteradas).Este processo tem o objetivo de tornar o código mais claro e fácil de modificar.
Por que: A refatoração torna seu código mais compreensível e organizado, portanto quando for necessário entender ou alterar o software tal atividade será menos custosa.Falando em custosa a refatoração elimina diversos problemas que podem tornar o seu software caro, como por exemplo extensão do programa ou alterações no código/comportamento.
Ficou interessado? espero em breve trazer mais posts sobre o assunto, mas se você quiser pesquisar um pouco por conta própria adicionarei algumas fontes de pesquisa.
ps: É importante salientar que refatoração exige outros conhecimentos como POO e UML