Cosas que he aprendido del curso con Martin Odersky Vol. 1 | Recursividad

Buenas tardes. Pues dado que hoy tengo una
pereza tremenda para salir, me dije a mí mismo:
"Mí mismo, hagamos una entrada en JavaMéxico".

Había dicho que cada sábado iría posteando algo
pero, ya saben, un joven recién salido de casa
capaz pagarse sus gustos... En fin.

Este curso de Martin Odersky es muy interesante desde mi particular
punto de vista:

+ En primera, tienes frente a ti al creador del lenguaje
de programación, por tanto uno aprende a usar Scala de la manera en
que fue pensado desde un inicio.

+En segunda, porqué aprendes temas muy base, qué
muy probablemente no te enseñaron en la escuela, y que te ayudan
a ver los problemas de tu trabajo de otra manera.

=====Nota====================================================
Dado que hubo un caso con los ejercicios de la semana pasada, no postearé
el código que yo conseguí que funcionase, era lo que quería hacer, pero tal parece
que si lo hago y me descubren me expulsan del curso; prefiero no arriesgarme :D
============================================================

En la primer semana el tema a tratar me parecía algo "soso", era recursividad y vamos
que eso lo vemos en la escuela y si me puse a pensar, ¿en realidad es necesario un tema
tan obvio en un curso de este nivel?... Y es ahí lo que pasa, el nivel en que se
maneja la recursividad en el curso no es tan trivial cómo (al menos un servidor) lo vimos
en la universidad.

La recursividad en pocas palabras es que dentro del cuerpo de una función (o método), sea
la función que se llame a sí misma, otra cosa es que un bloque recursivo DEBE tener un fin.
El ejemplo por excelencia es el ejercicio del factorial:
 

¿Nada difícil verdad?. Yo también lo creía, luego poco después de eso se trata el tema de
"recursividad en cola" (tail recursion). Qué aunque ya ahorita que lo comprendí, tampoco
es muy difícil. Tail recursion básicamente te sirve para no anidar operaciones dentro de una
función (¿se dieron cuenta de ese n*factorial(n - 1)?), y básicamente nos sirve para evitar
hacer cambios de estado.

Y después de cambios de estado me recuerda que debo explicar porqué evitarlos. Dada la
filosofía de Scala y el propósito del lenguaje (hacer aplicaciones escalables y concurrentes),
tenemos que la asignación de variables y el cambio de valor en las mismas hacen que tengamos
que bloquear procesos, básicamente por eso en Scala (más bien en este curso) no podemos
usar variables firmadas por "var", ya que estas son alterables. Si necesitamos alterar un valor,
digamos si tenemos un método llamado suma, lo que hacemos es "retornar" otro objeto, no
cambiamos un existente. Ejemplo de la suma:
 

Ahora. En el caso del factorial, tenemos más de lo mismo, no alteramos un acumulador,
creamos uno nuevo y de esa manera respetamos la inmutabilidad. Ejemplo:
 

¿Lo ven?... El método queda algo más simple, no anida operaciones y todos tan felices :D

Para no llegar a hacer posts tan largos que dan pereza de leer les pongo el reto que nos
puso Martin Odersky a resolver. Se trata de implementar de manera recursiva el triángulo de
pascal.

Para evitar algún problema con el curso y tal, recomiendo que lo hagamos en manera de
algoritmo/pseudo-código. Si algo no quedó claro de la entrada no se preocupen pregunten.

Mi status actual es bastante bueno, entré sabiendo que la programación funcional era usar
funciones cómo principal motor, y nada más, ahora ya en la tercer (para ser la cuarta) semana
del curso, ya entiendo muchas cosas más interesantes (funciones de alto orden, currying), pero
quiero explicarlas cómo nadie en la red las explica de manera sencilla.

En fin, espero que les haya gustado este micro-aporte, ay viene más, ustedes no se preocupen.

Por cierto, si quieren las diapositivas o los vídeos del curso díganme para subirlos a algún lugar,
tal parece que no hay problema por compartir ese contenido, el único problema es con la resolución
de los assigments, que esos evalúan a los "alumnos" y en base a ellos se entrega el certificado
de coursera.

Bueno, sin más. Un saludo y hasta luego.