Reuso de Software 07/03/2012

   # # # # # # # # # # # # #
  # Reuso de Software       #
  # Prof Eduardo Figueiredo #
  # notasdogarcia.blog.com  #
   # # # # # # # # # # # # #

  // Ele citou um pouco da bibliografia.

  Hoje vamos falar de vários pontos gerais sobre o curso.

  Reuso de software é uma abordagem de desenvolvimento com o objetivo de máximar o uso de softwares já existentes.

  Várias ferramentas foram criadas para facilitar o reuso de softwares:
    - Bibliotecas.
    - Classes de objetos.
    - Componentes.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  O tipo mais comum de re-uso é o reuso de funções e objetos.

  O reuso de componentes diz respeito a um bloco maior da estrutura de um programa, que pode ser re-aproveitada.

  Reuso de sistema inteiro é reutilizar todo o código de um programa.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Vantagens do reuso:
    - Redução de custos e tempo de entrega.
    - Maior confiabilidade do produto (ele já foi testado antes).
    - Do ponto de vista do cliente há um menor risco de atrazo no desenvolvimento.
    - Voce pode gerar interfaces padrões reutilizaveis facilitando o uso do software.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Potenciais Problemas:
    - Na questão de manutenção, um componente re-usado pode não ser compátivel com alguma atualização futura, e editar o código que voce não fez será mais dificil.
    - Falta de apoio ferramental, não existem ferramentas voltadas para isso.
    - É caro manter uma biblioteca para reuso, pois é dificil encontrar e entender o software desejado.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Planejamento para reuso.

    - O reuso exige um planejamento de toda empresa.
    - Muitas empresas podem criar vários sistemas com base em um mesmo conjunto de componentes.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Cronograma e Ciclo de Vida
    - Se o cronograma é aperdado pode não valer a pena fazer um software reutilizável, mas pode valer a pena re-usar.
    - Se o software vai ser utilizado por muito tempo pode ser inteligente fazer o software sem reuso de outros softwares.
      Pois componentes de terceiros podem ser de díficil manutenção.
    - Por outro lado a manutenção pode ficar mais fácil se seu código for feito para re-uso.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Equipe e Domínio
    - Conhecimento e experiencia na equipe é importante, pois é uma tarefa complexa.
    - Deve ser considerado que em alguns dominios pode ser mais fácil ou mais difícil encontrar bibliotecas para reuso.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Abordagens de Reuso:
  // Aqui foram citadas vários itens importantes na área, e destacou as que ele vai citar no curso.
  // Pode copiar isso do slide.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Blibliotecas de Software são uma forma bem comum de reuso.
  Geralmente implementam coisas como acesso a recusos e banco de dados, conversão de dados entre formatos, estruturas de dados abstratos, como fila, pilha, arvore etc.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Framework
    - Um framework é uma aplicação incompleta, onde o conjunto de classes e interfaces geram uma estrutura generica.
    - Um sistema é implementado pela adição de componentes para preencher partes do projeto.

  // Na vida real nem todo framework é exatamente incompleto, alguns funcionam mesmo sem adição de novo código.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Tipos de Framework:
    - Frameworks de infra-estrutura, como comunicação, interfaces de usuário e compiladores.
    - Frameworks de integração que apoiam a troca de informação entre componentes.
    - Frameworks de aplicações, por exemplo uma que facilite o desenvolvimento de aplicações Web.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Frameworks devem ser usados atravez de estensão.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Principal problema:

    Frameworks são complexos e levam um longo tempo para serem compreendidos.
    As vezes voce quer uma funcionalidade simples de um framework complexo então talvez valha mais apena implementar voce mesmo.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Padrão de projeto e Padrão de arquitetura

CONCEITO
  Padrão de projeto são um conjunto de boas soluções para prroblemas recorrentes, que permitem o fácil reuso
  e servem como uma linguagem comum entre códigos diferentes.

  Todo padrão é composto por:
    - Nome (para a comunicação entre programadores).
    - Descrição do problema.
    - Descrição da solução padrão.
    - Vantagens/Desvantagens do uso.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Exemplo de um padrão:

    Observadores: Imagina que voce quer publicar uma estatistica em mais de um tipo de gráfico.
                  Voce pode adicionar uma lista de funções de atualização à estrutura estatistica, que chama as funções em questão sempre que um valor for alterado.

  Nome: Observer
  Descrição do problema: Atualização de dados em vários locais.
  Descrição da solução padrão: Uma lista de referencias para serem atualizadas, contidas no objeto estatistico.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Padrões Arquiteturais:

CONCEITO:
  São padrões mais baixo nível que descrevem as estruturas básicas de seu programa.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Exemplo de Padrão de Arquitetura:

  Arquitetura em Camadas:
    - Orgnaniza o sistema em camadas, onde cada camada só se comunica com as camadas superior e inferior, e repassa as informações necessárias de cima para baixo.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Exemplo de arquitetura em camadas:
    Camada de Interface.
    Camada de Processamento.
    Camada de Dados.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Reuso de Modelos e geração de código:

    A proposta do re-uso de modelos é a idéia de que voce re-usa modelos, e após montar seu modelo real voce implementa o código.
    A vantagem é que um modelo é mais abstrato e portanto mais estável tendo um tempo de vida mais longo.
    Também é de compreensão mais fácil e permite melhor comunicação.

    Reuso ainda é uma técnica pouco adotada, porém é uma aposta que pode dar certo, já que hoje os softwares são mais complexos e exigem maior abstração.

    Um modelo deveria ser independente da linguagem assim como uma linguagem é independente do hardware.

    Assim seria possível criar um compilador de modelos.
    // Já existem coisas próximas disso, mas não literalmente isso, os que existem geram apenas os modelos.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Problemas potenciais:
    - Imaturidade do MDD hoje.
    - Falta de suporte de ferramentas.
    - Isso tira um pouco o papel do programador, o que pode gerar uma resistencia.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  // O professor pulou a parte sobre componentes para não atrasar o horário.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Linhas de Produtos:
    Quando uma empresa cria vários aplicativos semelhantes, porque não reaproveitar a maior parte, e criar uma base comum de reaproveitamento.

  Extração de linha:
    Este é o termo usado para a criação de uma linha de produtos, já que voce precisa encontrar a parte que é comum em seu vários produtos
    e extrai-la para ser usada nos próximos produtos.

  // Ou seja isso é o processo inverso, ao invés de criar partes reusáveis, voce cria e depois vê o que está efetivamente sendo re-usado e extrai isso.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Os Componentes de uma Linha de Produtos são:
    - Os mandatórios (todos tem)
    - Os opicionais (depende por exemplo do interesse do cliente)

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  // Fim da aula.
  // Prox aula vamos falar mais de reuso de objetos e funções bibliotecas e frame works.