[[egostar]]

Coincido con todos en general, pero si hablamos como ya lo mencione de los estilos de programar y haciendo uso de lo dicho por Al

y hasta pena me da ver algo de ese antiguo código

yo estoy convencido de que la modularización va de la mano con la experiencia y de las nuevas funciones que te permiten reducir código hasta lograr la optimización.

Empezado por AL González

Insisto en que pongamos un ejemplo de función Delphi de más de 20 líneas de código nativo y hagamos el ejercicio de atomizarla. Nos permitiría acercar criterios en esta materia y establecer una norma teórica.

Les pondré un ejemplo de lo que hacia con Delphi 16 bits y lo que hago ahora con Turbo Delphi y aún creo que no es lo óptmo.

En uno de mis sistemas y que desarrolle su primera versión hace ya algunos años, requiero de calcular la duración desde dos variables de tipo string de fecha y dos variables de tipo string conteniendo la hora.

con Delphi 16 bits

Código Delphi [-]
Function TLector.CalculaDuracion(FI,FF:String10;HI,MI,SI,HF,MF,SF:String2):String8;
Begin
  FIDate := StrToDate(FI);
  FFDate := StrToDate(FF);
  If FFDate = FIDate Then
     begin
       val(HI,HT,Code);
       val(MI,MT,Code);
       val(SI,ST,Code);
       DurIni   := CalculaSegundos(HT,MT,ST);
       val(HF,HT,Code);
       val(MF,MT,Code);
       val(SF,ST,Code);
       DurFin   := CalculaSegundos(HT,MT,ST);
       DurTotal := DurFin - DurIni;
       ConvDuracion;
       CalculaDuracion := DurHrsS+':'+DurMinS+':'+DurSegS;
     end
  Else If (FFDate - FIDate) = 1 then
          begin
            val(HI,HT,Code);
            val(MI,MT,Code);
            val(SI,ST,Code);
            DurIni   := CalculaSegundos(HT,MT,ST);
            DurIni   := 86400 - DurIni;
            val(HF,HT,Code);
            val(MF,MT,Code);
            val(SF,ST,Code);
            DurFin   := CalculaSegundos(HT,MT,ST);
            DurTotal := DurFin + DurIni;
            ConvDuracion;
            CalculaDuracion := DurHrsS+':'+DurMinS+':'+DurSegS;
          end;
End;

con Turbo Delphi

Código Delphi [-]
function CalculaDuracion(FI,FF,HI,HF:String):String;
Var
   FechaHora : TDateTime;
begin
   if TryStrtoTime(TimetoStr(StrtoDateTime(FF+HF)-StrtoDateTime(FI+HI)),
              FechaHora) then Result := TimeToStr(FechaHora);
end;

Que pasó, bueno, resulta que mi inexperiencia me dictó en ese momento que así lo tenía que hacer y me bastaba, ahora con TD encontré que todo ese rollo lo podía resolver en una sola línea, yo me imagino que hay algo mejor que eso, pero siendo sinceros me falta mucho para poder optimizarlo.

Yo me declaro inconpetente en hablar o discutir eso de atomización, ni siquiera entiendo el concepto aún, pero vamos, la idea principal que quiero expresar es como determinar lo que Delphius inicia como debate.

De acuerdo a tu experiencia, ¿Cuál sería la relación Modularidad/Complejidad que se estaría dispuesto a tolerar? ¿Qué criterios usas para determinar que tu trabajo está altamente integrado?

Mi sentido común me dice Tolerancia CERO entre Modularidad y Complejidad, mi experiencia (o mi inexperiencia) no puedo medirla, eso es lo que hoy se, el día de mañana y sobre todo aqui en el club me dira otra cosa.

Salud OS.