Instalación y entorno

J1.1 · Nivel J1 · Julia esencial

Una ventana de terminal con el prompt de Julia, la señal de un acelerómetro con dos frecuencias y tres celdas de un cuaderno reactivo

Todo lo que viene después en el curso (señales, modos, identificación) se programa en Julia. Esta unidad deja listo el puesto de trabajo: Julia instalado y actualizable, un REPL que sepas manejar, un editor cómodo y la idea clara de dónde se ejecuta qué. Al final habrás generado y dibujado tu primera señal de vibración.

NotaCómo se lee esta unidad

Tiempo orientativo: 60 minutos. Objetivos y prerrequisitos (3), teoría en cinco píldoras (12), práctica guiada (25), «Pídeselo a Claude» (8), ejercicios (10) y cierre (2). Las pestañas Python de la práctica no se ejecutan en la web: su versión probada está en la carpeta python/ de la unidad.

Objetivos y prerrequisitos

Objetivos. Al terminar esta unidad sabrás:

  • instalar Julia con juliaup, comprobar la versión y cambiar de versión;
  • moverte por los cuatro modos del REPL (evaluar, ayuda, shell y paquetes);
  • ejecutar un script con julia --project=. y explicar por qué se usa siempre esa opción;
  • decidir si una tarea va al REPL, a un script, a un cuaderno Pluto o a una página de Quarto;
  • generar y dibujar una señal sintética con semilla fija.

Prerrequisitos. Ninguno. Conviene haber usado una terminal alguna vez; si no, C2 la explica desde cero.

Reparto con otras unidades. Aquí se instala y se explora. El gestor de paquetes y los ficheros Project.toml y Manifest.toml se explican en J1.2; el lenguaje en sí empieza en J1.3.

Teoría breve

NotaUn poco de historia: por qué se creó Julia

En febrero de 2012, Jeff Bezanson, Stefan Karpinski, Viral Shah y Alan Edelman presentaron Julia con una entrada titulada «Why We Created Julia». Explicaban, con humor, que lo querían todo: un lenguaje libre, tan rápido como C y tan dinámico como Ruby, con la notación matemática de MATLAB y macros al estilo de Lisp, fácil para quien empieza y potente para quien programa a fondo, y con despacho múltiple para escribir algoritmos genéricos una sola vez (Bezanson et al. 2012). Una nota de la propia entrada aclara que la versión 1.0 llegó mucho más tarde, en 2018.

Fuente: blog de Julia, 14-02-2012 (Bezanson et al. 2012). Consultado el 26-10-2026.

Bezanson, Jeff, Stefan Karpinski, Viral B. Shah, y Alan Edelman. 2012. Why We Created Julia. Blog de Julia, 14-02-2012. Consultada el 26-10-2026. https://julialang.org/blog/2012/02/why-we-created-julia/.

J1.1.1 Instalar Julia con juliaup

juliaup es el instalador y gestor de versiones oficial. Instala Julia, lo mantiene actualizado y permite tener varias versiones a la vez, que es lo que necesitamos para comprobar que el código funciona en la versión estable y en la de soporte largo (LTS).

TipChuleta: juliaup 
juliaup status          # versiones instaladas y canal por defecto
juliaup add 1.10        # instala además la versión LTS
juliaup default 1.12    # versión que arranca con «julia»
julia +1.10             # arranca una versión concreta, sin cambiar la de por defecto
juliaup update          # actualiza todo

Dentro de Julia, VERSION devuelve la versión en uso:

Ver el código 
VERSION
v"1.12.3"
AdvertenciaErrores frecuentes

Instalar Julia desde un gestor de paquetes del sistema suele dar una versión antigua y sin forma sencilla de cambiarla. Usa juliaup (en Windows, desde la tienda de Microsoft o con winget; en macOS y Linux, con el script de instalación de la página oficial de Julia).

Con juliaup se pueden tener instaladas a la vez Julia 1.10 y Julia 1.12 y elegir cuál arrancar.

Verdadero. juliaup add 1.10 instala la versión LTS junto a la de por defecto y julia +1.10 la arranca sin cambiar el valor por defecto.

J1.1.2 Los cuatro modos del REPL

El REPL (read–eval–print loop) es la consola de Julia: escribes una expresión, Julia la evalúa y muestra el resultado. Se cambia de modo con la primera tecla de una línea vacía, y se vuelve al modo normal con la tecla de retroceso:

Se escribe Modo Prompt Para qué sirve
(nada) Julia julia> evaluar código
? Ayuda help?> documentación de una función: ?rms
; Shell shell> comandos del sistema sin salir: pwd, ls
] Paquetes (@v1.12) pkg> instalar y activar entornos (se verá en J1.2)

Tres trucos que ahorran mucho tiempo: la flecha arriba recupera la historia, el tabulador completa nombres y ans guarda el último resultado. Además, el tabulador convierte secuencias de LaTeX en símbolos: \omega + tabulador da ω y \zeta + tabulador da ζ, que son los nombres que usa el curso para la frecuencia angular y el amortiguamiento.

Ver el código 
ω = 2π * 2.5          # rad/s, la frecuencia de 2,5 Hz
ζ = 0.02              # amortiguamiento, adimensional
round(ω, digits=3)
15.708

¿Qué valor da 2π * 2.5 en rad/s?

\(2\pi\cdot2{,}5\approx15{,}708\) rad/s (se comprueba en el REPL).

J1.1.3 Scripts y --project=.

Un script es un fichero .jl que se ejecuta de principio a fin y da siempre el mismo resultado, que es lo que queremos para un cálculo que se repite. Se lanza desde la terminal, en la raíz del repositorio:

julia --project=. scripts/mi_calculo.jl

La opción --project=. le dice a Julia que use el entorno del proyecto (la lista de paquetes y versiones del curso, ficheros Project.toml y Manifest.toml) y no el entorno personal de quien lo ejecuta. Sin ella, el mismo script puede funcionar en un ordenador y fallar en otro por una versión distinta de un paquete. Dentro de un script, @__DIR__ da la carpeta del propio fichero, y con joinpath se construyen rutas que no dependen de desde dónde se lance.

julia script.jl y julia --project=. script.jl usan siempre los mismos paquetes y las mismas versiones.

Falso. Sin --project=. se usa el entorno por defecto de cada usuario; con la opción, el del proyecto. Por eso en el curso se escribe siempre --project=..

J1.1.4 VS Code con la extensión de Julia

VS Code, con la extensión oficial de Julia, es el editor recomendado. Aporta coloreado, ayuda al pasar el ratón, navegación a la definición y un REPL integrado. El flujo de trabajo es: abrir la carpeta del repositorio (no un fichero suelto, para que encuentre el entorno), arrancar el REPL con la orden Julia: Start REPL y ejecutar la línea o la selección con Mayús + Intro. Sirve cualquier otro editor, pero la extensión de VS Code es la que ofrece más ayuda.

J1.1.5 Pluto: un cuaderno reactivo para explorar

Pluto.jl es un cuaderno en el que cada celda es una expresión y, cuando cambias una variable, se recalculan automáticamente todas las celdas que dependen de ella. Es muy cómodo para probar un deslizador o ver qué pasa al variar un parámetro. En este curso se usa solo para explorar; lo que se publica y se verifica son las páginas de Quarto, que ejecutan Julia al compilar.

# Una vez, en el entorno personal de Julia (no en el del curso):
] add Pluto
# Cada vez que se quiera usar:
using Pluto; Pluto.run()
Cuatro cajas: REPL, Script, Pluto y Quarto. Una flecha va del REPL al script (se guarda) y del script a Quarto (se documenta). Otra va del REPL a Pluto y de Pluto al script. Debajo, una nota: todos usan el mismo entorno, julia --project=.
Figura 1: Dónde se ejecuta Julia según lo que se quiere hacer: el REPL para probar una línea, el script para repetir un cálculo, el cuaderno Pluto para explorar y la página de Quarto para explicar y publicar.
NotaIdea clave

Se prueba en el REPL, se guarda en un script y se explica en Quarto. Los tres usan el mismo entorno (--project=.), y por eso el resultado es el mismo en cualquier ordenador.

Para cada tarea, di si usarías el REPL, un script, Pluto o Quarto: (a) comprobar qué devuelve sqrt(-1); (b) procesar cada noche los registros del día; (c) ver cómo cambia un espectro al mover el amortiguamiento; (d) entregar un informe con código y figuras.

  1. REPL. (b) Script, porque debe repetirse sin intervención. (c) Pluto, por los deslizadores. (d) Quarto, porque junta texto, código y figuras y se compila de forma reproducible.
AdvertenciaErrores frecuentes: confundir los modos del REPL

Escribir ls en el prompt julia> da UndefVarError, porque es un comando de shell: hay que pulsar ; antes. Y escribir add Distributions fuera del modo paquetes da un error de sintaxis: hay que pulsar ] antes. El prompt que se ve (julia>, shell>, pkg>) dice en qué modo estás; se vuelve al normal con la tecla de retroceso.

Para saber más

Lauwens, Ben, y Allen B. Downey. 2019. Think Julia: How to Think Like a Computer Scientist. O’Reilly Media. https://benlauwens.github.io/ThinkJulia.jl/latest/book.html.

Práctica guiada

Vamos a generar la señal que un acelerómetro mediría en un edificio con dos modos: uno de 2,5 Hz y otro, más débil, de 7 Hz, con algo de ruido. Es el mismo tipo de señal que se analizará en M3. Se fija la semilla para que cualquiera obtenga exactamente los mismos números.

Paso 1. Crear la señal. 1000 muestras a 100 Hz son 10 s. Todas las magnitudes en unidades del SI (tiempo en s, aceleración en m/s²).

Ver el código 
Random.seed!(1)
fs = 100.0                                   # frecuencia de muestreo, Hz
T = 10.0                                     # duración, s
t = (0:Int(fs * T) - 1) ./ fs                # vector de tiempos, s
limpia = sin.(2π * 2.5 .* t) .+ 0.4 .* sin.(2π * 7.0 .* t)
x = limpia .+ 0.2 .* randn(length(t))        # con ruido
(muestras = length(x), rms_limpia = round(sqrt(mean(abs2, limpia)), digits=4),
 rms_con_ruido = round(sqrt(mean(abs2, x)), digits=4))
(muestras = 1000, rms_limpia = 0.7616, rms_con_ruido = 0.7731)

El valor eficaz (RMS) de la señal limpia es \(\sqrt{(1^2+0{,}4^2)/2}\approx0{,}7616\) m/s², y el ruido lo sube ligeramente. El punto delante de un operador (.*, .+) y detrás de una función (sin.) significa «elemento a elemento»; se explica en J1.5.

Paso 2. Dibujarla. Las figuras de la web se hacen con CairoMakie y el tema del curso.

Ver el código 
fig = Figure(size=(720, 300))
ax = Axis(fig[1, 1], xlabel="tiempo (s)", ylabel="aceleración (m/s²)")
n = Int(2fs)
lines!(ax, t[1:n], x[1:n], color=AZUL, label="medida")
lines!(ax, t[1:n], limpia[1:n], color=NARANJA, label="sin ruido")
axislegend(ax, position=:rt)
fig
Curva de aceleración frente al tiempo entre 0 y 2 segundos, con una oscilación lenta de 2,5 hertz y una más rápida y débil encima, y un ruido fino; la señal limpia aparece superpuesta en naranja.
Figura 2: Señal sintética de un acelerómetro: dos modos (2,5 Hz y 7 Hz) más ruido, a 100 Hz durante 10 s. Se muestran los dos primeros segundos.

Paso 3. Guardarlo como script. Cuando la prueba funciona en el REPL, se copia a un fichero. Si lo guardas como scripts/primera_senal.jl, lo lanzas con julia --project=. scripts/primera_senal.jl.

La versión equivalente, probada con pytest, está en python/senal.py. El entorno se gestiona con uv (no se usa conda):

uv run python
from senal import senal_dos_modos, rms

t, x = senal_dos_modos(fs=100.0, T=10.0, f1=2.5, f2=7.0, a1=1.0, a2=0.4)
print(len(x), round(rms(x), 4))     # 1000 0.7616

La parte determinista coincide con la de Julia al detalle (la prueba lo comprueba). El ruido no se compara: los generadores aleatorios de Julia y de NumPy son distintos aunque se fije la semilla.

NotaQué se ha conseguido

Una señal con semilla fija, su valor RMS comprobado a mano y una figura con unidades en los ejes. Es la receta de todo el curso: datos con semilla, valor numérico comprobado, figura con unidades y pie.

«Pídeselo a Claude»

TipPrompt

«Estoy en la raíz del repositorio resonancia. Con Julia y --project=.: (1) dime qué versión de Julia hay y si coincide con la de juliaup status; (2) crea scripts/primera_senal.jl que genere una señal de 10 s a 100 Hz con dos senoides de 2,5 Hz y 7 Hz (amplitudes 1 y 0,4) y ruido gaussiano de desviación 0,2 con semilla 1, e imprima su RMS; (3) ejecútalo y dime el resultado. No instales ni actualices ningún paquete. Si algo falla, dímelo en vez de inventar el resultado.»

Verifica. (a) Que el comando usa --project=.. (b) Que el RMS de la señal sin ruido sale \(0{,}7616\), que es lo que se calcula a mano con \(\sqrt{(1+0{,}16)/2}\). (c) Que la semilla está fijada antes de randn. (d) Que no ha modificado Project.toml ni Manifest.toml (míralo con git diff). (e) Que el tiempo está en segundos y que el eje de la figura, si la hace, lleva unidades.

Ejercicios

Una señal de 10 s muestreada a 100 Hz, ¿cuántas muestras tiene?

\(N=f_s\,T=100\cdot10=1000\) muestras (en Julia, Int(fs * T)).

Escribe una expresión de Julia que dé el valor RMS del vector [3, 4]. Indica el resultado.

El RMS es la raíz cuadrada de la media de los cuadrados: mean(abs2, x) calcula esa media (hace falta using Statistics).

sqrt(mean(abs2, [3, 4])) da \(\sqrt{12{,}5}\approx3{,}5355\).

Explica con tus palabras por qué se fija la semilla del generador aleatorio en todos los ejemplos del curso.

  • Menciona que sin semilla cada ejecución da números distintos.
  • Relaciona la semilla con la reproducibilidad y con poder comparar resultados.

La doy por superada si…

  • Sé decir con qué comando compruebo la versión de Julia y cómo arranco otra distinta.
  • Me muevo por los cuatro modos del REPL y vuelvo al modo normal sin ayuda.
  • Ejecuto un script con julia --project=. fichero.jl y sé explicar para qué sirve --project=..
  • Elijo entre REPL, script, Pluto y Quarto según la tarea.
  • He generado la señal de la práctica con semilla fija y he comprobado su RMS.

Cierre. Responde por escrito en tres líneas: qué he entendido, qué todavía no domino y cuál es mi siguiente paso pequeño. Si has usado a Claude, revisa con git diff lo que ha cambiado antes de aceptarlo.

Siguiente: J1.2 · Paquetes y reproducibilidad.

Referencias

Son las mismas que aparecen en el margen, junto al texto. La lista completa del curso, con el estado de verificación de cada ficha, está en recursos/bibliografia.bib del repositorio.

Bezanson, Jeff, Stefan Karpinski, Viral B. Shah, y Alan Edelman. 2012. Why We Created Julia. Blog de Julia, 14-02-2012. Consultada el 26-10-2026. https://julialang.org/blog/2012/02/why-we-created-julia/.

Lauwens, Ben, y Allen B. Downey. 2019. Think Julia: How to Think Like a Computer Scientist. O’Reilly Media. https://benlauwens.github.io/ThinkJulia.jl/latest/book.html.

Referencias