Escrita de Programas. António Rito Silva - João Pereira

Transcrição

1 Escrita de Programas António Rito Silva - Rito.Silva@ist.utl.pt João Pereira Joao@inesc-id.pt

2 Sumário Caracterização Objectivos Qualidades Técnicas Casos Notáveis Conclusões Escrita de Programas 2

3 Objectivos O desenho pode não ter abordado todos os aspectos da plataforma e do ambiente de programação O código deve ser legível, não apenas por quem o escreveu, mas por todos os membros da equipa Deve-se tirar proveito das características do desenho, das estruturas de dados, e dos construtores da linguagem de programação Escrita de Programas 3

4 Qualidades Simplicidade Conformidade com o desenho Rastreabilidade Escrita de Programas 4

5 Qualidades o código é para ser lido!!!! Escrita de Programas 5

6 Do Desenho à Implementação As qualidades do desenho devem ser preservadas no código Independência Ligação fraca Coesão forte Manter a rastreabilidade, em ambos os sentidos, entre o desenho e o código Escrita de Programas 6

7 Técnicas Normas de codificação Regras de codificação Escrita de Programas 7

8 Normas de Codificação O código é desenvolvido em equipa, os membros da equipa vão Testar o código Modificar o código Reutilizar o código Rever o código É importante que os membros da equipa entendam o código, porque é que se escreveu, e qual é a relação com o seu trabalho É necessário usar as normas de codificação (standards) da empresa Escrita de Programas 8

9 Normas de Codificação Todo o código deve usar as mesmas normas Quais as normas não é tão importante como a sua utilização uniforme em todo o código Mais fácil de manter Mais fácil de entender Se alguém encontra um pedaço de código que não respeita as normas deve-o alterar de imediato Escrita de Programas 9

10 Vantagens das Normas Para quem escreve Ajuda a organizar as ideias Ajuda a evitar os erros Ajuda quando se fazem alterações Ajuda quando se quer recomeçar o trabalho após uma interrupção Ajuda na tradução do desenho para o código Para os outros Facilita os outros a entender o código quando Testam Integram Fazem manutenção Procuram reutilizar Escrita de Programas 10

11 Comentar Métodos Em princípio não é necessário comentar os métodos Se um método é pouco claro pode-se alterar o seu nome ou re-factorizar Apenas devem ser comentados quando: ainda não estão terminados não é claro e a alteração de nome e a re-factorização não foi eficaz se usa um algoritmo pouco usual ou que está publicado em algum lado se foi a causa de um mau desempenho e foi reescrito, deve ser comentado a assinalar esse facto Menos de 1% dos métodos necessitam de ter comentários Escrita de Programas 11

12 Regras de Codificação Estruturas de controlo Algoritmos Estruturas de dados Rever e re-escrever Escrita de Programas 12

13 Estruturas de Controlo A estrutura de controlo é sugerida pelo desenho A implementação deve preservar a estrutura de controlo do desenho Cada componente deve poder ser lido de cima para baixo, sem saltos de controlo Escrita de Programas 13

14 Estruturas de Controlo Generalidade é uma virtude que facilita a leitura, os casos especiais devem estar encapsulados em componentes em que as variações são expressas pelos seus parâmetros As estruturas de controlo resultantes da especificidade da implementação não devem intervir com a estrutura de controlo do desenho Escrita de Programas 14

15 Estruturas de Controlo benefit = minimum; if (age < 75) goto A; benefit = maximum; goto C; if (AGE < 65) goto B; if (AGE < 55) goto C; A: if (AGE < 65) goto B; benefit = benefit * bonus; goto C; B: if (age < 55) goto C; benefit = benefit * 1.5; C: next statement Escrita de Programas 15

16 Estruturas de Controlo if (age < 55) benefit = minimum; elseif (AGE < 65) benefit = minimum + bonus; elseif (AGE < 75) benefit = minimum * bonus; else benefit = maximum; Escrita de Programas 16

17 Algoritmos O desenho pode especificar a classe de algoritmo a usar mas o programador tem muita liberdade de implementação A eficiência e o desempenho são factores que influenciam a codificação dos algoritmos, contudo podem existir custos: Demora mais tempo a codificar É mais complexo de testar É mais difícil de entender É mais complicado de alterar Mais uma vez, é necessário fazer os compromissos necessários em função dos requisitos existentes Cuidado com a impacto dos geradores de código e do hardware sobre as optimizações Escrita de Programas 17

18 Estruturas de Dados Manter o programa simples Re-estruturar os dados pode simplificar os cálculos do programa Uma tabela indexada pode simplificar uma estrutura de controlo pois os indexes são usados num ciclo Usar a estrutura de dados para definir a estrutura do programa Uma estrutura de dados recursiva pode levar à definição de procedimentos recursivos Escrita de Programas 18

19 Estruturas de Dados 1. For the first $10,000 of income, the tax is 10% 2. For the next $10,000 of income above $10,000, the tax is 12 percent 3. For the next $10,000 of income above $20,000, the tax is 15 percent 4. For the next $10,000 of income above $30,000, the tax is 18 percent 5. For any income above $40,000, the tax is 20 percent tax = 0. if (taxable_income == 0) goto EXIT; if (taxable_income > 10000) tax = tax ; else{ tax = tax +.10*taxable_income; goto EXIT; if (taxable_income > 20000) tax = tax ; else{ tax = tax +.12*(taxable_income-10000): goto EXIT; if (taxable_income > 30000) tax = tax ; else{ tax = tax +.15*(taxable_income-20000); goto EXIT; if (taxable_income < 40000){ tax = tax +.18*(taxable_income-30000); goto EXIT; else tax = tax *(taxable_income-40000); EXIT; Escrita de Programas 19

20 Estruturas de Dados Define a tax table for each bracket of tax liability Bracket Base Percent , , , , Simplified algorithm for (int i=2; level=1; i <= 5; i++) if (taxable_income > bracket[i]) level = level + 1; tax = base[level]+percent[level]*(taxable_income bracket[level]);

21 Rever e Re-escrever Quando se verifica que o fluxo de controlo está confuso, ou o processo de decisão é difícil de entender, ou os saltos incondicionais difíceis de eliminar, deve-se retornar ao desenho para: Saber se o problema está no desenho Saber se o problema está na tradução Nunca remendar!! Escrita de Programas 21

22 Casos Notáveis Extrair método In Refactoring: Improving the Design of Existing Code. Martin Fowler. extractmethod.html Introduzir variáveis explicativas In Refactoring: Improving the Design of Existing Code. Martin Fowler. introduceexplainingvariable.html Escrita de Programas 22

23 Extrair Método void printowing() { Enumeration e = this.orders.elements(); double outstanding = 0.0; // print banner System.out.printin ("************************"); System.out.printin ("**** Customer Owes *****"); System.out.printin ("************************"); // calculate outstanding while (e.hasmoreelements()) { Order each = (Order) e.nextelement(); outstanding += each.getamount(); //print details System.out.println("name:" + this.name); System.out.println("amount" + outstanding); Escrita de Programas 23

24 Extrair Método void printowing() { Enumeration e = this.orders.elements(); double outstanding = 0.0; printbanner(); // calculate outstanding while (e.hasmoreelements()) { Order each = (Order) e.nextelement(); outstanding += each.getamount(); //print details System.out.println("name:" + this.name); System.out.println("amount" + outstanding); void printbanner() { System.out.printin ("************************"); System.out.printin ("**** Customer Owes *****"); System.out.printin ("************************"); Escrita de Programas 24

25 Extrair Método void printowing() { Enumeration e = this.orders.elements(); double outstanding = 0.0; printbanner(); // calculate outstanding while (e.hasmoreelements()) { Order each = (Order) e.nextelement(); outstanding += each.getamount(); printdetails(outstanding); void printdetails(double outstanding) { System.out.println("name:" + this.name); System.out.println("amount" + outstanding); Escrita de Programas 25

26 Extrair Método void printowing() { printbanner(); double outstanding = getoutstanding(); printdetails(outstanding); double getoutstanding() { Enumeration e = this.orders.elements(); double outstanding = 0.0; while (e.hasmoreelements()) { Order each = (Order) e.nextelement(); outstanding += each.getamount(); return outstanding; Escrita de Programas 26

27 Extrair Método Consequências Aumenta legibilidade do código Aumenta potencial de reutilização Facilita testes Reduz duplicação de código Escrita de Programas 27

28 Introduzir Variáveis Explicativas double price() { // price is base price - quantity discount + shipping return this.quantity * this.itemprice - Math.max(0, this.quantity - 500) * this.itemprice * Math.min(this.quantity * this.itemprice * 0.1, 100.0); double price() { // price is base price - quantity discount + shipping final double baseprice = this.quantity * this.itemprice; return baseprice - Math.max(0, this.quantity - 500) * _itemprice * Math.min(this.quantity * this.itemprice * 0.1, 100.0); Escrita de Programas 28

29 Introduzir Variáveis Explicativas double price() { // price is base price - quantity discount + shipping final double baseprice = this.quantity * this.itemprice; return baseprice - Math.max(0, this.quantity - 500) * this.itemprice * Math.min(basePrice * 0.1, 100.0); double price() { // price is base price - quantity discount + shipping final double baseprice = this.quantity * this.itemprice; final double quantitydiscount = Math.max(0, this.quantity - 500) * this.itemprice * 0.05; return baseprice - quantitydiscount + Math.min(basePrice * 0.1, 100.0); Escrita de Programas 29

30 Introduzir Variáveis Explicativas double price() { final double baseprice = this.quantity * this.itemprice; final double quantitydiscount = Math.max(0, this.quantity - 500) * this.itemprice * 0.05; final double shipping = Math.min(basePrice * 0.1, 100.0); return baseprice - quantitydiscount + shipping; Escrita de Programas 30

31 Introduzir Variáveis Explicativas if ((platform.touppercase().indexof("mac") > -1) && (browser.touppercase().indexof("ie") > -1) && wasinitialized() && resize > 0 ) { // do something final boolean ismacos = platform.touppercase().indexof("mac") > -1; final boolean isiebrowser = browser.touppercase().indexof("ie") > -1; final boolean wasresized = resize > 0; if (ismacos && isiebrowser && wasinitialized() && wasresized) { // do something Escrita de Programas 31

32 Conclusões P87 Evitar Truques Existem muitas formas de justificar a utilização de truques: Os programadores querem mostrar que são muito inteligentes Os responsáveis da manutenção do software quando se aperceberem dos truques vão perceber como o programador foi inteligente e também vão concluir acerca da sua própria esperteza Segurança Mas como afirma Allen Marco os truques são a utilização idiota da inteligência Escrita de Programas 32

33 Conclusões P88 Evitar Variáveis Globais Torna difícil identificar que parte do software corrompeu uma variável global P89 Escrever para Ler de Cima- Para-Baixo Torna o código mais legível P90 Evitar Efeitos Colaterais São muito difíceis de detectar Escrita de Programas 33

34 Conclusões P91 Utilizar Nomes com Significado Os programadores passam apenas 10-15% do tempo a escrever código Reduz o número de comentários P92 Escrever Programas para as Pessoas No início o recurso mais valioso era o computador mas hoje em dia são as pessoas Trabalho de desenvolvimento Trabalho de manutenção... Escrita de Programas 34

35 Conclusões P93 Utilizar as Estruturas de Dados Adequadas As estruturas de dados e a estrutura do programa que manipula esses dados estão intimamente relacionadas P94 Legível Antes de Eficiente É mais fácil adaptar um programa legível para ser mais eficiente do que adaptar um programa eficiente para ser legível Ambicionar o desenvolvimento iterativo Escrita de Programas 35

36 Conclusões P100 Código Estruturado Não é Necessariamente Bom Código Código com objectos não é necessariamente bom código... P101 Não Encaixar Comandos com Muita Profundidade Evitar ir para além de 3 níveis de profundidade Escrita de Programas 36

37 Conclusões P102 Usar as Linguagens Apropriadas... mas se cliente quiser uma linguagem que não é a mais apropriada do ponto vista técnico... P103 A Linguagem de Programação não pode Servir de Desculpa Bons programadores são bons programadores independentemente da linguagem Escrita de Programas 37

38 Conclusões P105 Formatar os Programas Indentação incoerente Indentação incorrecta (que parece estar coerente) pior que indentação incoerente (alinhar um else com o if errado) Escrita de Programas 38

39 Referências Pfleeger01, Capítulo6. David95, Alguns Princípios do Capítulo 5. Martin Fowler. Extract Method and Introduce Explaning Variable. In Refactoring: Improving the Design of Existing Code index.html Escrita de Programas 39