Depuración de código: Una introducción elemental a Wolfram Language

47	Depuración de código

Hasta los programadores más experimentados se ven obligados a pasar por el proceso de depuración de sus códigos; esto es algo inevitable en la programación. Sin embargo, si se siguen unos cuantos principios básicos, la depuración puede ser particularmente fácil en el caso de Wolfram Language.

El primero, y más importante, de tales principios es que hay que probar cada porción del código que se escribe. Y esto se puede ir haciendo de manera casi instantánea, debido a que Wolfram Language es interactivo, a la vez que simbólico. Esto significa que aunque se hagan modificaciones muy pequeñas, el código se puede ejecutar de nuevo para ver si los ejemplos de prueba siguen funcionando. De no ser así, simplemente se arregla esa porción del código y se sigue adelante.

En ocasiones, Wolfram Language puede detectar algún posible error inmediatamente después de que se ingresa algo y, en ese caso, lo señalará marcándolo en rojo.

Una porción de código con problemas, que se señalan en color rojo:

Después de ejecutar alguna porción de código, Wolfram Language puede indicar si algo está obviamente mal, en cuyo caso mostrará en la pantalla un mensaje a tal efecto. Por ejemplo, el código a continuación termina solicitando el primer elemento de una lista de longitud 0.

Algo está obviamente mal si se aplica First a la lista vacía {} generada por Cases:

In[1]:=

Out[1]=

A veces Wolfram Language se topa con algo que no sabe cómo manejar, sin estar seguro de que haya algún problema. En tales casos, simplemente deja la entrada tal cual y la regresa en una forma simbólica que más tarde podría tener algún valor definitivo.

Si no se han dado valores para a, b y c, Wolfram Language simplemente regresa la entrada sin cambios:

In[2]:=

Out[2]=

Si se quiere generar una gráfica con partes simbólicas que no se pueden procesar, se produce una caja en color rosa:

In[3]:=

Out[3]=

Cuando se están construyendo funciones, es común que haya fragmentos del código que se desea probar antes de haber completado la función. Esto se puede hacer asignando valores a variables con With, que trabaja de forma parecida a Module, salvo que no permite reasignar los valores.

Use With para asignar m=4 temporalmente, para probar un fragmento de código:

In[4]:=

Out[4]=

Si en algún caso la depuración parece tomar demasiado tiempo, esto se debe generalmente a que uno se ha equivocado al juzgar qué es lo que hace el código. En mi experiencia, lo mejor para solventar esto es simplemente analizar de manera sistemática el comportamiento del código, haciendo tablas con los resultados, generando visualizaciones, probando las afirmaciones, y todo eso.

Producir algunas gráficas para ver lo que está haciendo el código:

In[5]:=

Out[5]=

Si este código funciona correctamente, el resultado debe contener todos los números del 0 al 2 ^m-1:

In[6]:=

Out[6]=

Se comprueba esto sistemáticamente hasta m=10:

In[7]:=

Out[7]=

A veces no basta con ver el resultado final de un fragmento de código; hay que asomarse también a lo que sucede al interior. Puede insertarse la función Echo en cualquier parte para ver en la pantalla resultados o valores intermedios con el código que está corriendo.

Echo muestra valores, pero no interfiere con el resultado:

In[8]:=

Out[8]=

Si se está ejecutando un cómputo largo, se puede supervisar el progreso del mismo usando Monitor.

Muestre continuamente (con un marco) el valor de n que se ha alcanzado hasta el momento:

In[9]:=

Out[9]=

Echo y Monitor solamente muestran cosas. Si se desea efectivamente capturar los resultados intermedios, puede usarse Sow (sembrar) y Reap (cosechar).

Reap produce el resultado final junto con una lista de todo lo que fue sembrado por Sow:

In[10]:=

Out[10]=

Esto siembra valores consecutivos de Length[#], y cosecha los resultados:

In[11]:=

Out[11]=

Vocabulario

With[{x=value},expr]		ejecuta expr dando a x el valor value
Echo[expr]		muestra y regresa el valor de expr
Monitor[expr,obj]		muestra continuamente obj a lo largo de una ejecución
Sow[expr]		siembra el valor de expr para cosecharse posteriormente
Reap[expr]		colecciona los valores sembrados mientras se ejecuta expr