**IAIC** Julia Instalación y Ecosistema Aunque el [sitio web oficial de Julia](https://julialang.org/) ofrece paquetes de instalación completos, nosotros vamos a usar una distribución llamada [`juliaup`](https://github.com/JuliaLang/juliaup), que resulta más cómoda y fácil de mantener. Esta guía no pretende ser exhaustiva en todo lo referente al mantenimiento de un ecosistema completo de producción y desarrollo en Julia, sino una guía de iniciación que facilite la tarea inicial de instalar una primera versión y algunos detalles sobre cómo mantenerla. El objetivo es ayudarte a mantener el ecosistema en tu ordenador personal, ya que el sistema debe estar montado en los laboratorios de la E.T.S. Ingeniería Informática. ## Instalación de Julia con `juliaup` 1. Instala `juliaup`: ```` winget install julia -s msstore ```` Para MacOS/Linux sería: ```` curl -fsSL https://install.julialang.org | sh ```` En Windows pide confirmar algunas cosas antes de ponerse a instalarlo porque se hace por medio de Microsoft Store. 2. Instala Julia(usamos `juliaup` para hacerlo, en vez del sistema habitual de Julia). Normalmente, en la versión `x.y` se considera la última versión estable actual (en el momento de escribir este documento, es la 1.9): ```` juliaup add 1.9 ```` 3. `juliaup` permite tener fácilmente muchas versiones distintas, pero no sé ahora mismo si nos hará falta movernos entre versiones, así que lo más cómodo es hacer que esta versión (las más actual ahora mismo) sea la que se toma por defecto para no tener que hacer nada más: ```` juliaup default 1.9 ```` 4. `juliup` también proporciona comandos adicionales para actualizar (`update`), eliminar (`remove`), etc. Por ejemplo, si quieres ver qué versiones de Julia hay instaladas, basta que escribas (opbserva que muestra que es la versión por defecto, y que podrían aparecer más líneas dependiendo de las versiones instaladas anteriormente): ```` $ juliaup status Default Channel Version Update --------------------------------------------------- * 1.9 1.9.2+0.x64.w64.mingw32 ```` 5. Además, `juliaup` funciona bien con VSCode, porque son los mismos desarrolladores que preparan la extensión principal de Julia para este editor. ## Preparación de un entorno con herramientas de apoyo 1. Junto a la carpeta `.julia` crea la carpeta+subcarpeta `.julia-environments/tools`. 5. Ejecuta `julia` en esa carpeta: ```` .julia-environments/tools> julia ```` 6. En el REPL de Julia: 1. Entra en el gestor de paquetes y crea un nuevo entorno: ```` julia> ] (@v1.9) pkg> (@v1.9) pkg> activate . Activating new project at `~/.julia-enironments/tools` (tools) pkg> ```` 3. Añade los paquetes `Revise`, `OhMyREPL` y `BenchmarkTools`, que forman parte del ecosistema de trabajo de Julia y facilitan la tarea de tener un entorno de desarrollo algo más productivo: * `Revise.jl`: permite usar cambios en el código sin necesidad de reiniciar Julia. * `OhMyREPL.jl`: permite hacer *syntax highlighting* en el REPL y matching de corchetes/paréntesis (algo que solo se suele permitir en editores). * `BenchmarkTools.jl`: para análisis de rendimiento y comparativas. ```` (tools) pkg> add Revise OhMyREPL BenchmarkTools Updating registry at `~/.julia/registries/General.toml` Resolving package versions... Updating `~/.julia-enironments/tools/Project.toml` [6e4b80f9] + BenchmarkTools v1.3.2 [5fb14364] + OhMyREPL v0.5.13 [295af30f] + Revise v3.5.0 Updating `~/.julia-enironments/tools/Manifest.toml` [6e4b80f9] + BenchmarkTools v1.3.2 [da1fd8a2] + CodeTracking v1.2.0 [a8cc5b0e] + Crayons v4.1.1 ... (output truncated) (tools) pkg> ```` Tras estas tareas, se han creado dos ficheros en la carpeta `tools` (`Project.toml` y `Manifest.toml`) que definen el entorno en el que se cargarán automáticamente los paquetes anteriores. Cada vez que trabajemos en este entorno, tendremos a nuestra disposición esos paquetes sin necesidad de cargarlos. 4. Cierra el REPL (Ctrl+D). ## Entorno por defecto 1. Salta al directorio `.julia` y crea un subdirectorio `config`. Dentro de él, crea el fichero `startup.jl` con el siguiente contenido (lo puedes descargar de [aquí](startup.jl)): ````julia # ~/.julia/config/startup.jl # Apila el entorno tools sobre el entorno actualmente activo. # Ver: https://docs.julialang.org/en/v1/manual/environment-variables/#JULIA_LOAD_PATH push!(LOAD_PATH, Base.Filesystem.homedir() * "/.julia-environments/tools/") # Importa las herramientas, o muestra un error si algo sale mal try @eval using OhMyREPL catch e @warn "Error inicializando OhMyREPL" exception=(e, catch_backtrace()) end try @eval using Revise catch e @warn "Error inicializando Revise" exception=(e, catch_backtrace()) end try @eval using BenchmarkTools catch e @warn "Error inicializando BenchmarkTools" exception=(e, catch_backtrace()) end ```` ## VSCode [Sitio web del editor](https://code.visualstudio.com/). Es el editor preferido para trabajar con Julia (de hecho, los desarrolladores de *Juno*, el editor de referencia que se desarrolló para Julia, han pasado a mantener la extensión de Julia para VSCode, así como la utilidad `juliaup` que hemos usado para mantener las versiones de Julia). Basta instalar la extensión Julia para comenzar a trabajar desde este editor sin el más mínimo problema (busca en las extensiones `Julia`, es la primera que sale). Como se indica a continuación, es incluso un entorno ideal para la instalación de paquetes que pueden dar problemas de instalación desde la consola de Julia corriendo en la terminal de Windows. VSCode ofrece dos formas de interactuar con Julia: la REPL y el editor ### El REPL de Julia El `read-eval-print-loop` (`REPL`) es la interfaz de línea de comandos de Julia, similar a la shell de Python. Permite escribir y evaluar líneas individuales de código, y es también el lugar donde se ejecutará cualquier programa que escribas. Puede abrirse mediante la secuencia de teclas `Alt + J` seguida de `Alt + O`, o abriendo la paleta de comandos de VSCode a través del menú `Ver` o con `Ctrl + Mayús + P`, y buscando el comando `Julia: Start REPL`. Es idéntica a la línea de comandos que aparece al ejecutar Julia como aplicación, por lo que no es necesario interactuar con Julia fuera de VSCode. Una característica particularmente útil de la REPL es el modo de ayuda. Al teclear `?` en la REPL, el prompt cambia de `julia>` a `help?>`, tras lo cual al teclear el nombre de cualquier variable o función se obtiene información sobre ella. Se puede salir del modo de ayuda pulsando `Retroceso` en una línea vacía o `Ctrl + C` en cualquier momento. ### El editor El panel del editor es el gran panel central, que permitirá la escritura de programas en forma de scripts. Para crear un nuevo archivo, selecciona `Archivo` y a continuación `Nuevo Archivo` en el menú, o utilice `Ctrl + N`. A continuación, tienes que decirle a VSCode que vas a escribir Julia, lo que puede hacerse a través de la opción `Seleccionar un lenguaje`, o guardando el archivo con el tipo de archivo `.jl`. VSCode te pedirá que abras una carpeta, lo que permitirá guardar sus archivos en una ubicación elegida, y también determinar el lugar desde el que partirá cualquier ruta de archivo posterior, permitiendo que el programa funcione independientemente de su ubicación de archivo. Una vez que un script ha sido escrito y guardado, puede ser ejecutado a través del REPL haciendo clic en el triángulo en la parte superior derecha y seleccionando `Julia: Ejecutar Archivo en REPL`. Esto no tiene un atajo de teclado automáticamente. Se pueden instalar extensiones de VSCode que facilitan la ejecución línea a línea del script, de forma más interactiva. ## Pluto.jl [Sitio web de la herramienta](https://plutojl.org/). Si tienes experiencia con los notebooks de Jupyter o similares, la primera aproximación a `Pluto.jl` no te va a sorprender, porque comparte muchas de las ideas que tienen esos entornos de trabajo. Como es el sistema que usaremos en las clases, vamos a entrar un poco en detalle acerca de sus características (y diferencias). Un notebook de Pluto se compone de pequeños bloques de código Julia (celdas) y juntos forman un cuaderno **reactivo**... esta es una de las diferencias fundamentales que encontramos entre Pluto y Jupyter, porque cuando cambias una variable, Pluto vuelve a ejecutar automáticamente las celdas que hacen referencia a ella. Esto significa que las celdas pueden incluso colocarse en orden arbitrario, y será el análisis inteligente de sintaxis de Pluto el que averigua las dependencias entre ellas y se encarga de la ejecución en el orden adecuado.  Las celdas pueden contener código Julia arbitrario, y se pueden utilizar librerías externas. No hay reescrituras de código o envolturas, Pluto sólo mira el código una vez antes de la evaluación. Las celdas se pueden reordenar y ocultar el código, por lo que hay control absoluto sobre cómo organizar la información. También permiten introducir texto escrito en [Markdown](https://www.markdownguide.org/), que es una herramienta de edición de texto sencilla pero razonablemente potente. Los notebooks se guardan como archivos Julia puros que luego se pueden importar como si hubieran sido programados en un editor normal. También se pueden exportar como un documento HTML y/o PDF. Pluto ofrece un entorno en el que el código modificado surte efecto al instante y en el que el código eliminado no deja rastro. A diferencia de Jupyter o Matlab, no existe un espacio de trabajo mutable, sino una garantía importante: !!! tip En cualquier instante, el estado del programa está completamente descrito por el código presente, no depende de anteriores evaluaciones que, quizás, se han eliminado ya del notebook actual pero han dejado una huella en el estado (como ocurre con Jupyter). Sin estado oculto, no hay errores ocultos. El entorno de programación se vuelve interactivo al dividir el código en múltiples celdas. El cambio de una celda muestra al instante los efectos en todas las demás, lo que ofrece una forma rápida y divertida de experimentar con el modelo. En el ejemplo siguiente, si se cambia el parámetro $A$ y se ejecuta la primera celda, se reevaluará directamente la segunda celda y se mostrará el nuevo gráfico.  Pluto utiliza el análisis de sintaxis para entender qué paquetes se están utilizando en un notebook, y gestiona automáticamente un entorno de paquetes privado, por lo que no es necesario instalar paquetes, se puede importar directamente cualquier paquete registrado y utilizarlo (también hay forma de importar los no registrados). Para garantizar la reproducibilidad, la información para reproducir exactamente el entorno de paquetes se almacena en el archivo del propio notebook. Cuando dos personas abren un mismo notebook con Pluto, se utilizará exactamente el mismo entorno de paquetes en los dos usuarios... automáticamente. Por último, hay una característica más: los notebooks de Pluto tienen una macro `@bind` para crear un enlace en vivo entre un objeto HTML y una variable de Julia, lo que, combinado con la reactividad, convierte a Pluto en una herramienta muy interesante  No hace falta saber nada de HTML para crear páginas interactivas, el paquete PlutoUI contiene entradas básicas como deslizadores y botones, haciendo que la interactividad en Pluto sea algo muy fácil de producir y de usar. !!! note Se puede usar HTML, JavaScript y CSS para escribir widgets personalizados. Los eventos de actualización personalizados pueden ser disparados enviando un nuevo `CustomEvent("input")`. ## Paquetes interesantes * `Plots`: La librería más famosa de visualización gráfica. **Cuidado**, parece que no funciona la instalación si lo haces desde un Julia desde la Terminal de Windows debido a un problema con la librería FFMPEG, pero la instalación de los paquetes funciona si se hace desde la terminal de Julia de VSCode (aunque experimentalmente es así, no he podido encontrar una razón para esto). Hay algunas alternativas a `Plots` que pueden usarse: * `PlotlyLight`: Orientada a JS (es una interfaz de conexión con Plotly). * **`Makie`**: Quizás la más completa de Julia. Probablemente, la que usemos durante el curso. * `IJulia`: Permite hacer uso de varias librerías interactivas en el REPL. Pero más importante, permite conectar Jupyter Notebook y Jupyter Lab con Julia: * **Jupyter Notebook**: `notebook()`, instalará conda. * **Jupyter Lab**: `jupyterlab()`, instalará conda. * `Pluto`: Notebooks enriquecidos propios de Julia. Tras instalarse, se inicia con ``` import Pluto Pluto.run() ``` * `CalculusWithJulia`: Librería asociada al curso del mismo nombre. Ver [aquí](https://jverzani.github.io/CalculusWithJuliaNotes.jl/). * `SymPy`: Permite realizar operaciones de cálculo simbólico. * `UpdateJulia`: Permite actualizar la distribución de Julia desde el propio Julia. Una vez instalado el paquete, basta cargarlo (`using UpdateJulia`), y ejecutar la instrucción `update_julia()`. Ha de tenerse presente que muchas (si no todas) de las funcionalidades que ofrece este paquete ya van incluidas en `juliaup`, pero se añade como paquete interesante porque `juliaup` está principalmente diseñado para los sistemas basados en Windows.