programación supermodular

Manuel Calero Solís 24.abr.2002

"Cuanto más se dividen los obstáculos son más fáciles de vencer".
Concepción Arenal (1820-1893); escritora y socióloga española.

 

Hace algunos meses en una conversación a través del messenger con mi amigo Paco, empezamos a hablar de las distintas técnicas de programación y hablamos de una que yo llevaba tiempo practicando pero sin haberla aprendido de ningún libro, solo llegando a ella por la experiencia propia.

Posiblemente tenga un nombre, posiblemente usted ya la este practicando,  y posiblemente este en los libros, pero como a mi me ha valido de mucho la expongo aquí.

Yo la llamo programación "Supermodular". No espere nada revolucionario, es un nombre que se me ha ocurrido y creo que no la define muy bien pero es el nombre que he encontrado.

¿De que se trata? Se trata de crear muchas funciones o metodos que hagan cálculos mínimos e ir subiendo hasta obtener el resultado deseado.

Me explico,  o lo intento,  con un caso concreto: imagine que estamos trabajando en un programa, mas concretamente en un modulo del programa, por ejemplo en el calculo de una factura, y decimos mentalmente, "Total de factura es igual a unidades por precios de tantas líneas como contenga la factura, mas el I.V.A.". Esto seria de manera simple y sin tener en cuenta muchos otros factores, descuentos, comisiones, etc., bueno estamos en un ejemplo.

 Como resolvemos el problema.

Codigo 1
//-------------
Metodo Total()
nTotalFactura := 0
while cCodigoFactura == cCodigoFacturaLinea
   nTotalFactura += nUnidades * nPrecio
end while
nTotalFactura += nTotalFactura * nPorcentajeIVA / 100
return ( nTotalFactura)
//--------------

¿Pero que tiene de malo este código?

En principio nada o mucho según se mire, el problema esta resuelto pero no hemos pensado en el futuro, en lo que pasará mañana o a mas tardar pasado.

Mañana ha llegado, y nuestro jefe nos dice que han decidido que ahora las facturas deben de soportar Cajas, o sea que puedas facturar por Cajas. Fácil ¿ no ?.

Codigo 2
//------------
Metodo Total()
TotalFactura := 0
while cCodigoFactura == cCodigoFacturaLinea
   nTotalFactura += nUnidades * nCajas * nPrecio
end while
nTotalFactura += nTotalFactura * nPorcentajeIVA / 100
return ( nTotalFactura)
//--------------

El tema esta resuelto, pero hemos vuelto a hacerlo mal. Hemos resuelto el calculo de la factura pero debemos de tocar ahora todos los informes donde se nos pedían las unidades vendidas de una factura, y todos los gráficos, toda la impresión de la factura, y todo lo que mantenga una relación directa con la factura.

¿Qué propongo? Supermodular o dicho de otra manera menos rara: hacer funciones o métodos por cada dato que se necesite para hacer un calculo superior o por cada dato que será empleado en otra parte del programa. Pasemos a la practica.

Codigo 3
//--------
Metodo nUnidades()
Return ( nUnidades )
//-------
Metodo nPrecio()
Return  ( nPrecio )
//-------
Metodo nTotalLinea()
Return ( nUnidades() * nPrecio() )
//-------
Metodo nBaseFactura()
nTotalFactura := 0
while cCodigoFactura == cCodigoFacturaLinea
   nTotalFactura += nTotalLinea()
   skip
end while
return ( nTotalFactura )
//-------
Metodo nIva(nTotalFactura)
nIva := nTotalFactura * nPorcentajeIVA / 100
//-------
Metodo Total()
nTotalFactura := nBaseFactura() + nIva( nTotalFactura )
return ( nTotalFactura)
//--------

Si ahora me proponen el cambio en el calculo de las unidades se me pone una sonrisa de oreja a oreja y contesto a mi jefe 'sin problemas jefe'

Codigo 4
//----------
Metodo nUnidades()
Return ( nUnidades * Cajas )
//----------

Pasado mañana mi jefe dirá que nuestra factura debe soportar el punto verde, ' ningún problema jefe'.

Codigo 5
//----------
Metodo nPrecio()
Return ( nPrecio + nPuntoVerde )
//----------

Y todo el programa saldrá funcionando, sin más problemas. Como veis la idea es muy simple lo verdaderamente complicado es saber que cálculos debemos de atomizar y cuales no, como norma todo aquellos datos que sospechéis van a ser utilizados en otras partes del programa, por ejemplo, es muy probable q necesitemos durante la vida de nuestro programa saber el numero de unidades facturadas de un determinado producto, ese dato nos lo da el método nUnidades(), y esta filosofía trasladarla a todo el programa.

Si algo he aprendido es que merece la pena pararse 30 min. sobre lo que vamos a hacer. Antes de codificar debemos coger un papel en blanco y pintar, meditar y reflexionar lo que se desea antes de escribir una sola línea de código, lo he aprendido pero a veces aun me precipito y lo pago siempre.

Saludos.

Puedes dar tu opinión en el foro de discusión.