Rodrigo Strauss :: Blog
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
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.