logo
Contato | Sobre...        
rebarba rebarba

Rodrigo Strauss :: Blog

follow us in feedly

Os códigos que eu tenho que aguentar

Em todas as empresas que eu já trabalhei, tive que dar manutenção em diversos sistemas, muitas vezes feitos por pessoas que nem trabalham mais na empresa. Eu já passei infinitas horas tentando entender o que foi feito, quase sempre em um código confuso e com nenhum comentário. Agora que eu estou trabalhando com otimização de performance em componentes já existentes, minha situação piorou. Eu preciso antes entender COMPLETAMENTE o que o componente faz, ao invés de entender somente a parte que eu preciso modificar.

Meu amigo Gilberto já passou por mais empresas do que eu, porque ele aceitava [se sujeitava a] pegar projetos com 4 meses de duração. Depois de algumas discussões sobre os diversos estilos de código que encontramos durante nossa longa jornada (isso deveria ter uma música dos anos 60 como trilha sonora...), ele me apareceu no dia seguinte com essa pérola que vos mostro, entitulada "Os códigos que eu tenho que agüentar".

Nos exemplos abaixo, programadores com diversos perfis (prático, metódico, enigmático, etc) se propõem a criar uma função que retorne o resultado de (2 + 2). Cada estilo de programador faz de uma forma diferente, como vemos abaixo:

//
// Prático
//
int soma()
{
       return 2 + 2;
}

//
// Enigimatico
//
int soma()
{
       int a = 1;
       a = a << 1;
       a = (++a)++;
       return a;
}

//
// Metódico
//
int soma3()
{
       int a;
       int b;
       int c;
       a = 2;
       b = 2;
       c = a + b;
       return c;
}

//
// Aprendeu orientação a objetos ontem
//
class cVal
{
private:
       int valorInterno;
public:
       int GetValue()
       {
               return valorInterno;
       };
       void SetValue(int i)
       {
               valorInterno = i;
       };
       int Soma(cVal CV)
       {
               return this->GetValue() + CV.GetValue();
       };
};

int soma()
{

       cVal a,b;
       a.SetValue(2);
       b.SetValue(2);
       return a.Soma(b);
}

//

// Macaco velho
//
int soma()
{
       return 4;
}

//
// Experiente
//
static const int Soma2_2 = 4; //2 + 2 = 4


//
// STL maníaco
//
#include <vector>
#include <functional>
#include <numeric>


template<typename T>
int supersoma(T p1, T p2)
{
 typedef T _MyType;
 return std::plus<_MyType>()(p1,p2);
}

template<typename T>
int supersoma2(T p1, T p2)
{
 std::vector<T> v;

 v.reserve(2);
 v.push_back(p1);
 v.push_back(p2);
 return std::accumulate(v.begin(), v.end(), 0, std::plus<T>());
}

template<typename T, bool b>
int supersoma3(T p1, T p2)
{
	return b ? supersoma<T>(p1,p2) : supersoma2<T>(p1,p2);
}

template<typename T, bool b>
class SuperSoma4
{
 public:
  int operator()(T p1, T p2)
  {
    return supersoma3<T,b>(p1,p2);
  }

};

static const bool qual_somal = false;

int soma()
{
 // Stroustrup e Alexandrescu sejam louvados
 return SuperSoma4<int, false>()(2,2);
}

Eu dei minha contribuição, com o exemplo "STL Maníaco". Se você conhece algum perfil que eu não mostrei, sinta-se à vontade para colocar um exemplo nos comentários.


Em 11/05/2005 19:43, por Rodrigo Strauss


  
 
 
Comentários
Alfred Gary Myers Jr. | website | em 11/05/2005 | #
Tem também o TDD maníaco:

using System;
using NUnit.Framework;

public class Sample
{
static public int Soma2e2()
{
return 4;
}
}

[TestFixture]
public class SampleFixture
{
[Test]
public int Soma2e2Fixture()
{
Assert.AreEqual(4, Sample.Soma2e2());
}
}




E ainda tem o RUP maníaco gasta 2 anos fazendo levantamento, todos os diagramas possíveis, imprime tudo encardena e engaveta o projeto porque se perdeu no meio do caminho.
Leonardo Stabile Prates | website | e-mail | em 11/05/2005 | #
O matematico:

/*
void no parametro, pq matematico que eh matematico mesmo soh programa em ANSI C, e com base binaria ou derivadas
*/

int soma0x2( void )
{
double angle = (double) 0x0348;

return (int) ( (double)0x2 * ( pow( sin(angle) , (double)0x2 ) + pow( cos(angle) , (double)0x2 ) ) );
}
Rodrigo Strauss | website | em 11/05/2005 | #
hahahahaha. As três são boas, mas essa do "RUP maníaco" foi maravilhosa!!!
Marcelo Van Kampen | em 12/05/2005 | #
Tem também o preprocessor Maniac:

#define Soma2_2 4

:D

Leonardo Stabile Prates | website | e-mail | em 12/05/2005 | #
pow, tinha q retornar 4.... esse matematico fez faculdade por correspondencia.....
Leonardo Goslar Otto | e-mail | em 13/05/2005 | #
O mega-comentador:
//Este é o meu estilo de programação como podem ver...

int plus(int x,int y){
//Como se pode ver anteriormente
//foi criada uma função genéria que se
//sera usada para este propósito e quem sabe
//um propósito futuro..
//Pode-se ver tbm que a função foi escrita em ingles
//para facilitar a vida dos programadores gringos.
int xNew;
//Aqui crio um xNovo que será copiado o valor de x
//para uso exclusivo dentro desta função.
int yNew;
//Aqui o mesmo do comentario anterio só que
//agora para x
xNew=x;
yNew=y;
//CUIDADO para não se confundir aqui.
//Foi copiado x para xNew e y para yNew
//Isso é muito importante
int nPlus=xNew+yNew;
//Aqui fazemos a soma dos valores das variaveis xNew e yNew
//estas variaveis são a cópia de x e y respectivamente.
return nPlus;
//E aqui se retorna o valor somado de xNew e yNew que são
//respectivamente x e y que são os valores recebidos pela
//função.
//para criticas
// e sugestôes:
// me mande um email que esta la no departamento
// pessoal da empresa pois já fui despedido.
}
Rodrigo Strauss | website | em 13/05/2005 | #
Infelizmente, hoje em dia é muito difícil encontrar alguém que coloque o mínimo de comentário no código, quanto mais esse exagero que você mostrou... :-)

Eu comento bastante mas não chego a tanto.

Clebson Derivan | website | em 02/06/2005 | #
int
soma(int a, int b)
{
_asm mov eax, dword ptr [ebp + 8]
_asm add eax, dword ptr [ebp + 12]
}


que tipo é esse ?
[]'s
Clebson
Edson | em 18/11/2006 | #
Depois-eu-faço-pois-agora-eu-to-sem-tempo:

int soma( void )
{
/** TODO: retornar o valor da soma de 2 com 2 */
return 0; /** return pra não gerar warning */
}
Glauber | em 24/06/2010 | #
HAhaha me cansei de rir com a do RUP maniaco kkkk!!
eu sei que o poste é de 2005 hehe!

A do Clebson é ASM maniac kkk!
Algo a dizer?
Nome:


Site:


E-mail:


Escreva o número vinte e seis:


 Não mostre meu e-mail no site, não serve pra nada mesmo...

Comentário





Os comentários devem ser sobre assuntos relativos ao post, eu provavelmente apagarei comentários totalmente offtopic. Se quiser me enviar uma mensagem, use o formulário de contato. E não esqueça: isso é um site pessoal e eu me reservo o direito de apagar qualquer comentário ofensivo ou inapropriado.
rebarba rebarba
  ::::