Hace un tiempo escribía acerca de Julia en mi blog previo rchg.github.io, y explicaba porque me había decidido a aprender y practicar con Julia. Ahora retomo un poco esta misma cuestión con la perspectiva que tiene haber usado durante casi dos años con intensidad variable Julia.

Qué escribía entonces...

Mis dos herramientas hasta el momento para programar en entornos científicos han sido Fortran y Python (y aun siguen siendo las que más utilizo), en principio ninguno me ha servido por si solo para resolver los problemas de cálculo científico de mí día a día (aparte del uso de la shell, como bash, y programas puntuales en C).

Más allá de que los programas de climatología y transferencia radiativa que uso están en Fortran, la realidad es que, parte de las librerías de Python en última instancia se basan en métodos en Fortran o en C para las partes de cálculo intensivo: basta ver que parte de los métodos en scipy son wrappers a programas en Fortran/C. Con todo Python ha mejorado en los últimos tiempos, y hay aproximaciones como PyPy, numba etc que intentan soslayar el problema de los dos lenguajes.

De todos modos en mi experiencia programando en Python, desearía en múltiples ocasiones tener varias de las siguientes posibilidades:

• Compilar el código en lugar de ser interpretado
• Poder definir los tipos asociados a las variables en lugar del tipado dinámico de Python (parece que tras 3.11 es posible realizar anotaciones de tipos en las funciones, aunque no sé en que medida hay una evaluación por el interprete o son solamente anotaciones para el programador).
• Conservar, si es posible, una versión interpretada que es útil en situaciones particulares.
• Seguir teniendo la posibilidad de interactuar con código C o Fortran.
• Forzar o posibilitar una programación más próxima a como se formulan las funciones en matemáticas y dar la posibilidad de componer funciones/código de modo similar a como se hace en matemáticas.

Mi decisión inicial fue Haskell (sobretodo por el último punto) que aún considero una opción formal razonable: es posible invocar ghci que permite una versión interactiva. El sistema de tipos me parece ejemplar aunque requiere bastante esfuerzo habituarse. Permite usar funciones C/Fortran aunque no es particularmente sencillo.

Actualización: He explorado en los últimos meses la opción de OCaml, que en este momento me parece una de las mejores. El compilador es rápido, puedes usar REPL, puedes usar código en C/Fortran. El único inconveniente es que faltan librerías específicas para cálculo científico. OCaml es rápido comparado con Python puro, y no necesita tanta memoria como Julia. Sin embargo en aplicaciones científicas numpy esta optimizado gracias al uso de C/Fortran en tareas críticas. Por mi parte, he optado por OCaml para aplicaciones en la terminal y ojala haya un desarrollo más amplio de librerías numéricas basadas en Owl (u otras similares).

Sin embargo ha habido dos aspectos que han hecho que busqué otras opciones (diferentes de Haskell):

• Falta de un sistema amplio y sencillo de paquetes para las tareas básicas: lectura de NetCDFs por ejemplo. Existe un paquete llamado hnetcdf, sin embargo su integración con otras librerías no esta al nivel de xarray o similar.
• Hay muchas librerías para arrays (demasiadas seguramente para un novato), que poseen una curva de aprendizaje nada suave, además de no saber cual es la mejor opción (Massiv, Repa, accelerate...)
• El sistema de paquetes, Cabal, es en primera instancia un poco confuso (como lo fue en sus inicios de python), aunque una vez que te habitúas acabas viéndolo como natural.
• Las librarías de representación gráfica no están muy desarrolladas, en particular para hacer representaciones geográficas. Esta ha sido la principal causa de buscar alternativas.

En función de estas circunstancias he buscado otras alternativas: rust, nim entre otros. Sin embargo, he optado por Julia:

• Su sistema de paquetes es muy sencillo y práctico.
• Su documentación esta bien organizada y aunque aun no hay tantos recursos como en Python posee un rápido crecimiento.
• La curva de aprendizaje es rápida debido a una sintaxis sencilla (si vienes de Python no hay una diferencia abismal).

Además,

• Es posible definir/fijar el tipo de las variables con notable flexibilidad (multiple dispach).
• Las librería de arrays y álgebra lineal parecen bastante consolidadas (de hecho están en la librería estándar).
• Hay bastantes opciones para la visualización aunque aún no hay una librería consolidad para la representación de mapas (geográficos).
• Es posible usar representación Unicode en el código, para variables, funciones etc, lo que agiliza y simplifica notablemente la notación.
• El código compilado on the fly es notablemente rápido, cercano, parece ser, a C/Fortran.

Nota:

Tras trabajar con Julia en algunas librerías, se observa bastante progreso y mucha actividad en los foros. Si que hecho de menos la posibilidad de crear ejecutables, que aunque no es una prioridad, es una aspecto en el que parece que se esta trabajando dentro de los programadores que llevan el proyecto. Algunas curiosidades:

• Se puede indicar el tipo (type) mediante la sintaxis: x::Float64, x::Int etc... esto recuerda a Haskell que posee una sintaxis similar. En el caso de Python3 es posible anotar con x:Int por ejemplo, pero no tiene ningun efecto en el codigo, y es meramente para ayudar a quien lea el codigo.
• Me gusta el modo de introducir estructuras (nuevos tipos)
• Han introducido la composición de funciones, que de nuevo me gusta ya que me recuerda la programación funcional y Haskell.

Actualización: Como se puede observar en este blog, he empezado un tutorial sobre OCaml que más o menos relata mi progreso/aprendizaje de este lenguaje.

Qué pienso en este momento...

Ahora pienso que hay un cierto marketing en como se promociona cada lenguaje.

En su momento Python era un glue language que podías utilizar para muchas cosas, obviamente no tenía la performance de C o Fortran pero no era importante ya que era glue language y se podía hacer uso de su capacidad de usar métodos de otros lenguages para conseguir performance. Julia se ha promocionado como un lenguaje que soluciona el problema de los dos lenguajes ya que dice ser tan rápido en aplicaciones científicas como Fortran (aunque ahora no estoy seguro de que tal problema de los dos lenguajes sea un problema, solo permite no tener que saber dos lenguajes de programación). https://ocaml.xyz/ En realidad Julia podría ser también un glue languaje ya que puedes rehusar código de Fortran o C como puedes hacer en Python. La razón, sería no tanto el rendimiento como aprovechar las librerías en C o Fortran. Pero en muchos lenguajes se puede acceder a C y dado que Fortran puede accederse desde C también a Fortran. Me gusta más Julia que Python como lenguaje por el sistema de tipos, no se como será en la versión 3.11 donde parece que puedes introducir tipos en Python (aunque tengo la sensación de que es algo artificial).

En ambos casos, Python y Julia, me falta poder crear ejecutables así como byte-code. Y eso me atrae de OCaml, pero la búsqueda del lenguaje perfecto ha finalizado, no lo voy a encontrar pero hay algunos en que estoy más cómodo. Cual usar dependerá de con quien trabajas y del problema concreto. Aprender otros lenguajes hace ver los anteriores con otros ojos. No veo igual Julia o Python tras aprender algo de OCaml y tambíen algo de C.