Mostrando postagens com marcador programação. Mostrar todas as postagens
Mostrando postagens com marcador programação. Mostrar todas as postagens

segunda-feira, 4 de abril de 2011

Algumas verdades sobre programação

Este artigo é a tradução de artigo escrito por David Veksler, no qual ele conta o que sua experiência como programador lhe ensinou.

O texto original pode ser encontrado aqui.

E vamos ao que interessa:
  • Um programador gasta cerca de 10% a 20% do seu tempo escrevendo código. Normalmente escreve entre 10 e 12 linhas por dia, que estarão presentes no produto final independentemente do seu nível de perícia ou experiência. Bons programadores gastam cerca de 90% do seu tempo pensando, pesquisando e experimentando maneiras de encontrar a solução ótima. Os programadores ruins gastam quase 90% do tempo debugando e fazendo alterações muitas vezes aleatórias na tentativa de “fazer funcionar”.
  • Um bom programador é dez vezes mais produtivo do que um programador comum. Um excelente programador é entre 20 e 100 vezes mais produtivo do que um convencional. Não é um exagero. Estudos desde os anos 60 têm mostrado isso consistentemente. Um mau programador não é só improdutivo - além de não concluir o trabalho com êxito, gera dores de cabeça e trabalho extra para outras pessoas consertarem.
  • Excelentes programadores gastam pouco do seu tempo escrevendo (código que de fato estará no resultado final). Os programadores que gastam muito do seu tempo escrevendo provavelmente não estão encontrando e utilizando soluções existentes para problemas antigos. Bons programadores são ótimos em reconhecer e em reutilizar padrões comuns e não têm medo de refatorar seu código constantemente, a fim de atingir a solução ótima. Programadores ruins escrevem código que falha em integridade conceitual, não-redundância, hierarquia e padrões, tornando complicada a refatoração, fazendo com que seja mais fácil jogar fora todo o trabalho e recomeçar.
  • Software, como qualquer coisa, obedece às leis da entropia. Contínuas mudanças levam ao desgaste do software e de sua integridade conceitual planejada originalmente. A entropia é inevitável, no entanto, programadores que falham ao estabelecer a integridade conceitual criam sistemas que se desgastam tão rapidamente, que muitas vezes se tornam inúteis e caóticos demais mesmo antes de serem concluídos. Possivelmente, o motivo mais comum para falha em projetos é o rompimento da integridade conceitual devido à entropia descontrolada (o segundo mais comum é a entrega de um produto diferente do que o cliente esperava). A entropia desacelera exponencialmente o desenvolvimento e é o principal motivo para deadlines desesperadoras.
  • Um estudo realizado em 2004 revelou que 51% dos projetos falham ou irão falhar em alguma funcionalidade importante e que 15% simplesmente vão falhar como um todo, o que é um grande avanço desde 1994, quando 31% dos projetos falhavam criticamente.
  • Embora muitos softwares sejam desenvolvidos em equipe, não se trata de uma atividade democrática. Geralmente somente uma pessoa é responsável pelo “design” do sistema e o resto do time o completa com detalhes.
  • Programar é um trabalho pesado. É uma atividade mental intensa. Bons programadores pensam sobre seu trabalho 24/7. Eles escrevem seu código mais importante no chuveiro, sonhando etc., porque o trabalho mais importante é feito longe do teclado. Projetos não são concluídos mais rapidamente gastando mais tempo no escritório ou adicionando pessoas novas ao projeto.
“Um excelente operário pode ser duas ou até três vezes mais produtivo que um operário comum, já um bom programador pode fazer com que seu trabalho seja mais do que 10 mil vezes mais produtivo do que um programador comum” - Bill Gates
Fonte: http://dotmac.rationalmind.net (Traduzido por iMasters)

quinta-feira, 10 de março de 2011

Série Java Bizarro - Capítulo 1

Essa série irá demonstrar trechos de códigos bizarros que já encontrei durante a vida de desenvolvedor Java.
Segue o primeiro post....

==========================================
private String mObtenerEvento (EventBody evtIn) throws IndexOutOfBoundsException {
String BusinessEvent= evtIn.getEventDef().getName();
String Acao;

if ( BusinessEvent.equalsIgnoreCase(EVT_STRING_EVENT)) {
Acao= ((String)(evtIn.getParameters())[0]).substring(0, 4);
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_ATUA)) return EVT_STRING_EVENT_ATUA;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_FPAR)) return EVT_STRING_EVENT_FPAR;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_FTOT)) return EVT_STRING_EVENT_FTOT;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_COPI)) return EVT_STRING_EVENT_COPI;
if (Acao.equalsIgnoreCase(EVT_STRING_TST_AUTO_BD)) return EVT_STRING_TST_AUTO_BD;
if (Acao.equalsIgnoreCase(EVT_STRING_FECH_OS_SAC)) return EVT_STRING_FECH_OS_SAC;
if (Acao.equalsIgnoreCase(EVT_STRING_ATU_EST_OS_SAC)) return EVT_STRING_ATU_EST_OS_SAC;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_FIGU)) return EVT_STRING_EVENT_FIGU;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_RDSI)) return EVT_STRING_EVENT_RDSI;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_ATUALIZAR_BAUTO_IBUS)) return EVT_STRING_EVENT_ATUALIZAR_BAUTO_IBUS;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_ATUALIZAR_BAUTO_RBUS)) return EVT_STRING_EVENT_ATUALIZAR_BAUTO_RBUS;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_ATUALIZAR_BAUTO_IPLA)) return EVT_STRING_EVENT_ATUALIZAR_BAUTO_IPLA;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_ATUALIZAR_BAUTO_RPLA)) return EVT_STRING_EVENT_ATUALIZAR_BAUTO_RPLA;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_ATUALIZAR_BAUTO_ITRO)) return EVT_STRING_EVENT_ATUALIZAR_BAUTO_ITRO;
if (Acao.equalsIgnoreCase(EVT_STRING_EVENT_ATUALIZAR_BAUTO_RTRO)) return EVT_STRING_EVENT_ATUALIZAR_BAUTO_RTRO;
//Fim: 29/09/2003
if (Acao.equalsIgnoreCase(EVT_STRING_CRIAR_OS_PAP_SAC)) return EVT_STRING_CRIAR_OS_PAP_SAC;
if (Acao.equalsIgnoreCase(EVT_STRING_CANCELAR_OS_PAP_SAC)) return EVT_STRING_CANCELAR_OS_PAP_SAC;
if (Acao.equalsIgnoreCase(EVT_STRING_MODIFICAR_OS_PAP_SAC)) return EVT_STRING_MODIFICAR_OS_PAP_SAC;
if (Acao.equalsIgnoreCase(EVT_STRING_ENCERRARFILA_OS_PAP_SAC)) return EVT_STRING_ENCERRARFILA_OS_PAP_SAC;
}
return evtIn.getEventDef().getName();
}// fim do metodo mObtenerEvento

===========================================
Afinal de contas, qual o motivo de tudo isso ???