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.