¿Cuál sería la relación Modularidad/Complejidad que se estaría dispuesto a tolerar?

[[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.

[[AzidRain]]

Yo creo que la atomizacion del código simplifica en mucho el mantenimiento poterior ya que a todos nos pasa que despues de cierto tiempo se nos olvida un poco como iba el algoritmo sobre el que trabajamos para hacer x cosa. >Con código atomizado podemos llegar a tener cosas como esta:

  Procedure TMiVentana.EjecutaTarea;
Begin
  AbreTablas;
  PreparaGrillas;
  If ShowModal=mrOK Then
    GuardaDatos;
  CierraTablas;
end;

Muy entendible no?
Claro que tambien depende del estilo o "convenciones" que usemos en el código ya que si nombramos las funciones con nombres que no vienen al caso pues se pierde la utilidad de la atomización y se complica la cosa. En mis inicios en Pascal acostumbraba usar sintaxis en inglés para casi todo, posteriormente empece a revolver inglés con español y ahora solo uso español. A veces ponia nombres como "SeekFileNombres" o "BuscarFiles"...ahora me dan risa.

Otra práctica que de repente uso es la de hacer todo sucio y rápido y luego irlo partiendo, asi pues llego a tener funciones muy grandes que luego voy dividiendo y optimizando, asi por lo menos mis aplicaciones funcionan a a primera y las voy mejorando..

[[egostar]]

Empezado por AzidRain

Muy entendible no?

Asi es, ya lo veo claro, de hecho yo lo hago asi, genero funciones y procedimientos encapsulando codigo de la forma como lo planteas tu, pero esto mas por sentido practico que por conocimiento.

Salud OS.

[[Lepe]]

Yo siempre uso el inglés (aunque mi lengua materna sea el castellano) lo encuentro mucho más compacto. Nunca recuerdo si he usado el infinitivo o un tiempo verbal (Busca / Buscarrr) en el nombre de un procedimiento. Lo mismo con el singular y plurar, o con los artículos y preposiciones, que son muy incómodos (De, Los, El, etc).

No mezclo jamás inglés con español en el nombre de una función solo con conceptos del propio Software, por ejemplo: IdToAlbaran o IdToFactura.

Por este lado del charco, Grilla es la hembra del Grillo [...] ¿las maquillas y las peinas ?. Yo, personalmente , prefiero algo así como "SetGridHeader"; en español sería "EstablecerCabecerasDelGrid". "Preparar" es abstracto, nunca identifico lo que hace y acabo mirando la función.

Por otro lado, uso propiedades (property) siempre que puedo [...] Pero creo que me estoy saliendo del hilo jejeje.

En cuanto a lo ocurrido con la función "CalculaDuracion" es muy normal. Yo usaba mi función "InsertBreakLine" para romper una cadena larga al llegar a XX caracteres, Ahora recién veo WrapText de la unidad SysUtils en BDS2006 que me hace sonrojar (muy posiblemente también esté en delphi 6... no sé).

Saludos

[[Al González]]

¡Hola a todos!

Empezado por Lepe

...algo así como "SetGridHeader"; en español sería "EstablecerCabecerasDelGrid"...

Rejilla.

Un abrazo sin grilla.

Al González.

[[Caral]]

Hola
Despues de toda esta explicacion de los maestros, me gustaria dar una opinion autodidacta.
No todo esta inventado.
No creo que exista la funcion perfecta o ideal para todos los programas (Standard).
De acerdo a esto:

¿Cuál sería la relación Modularidad/Complejidad

Para mi dependeria de la experiencia y del proyecto en si, no creo que se pueda generalizar.
Estoy de acuerdo con seoane en partir el problema para entenderlo mejor, pero mi poca experiencia dice que si no conoces la base no puedes partir nada, entonces partiriamos del conocimiento.
Para mi sencillamente se reduciria a lo dicho, Experiencia y deficinicion del proyecto.
Saludos

[xander]

A como yo veo el asunto, esta muy bien ser organizado y partir los problemas en pedazos que puedan ser reutilizables.

Un problema es el que comenta Mamcx, todo crece en cuanto lo partes... yo veo librerias como la de "interfazGH" de Al Gonzalez y me parece de lo mejor... pequeñas funciones bien separadas en contexto y todo...

Donde yo veo el problema en tener tantas cosas tan chiquitas es que luego no te acuerdas que es lo que tienes y que es lo que no... y si te acuerdas que ya lo tienes, ahora ¿donde quedó al final?... es como tener una caja de herramientas como el dice pero tener cientos de ellas en la caja... cuando tienes muchas encontrar una en específico es bien dificil, y luego a lo mejor resulta que si tenías hecha la funcion pero le pusiste un nombre que en el momento no recordaste y la pasaste por alto y la volviste a hacer... tal como le paso a Lepe con la funcion esa del BDS2006...

La cuestión tambien no es solo partir sino como es que se documenta o se le hace para encontrar lo que se ocupa rápidamente. tampoco es la idea de leerse los encabezados de todas las funciones de la unidad para encontrar la que busco, ahi pierdo el tiempo que pude haberme ahorrado.