Porque utilizar o controle de versões

Um sistema de controle de versão, VCS (do inglês version control system) ou ainda SCM (do inglês source code management), é 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
Imagine o seguinte:
Você chega lá na empresa que você está desenvolvendo um projeto, passou dias desenvolvendo e logicamente há outras pessoas alterando os arquivos do projeto, porém nenhuma delas utilizaram o controle de versão para informar a você das modificações atuais, ou seja você está la com a sua versão porém já pode ter ocorrido uma série de alterações. Isso nos mostra como é importante termos o controle de versão , uma que sem ele você pode afetar o prazo de entrega já que ficou todo bagunçado e você vai ter todo um trabalho de ir atrás dos arquivos modificados para um futuro merge ( em outro post falarei de umas ferramentas boas para isto) na qual demanda muito tempo e sujeito a mais erros.
A principal função do sistema de controle de versão é armazenar todo o histórico de desenvolvimento do documento ( todas suas modificações nos arquivos são registradas), desde o primeiro envio até sua última versão. Isso permite que seja possível resgatar uma determinada versão de qualquer data mais antiga, evitando desperdício de tempo no desenvolvimento para desfazer alterações quando se toma algum rumo equivocado.
Alguns exemplos de softwares que fazem controle de versoes
Soluções comerciais

• Microsoft Visual SourceSafe (VSS) – produto da Microsoft para controle de versão, integrado a muitas IDEs da Microsoft.
• Rational ClearCase – produto da IBM para controle de versão.
• Borland StarTeam – produto da Borland para controle de versão e de equipe.

Soluções livres

• Concurrent Version System (CVS) – software livre clássico e bem testado.
• Subversion (SVN)
• Git – Software para controle de versão distribuído com foco na velocidade.
• MediaWiki – software livre que possui um sistema integrado de controle de versões. Sites com os projetos da Wikimedia, tal como a Wikipédia mantém o sistema MediaWiki para o controle das versões dos documentos. Esse sistema permite o trabalho simultâneo de milhares de voluntários.
• GNU CSSC
• Revision Control System (RCS)
• Bazaar
• Darcs
• Mercurial
• Monotone
• SVK

Eu fiz o uso do GIT  e do SVN, ambos me trouxeram uma prática muito boa de versionamento, no meu caso eu estava trabalhando com linux embarcado, caso acontecesse algum erro aparentemente “irreparavel” ou então se eu tivesse meus arquivos atuais corrompidos, ao invés de ter que reinstalar o kernel ou ir atras destes arquivos com alguém, era só eu voltar para uma versão anterior que estaria lá no meu git ( falarei mais do git em breve) .

Fica aqui mais uma dica, o projeto sem estas boas práticas de software pode comprometer a confiabilidade/qualidade do seu projeto.

Fonte: Wikipedia

Read More

Confiabilidade de software

 

1 - Introdução: Software Embarcado - Desastres?

Com o advento da era tecnológica, computadores, bem como os softwares que rodam neles, estão desempenhando um papel vital em nossa vida diária. Podemos não ter notado, mas aparelhos como máquinas de lavar, telefones, televisões e os relógios, estão tendo os seus componentes analógicos e mecânicos substituído pelos processadores e software.
A indústria de computadores/tecnologia está crescendo exponencialmente. Com um custo reduzido e controle melhorado, processadores e sistemas controlados por software oferecem um design compacto, manipulação flexível, ricos em recursos e custo competitivo. As pessoas costumavam acreditar que o "software nunca quebra." Intuitivamente, ao contrário de peças mecânicas, tais como parafusos, alavancas, ou componentes eletrônicos como transistores, software, capacitor vai ficar "como está" se não houver problemas de hardware que altera o conteúdo ou o caminho de armazenamento de dados. Software não enferruja, não tem idade, e nem desgaste. Não há nenhuma restrição ambiental para operar o software, enquanto o processador é executado em hardware podem operar. Além disso, o software não tem forma, cor, material e massa. Ele não pode ser visto ou tocado, mas tem uma existência física e é crucial para a funcionalidade do sistema. Sem ser provado o contrário, as pessoas otimistas que pensam que uma vez que o software foi criado pode ser executado corretamente para sempre. Uma série de tragédias e caos causado pelo software comprova que isso é errado. Esses eventos sempre terão seu lugar na história. Software pode tomar decisões, mas pode apenas com pouca confiabilidade ( sujeito a bugs/crash) , como seres humanos erram. O destróier britânico Sheffield foi afundado porque o sistema de radar identificou um míssil como "amigável". O que foi uma tragédia para o sistema de defesa.
O software também pode ter pequenos erros imperceptíveis ou desvios que podem culminar em um desastre. Em 25 de fevereiro de 1991, durante a Guerra do Golfo, o erro corte que perdeu 0,000000095 segundos na precisão, fez o míssil Patriot errar em interceptar um míssil Scud. 28 vidas foram perdidas. Corrigir problemas pode não necessariamente tornar o software mais confiável. Pelo contrário, novos problemas sérios podem surgir. Em 1991, depois de mudar três linhas de código em um programa de sinalização, que contém milhões de linhas de código, os sistemas de telefonia local na Califórnia e ao longo da costa leste parou. (interrupção por telefone) .Uma vez funcionando perfeitamente software também pode quebrar se o ambiente de execução for modificado. Depois do sucesso do foguete Ariane 4, o vôo inaugural do Ariane 5 acabou em chamas, enquanto defeitos de projeto no software de controle foram revelados pela rápida velocidade horizontal do novo foguete.
Há histórias muito mais assustadoras para contar. Isto faz-nos saber se o software é confiável em tudo, se devemos usar o software de segurança, aplicações críticas. Aviões, marca passos , máquinas de radioterapia entre varias outras aplicações dentro da área da biomedicina e etc, um simples erro de software pode facilmente reivindicar as vidas das pessoas. A confiabilidade do software é simplesmente uma questão de vida ou morte. Será que estamos incorporando potenciais catástrofes enquanto incorporamos o nosso software em sistemas?

Conceitos-chave:

Definição
De acordo com ANSI, Confiabilidade de Software é definido como: A probabilidade de software operar sem falhas durante um determinado período de tempo em um ou mais ambientes especificados. Apesar de confiabilidade de software ser definida como uma função probabilística, e vem com a noção de tempo, devemos notar que, diferente da tradicional confiabilidade de Hardware, confiabilidade de software não é uma função direta do tempo. Eletrônicos e peças mecânicas podem tornar-se "velho" e se desgastam com o tempo e uso, mas o software não irá enferrujar ou desgastar durante seu ciclo de vida. O software não irá mudar com o tempo a menos que intencionalmente modificado ou atualizado. ( Aqui sim entram as N questões da fase de testes)
Confiabilidade de software é um importante atributo de qualidade de software, juntamente com a funcionalidade, usabilidade, desempenho, facilidade de manutenção, capacidade, instalabilidade, manutenção e documentação. É difícil de alcançar, porque a complexidade do software tende a ser elevada. Embora qualquer sistema com um alto grau de complexidade, será difícil chegar a um certo nível de confiabilidade, desenvolvedores de sistemas tendem a empurrar a complexidade para a camada de software, com o rápido crescimento do tamanho do sistema e a facilidade de fazê-lo através da sua modernização . Apesar da complexidade do software estar inversamente relacionado com a confiabilidade, ele está diretamente relacionado a outros importantes fatores de qualidade de software, especialmente a funcionalidade, capacidade e etc. Ressaltando essas características tendem a adicionar mais complexidade ao software.

Insuficiência no mecanismos de Software

As falhas de software pode ser devido a erros, ambigüidades, omissões ou má interpretação da especificação de que o software deve satisfazer, descuido ou incompetência na escrita de código, testes inadequados ou inesperados uso incorreto do software ou outros problemas imprevistos.Software e hardware têm diferenças fundamentais que as tornam diferentes mecanismos de falha. Falhas de hardware são principalmente falhas físicas , enquanto que falhas de software são falhas de concepção , que são mais difíceis de visualizar, classificar, detectar e corrigir. Falhas no projeto estão intimamente relacionadas com fatores humanos e do processo de design, que não temos uma sólida compreensão. Em hardware, defeitos de projeto também podem existir, mas falhas físicas normalmente dominam.

Software x Hardware  :

Falha : defeitos de software são principalmente erros na sua fase de concepção.
Desgastar-se : Software não desgasta porem erros podem ocorrer sem aviso prévio.
Conceito de sistemas reparáveis : reiniciar periódicamente pode ajudar a resolver problemas de software.
Tempo de dependência e de ciclo de vida : a confiabilidade do software não é uma função do tempo operacional.
Fatores ambientais : Não afetar a confiabilidade do software, exceto que ele pode afetar as entradas do programa.
Previsão Confiabilidade : confiabilidade de software não pode ser previsto a partir de qualquer base física, já que depende totalmente sobre fatores humanos em design. ( Fase de projeto)
Redundância : não é possível melhorar a confiabilidade do software se os componentes de software idênticos são usados.
Interfaces : interfaces de software são puramente conceitual diferente visual.
Taxa de falhas : Normalmente não é previsível a partir de análises separadas.
Construído com componentes padronizados : Bem-entendido e amplamente testada peças padronizadas irá ajudar a melhorar a durabilidade e confiabilidade. Mas, na indústria de software, não observamos esta tendência. A reutilização de código tem sido em torno de algum tempo, mas a uma extensão muito limitada.

Melhoria de Software  - Técnicas de Confiabilidade

Métodos de engenharia de boa qualidade podem melhorar a confiabilidade do software em grande parte.
Antes da implantação de produtos de software, verificação, teste e validação são etapas necessárias. O teste de software é muito utilizado para acionar, localizar e remover os defeitos de software.  Várias ferramentas de análise, tais como análise de tendências, análise de árvore de falhas, defeitos classificação ortogonal e métodos formais, etc, também podem ser usados para minimizar a possibilidade de ocorrência de defeito após o lançamento e, portanto, melhorar a confiabilidade do software.
Após a implantação do produto , dados de entrada/saida podem ser reunidas e analisadas para estudar o comportamento do sistema. Tolerância a falhas ou  previsão de falhas será útil para minimizar a ocorrência de falhas ou o impacto da falha no sistema.

Conclusões

Confiabilidade de software é uma parte fundamental na qualidade do sistema. O seu estudo pode ser categorizadas em três partes: a medição, modelagem e aperfeiçoamento.
Software de modelagem  amadureceu a tal ponto que resultados significativos podem ser obtidos através da aplicação de modelos adequados para o problema. Há muitos modelos existentes atualmente, mas nenhum modelo pode capturar uma quantidade necessária das características do software. Suposições e abstrações devem ser feitas para simplificar o problema. Não existe um modelo único, que é universal a todas as situações.
Software de medição de confiabilidade é ingênuo. Medição está longe de ser comum em software, como no campo da engenharia. "Como é bom o software, quantitativamente?" Tão simples como a pergunta é: ainda não há uma boa resposta.
Confiabilidade de software não pode ser medido diretamente, então outros fatores relacionados são medidos para estimar a confiabilidade do software e compará-lo entre os produtos. Processo de desenvolvimento, faltas e falhas encontradas são todos fatores que garantem a boa qualidade do sistema.
Como o software cada vez mais está se arrastando em sistemas embarcados, devemos nos certificar de que não estamos incorporando catástrofes. Se não for analisada com cuidado, a confiabilidade do software pode ser o gargalo da confiabilidade do sistema como um todo. Garantir isto não é tarefa fácil. Por mais difícil que o problema seja jamais deixe de lado esta questão da qualidade do sistema, pois sem isso não podemos garantir um produto livre de prejuizos e possiveis acidentes irreparaveis.Vamos todos utilizar varios processos já existentes no campo da engenharia de software.

Chato?

Sempre escuto pessoal comentando "ah documentação é chato!" , "pra que eu preciso disso? é só implementar isto e mais aquilo" , ah pergunta é: Você tem certeza que só você irá mexer no sistema? Você vai se lembrar de todas as alterações feitas? . Devemos praticar todos os métodos de engenharia de software se desejamos ter qualidade no nosso sistema, pois é mais facil corrigir uma falha do presente do que ignora-lo e no futuro a somátoria das pequenas falhas tornar um buraco enorme que irá até depreciar a imagem da empresa e dependendo da área que ele for implementado colocar em fase de risco para os utilitarios deste.

Fonte: http://www.ece.cmu.edu/~koopman/des_s99/sw_reliability/

Read More

Utilizando jExcelAPI

JExcel é uma biblioteca para integração do Microsoft Excel para aplicações Java .Com esta biblioteca você possui classes que nos fornecem funções para a criação, escrita e leitura de arquivos para o excel em tempo real. A vantagem é que dependendo da aplicação que desejamos não necessitamos de um banco de dados já que no caso seria a propria planilha o armazenamento das informações que queremos. A plataforma requerida é a JVM (Java Virtual Machine) que significa que o código desenvolvido com JExcel pode ser executado em diferentes sistemas operacionais sem nenhuma modificação. O exemplo a seguir é uma aplicação que cria um novo documento em excel e escreve os dados em diferentes folhas deste.

   1: import java.io.*;

   2: import jxl.*;

   3: import java.util.*;

   4: import jxl.Workbook;

   5: import jxl.write.DateFormat;

   6: import jxl.write.Number;

   7:  

   8: import jxl.write.*;

   9: import java.text.SimpleDateFormat;

  10:  

  11: class  create

  12: {

  13:   public static void main(String[] args) 

  14:   {

  15:     try

  16:     {

  17:       String filename = "entrada.xls";

  18:       WorkbookSettings ws = new WorkbookSettings();

  19:       ws.setLocale(new Locale("en", "EN"));

  20:       WritableWorkbook workbook = 

  21:         Workbook.createWorkbook(new File(filename), ws);

  22:       WritableSheet s = workbook.createSheet("Folha1", 0);

  23:       WritableSheet s1 = workbook.createSheet("Folha1", 0);

  24:       writeDataSheet(s);

  25:       writeImageSheet(s1);

  26:       workbook.write();

  27:       workbook.close();      

  28:     }

  29:     catch (IOException e)

  30:     {

  31:       e.printStackTrace();

  32:     }

  33:     catch (WriteException e)

  34:     {

  35:       e.printStackTrace();

  36:     }

  37:   }

  38:  

  39:   private static void writeDataSheet(WritableSheet s) 

  40:     throws WriteException

  41:   {

  42:  

  43:     /* Formata a fonte */

  44:     WritableFont wf = new WritableFont(WritableFont.ARIAL, 

  45:       10, WritableFont.BOLD);

  46:     WritableCellFormat cf = new WritableCellFormat(wf);

  47:     cf.setWrap(true);

  48:  

  49:     /* Cria um label e escreve a data em uma célula da folha*/

  50:     Label l = new Label(0,0,"Data",cf);

  51:     s.addCell(l);

  52:     WritableCellFormat cf1 = 

  53:       new WritableCellFormat(DateFormats.FORMAT9);

  54:  

  55:     DateTime dt = 

  56:       new DateTime(0,1,new Date(), cf1, DateTime.GMT);

  57:  

  58:     s.adCell(dt);

  59:     

  60:     /* Cria um label e escreve um float numver em uma célula da folha*/

  61:     l = new Label(2,0,"Float", cf);

  62:     s.addCell(l);

  63:     WritableCellFormat cf2 = new WritableCellFormat(NumberFormats.FLOAT);

  64:     Number n = new Number(2,1,3.1415926535,cf2);

  65:     s.addCell(n);

  66:  

67: n = new Number(2,2,-3.1415926535, cf2);

  68:     s.addCell(n);

  69:  

  70:     /* Cria um label e escreve um float number acima de 3 decimais 

  71:        em uma célula da folha*/

  72:     l = new Label(3,0,"3dps",cf);

  73:     s.addCell(l);

  74:     NumberFormat dp3 = new NumberFormat("#.###");

  75:     WritableCellFormat dp3cell = new WritableCellFormat(dp3);

  76:     n = new Number(3,1,3.1415926535,dp3cell);

  77:     s.addCell(n);

  78:  

  79:     /* Cria um label e adiciona 2 células na folha*

  80:     l = new Label(4, 0, "Add 2 cells",cf);

  81:     s.addCell(l);

  82:     n = new Number(4,1,10);

  83:     s.addCell(n);

  84:     n = new Number(4,2,16);

  85:     s.addCell(n);

  86:     Formula f = new Formula(4,3, "E1+E2");

  87:     s.addCell(f);

  88:  

  89:     /* Cria um Label e mulpiplica o valor de uma célula da folha por 2 */

  90:     l = new Label(5,0, "Multiplica por 2",cf);

  91:     s.addCell(l);

  92:     n = new Number(5,1,10);

  93:     s.addCell(n);

  94:     f = new Formula(5,2, "F1 * 3");

  95:     s.addCell(f);

  96:  

  97:     /* Cria um Label e divide o valor de uma célula da folha por 2.5 */

  98:     l = new Label(6,0, "Divide por 2.5",cf);

  99:     s.addCell(l);

 100:     n = new Number(6,1, 12);

 101:     s.addCell(n);

 102:     f = new Formula(6,2, "F1/2.5");

 103:     s.addCell(f);

 104:   }

 105:  

 106:   private static void writeImageSheet(WritableSheet s) 

 107:     throws WriteException

 108:   {

 109:     /* Cria um label e escreve uma imagem em uma célula da folha*/    

 110:     Label l = new Label(0, 0, "Imagem");

 111:     s.addCell(l);

 112:     WritableImage wi = new WritableImage(0, 3, 5, 7, new File("imagem.png"));

 113:     s.addImage(wi);

 114:  

 115:     /* Cria um label e escreve hyperlink em uma célula da folha*/

 116:     l = new Label(0,15, "HYPERLINK");

 117:     s.addCell(l);

 118:     Formula f = new Formula(1, 15, 

 119:       "DevMedia(\"http://www.devmedia.com.br\", "+

 120:       "\"Portal DevMedia\")");

 121:     s.addCell(f);

 122:     

 123:     }

 124: }

Download : Download Fonte do Código exemplo : How-to-create-an-excel-file Este é o guide do site oficial : JExcel-PGuide Tutorial: Tutorial

Read More

Hello World !

Blog criado com o intuito de postar sobre vários assuntos dentro da área de computação : software embarcado, programação C,  java, scripts de perl, python, ruby, webservers, linux e muitas outras coisas que eu achar interessante para postar.  =) Sejam bem vindos, aceito sugestões.

Read More