Temario curso

Tema 1: El entorno de Julia

• Resumen de Julia.
• Filosofía.
• No sólo, sino también...
  • ¿Qué es la ciencia de datos?
  • Comparación con otros idiomas.
• ¿Por qué Julia es rápida?
• ¿Por qué usar Julia?
  • Julia es fácil de aprender.
  • Julia está escrita (en su mayor parte) en Julia.
  • Julia puede interactuar con otros idiomas.
  • Julia tiene un sistema de tipos novedoso.
  • Julia tiene macros de tiempo de ejecución genuinas.
• Primeros pasos con Julia.
  • Un primer guión de Julia.
  • Editores e IDEs.
  • Un vistazo rápido a algo (más) de Julia.
• Gestión de paquetes.
  • Enumerar, agregar y eliminar paquetes.
  • Probando un paquete.
  • Elegir y explorar paquetes.
  • Aprendizaje automático.

Tema 2: Desarrollo en Julia

• Requisitos técnicos.
• Enteros, bits, bytes y booleanos.
  • Enteros.
  • Tipos primitivos.
  • Operadores lógicos y aritméticos.
  • Booleanos.
  • Números enteros grandes.
• Matrices.
  • Radiodifusión y comprensión de listas.
• Cálculo de funciones recursivas.
  • Tipado implícito y explícito.
• Operaciones matriciales simples.
• Caracteres y cadenas.
  • Caracteres.
  • Instrumentos de cuerda.
  • Literales de matriz de bytes.
• Números complejos y racionales.
  • Números complejos.
  • Racionales.
• Un poco de alivio.
  • El tamiz de Eratóstenes.
  • Toros y vacas.
  • Sets de Julia.
• Matrices multidimensionales.
  • Matrices dispersas.
  • Vectores dispersos.
  • Matrices diagonales dispersas.
• Matrices de datos y tramas de datos.
• Diccionarios, conjuntos, pilas y colas.
  • Diccionarios.
  • Establece.
  • Pilas y colas.

Tema 3: El sistema de tipos Julia

• Más información sobre las funciones.
  • La sintaxis do.
  • Objetos de primera clase.
  • Closures y currying.
• Argumentos de paso.
  • Argumentos predeterminados y opcionales.
  • Lista de argumentos variables.
  • Argumentos de palabras clave.
• Alcance.
• El problema de Queens.
  • Conversión entre números y cadenas.
• Tipos derivados y compuestos.
  • Una mirada al tipo racional.
  • Un tipo de datos compuesto de Vehicle.
  • Modularización.
• typealias y uniones.
  • Enumeraciones.
• Vectores multidimensionales y computación pi.
  • Parametrización.
• Vectores dimensionales superiores.

Tema 4: Las tres M

• Envío múltiple.
  • Generación de código.
• Metaprogramación.
  • Símbolos y expresiones.
  • Manipulación del árbol de código.
• Macros.
  • Macros de tiempo.
  • Macro higiene.
  • Macro expansiones.
  • MacroTools.
  • Macro reducciones.
  • Evaluación perezosa.
• Funciones generadas.
• ¿Funciones o macros?
• Modularidad.
  • Cargando un módulo.
  • Enteros modulares.
  • Métodos.
  • Ensayo.
  • Pares ordenados.

Tema 5: Interoperabilidad

• C y Fortran
  • Mapeo de tipos C.
  • Llamando a las rutinas de Fortran.
  • Funciones de Basilea y Horner en C.
• C++.
• Python, R y Java.
  • Python.
  • Yendo por el otro lado.
  • Paquetes con envolturas de Python.
  • La R (lenguaje).
  • Java.
• Trabajar con el sistema operativo y las canalizaciones.
  • Ejecución de comandos.
  • Procesamiento de texto y tuberías.
  • Encontrar archivos grandes.
• Frases ingeniosas de Perl.
  • Un par de ejemplos.
• Uso de canales de E/S de proceso.
• Interfaz con otros idiomas.
  • Perl 6.
  • Ruby.
  • Python.
  • Otros idiomas admitidos por el grupo JuliaInterop.
• Trabajar con el sistema de archivos.

Tema 6: Trabajar con datos

• E/S básicas.
  • E/S de terminal.
  • Salida de terminal.
  • Entrada de terminal.
• Archivos de texto.
  • Procesamiento de texto.
• Archivos binarios.
• Conjuntos de datos estructurados.
  • CSV y otros archivos delimitados (DLM).
  • Archivos HDF5 y JLD.
  • Formato de datos Julia (JLD).
  • Archivos XML.
• Series temporales.
• DataFrames y estadísticas.
  • DataFrames.
• Algunas estadísticas simples.
  • Densidades de kernel.
  • Hipótesis de prueba.

Tema 7: Programación Científica

• Álgebra lineal.
  • Descomposición de la matriz.
  • Ecuaciones simultáneas.
  • Valores propios y vectores propios.
  • Ecuaciones algebraicas de alto orden.
• Procesamiento de señales.
  • Análisis de frecuencia.
  • Imágenes convolucionales.
• DEs.
  • ODEs.
  • Simulando un péndulo (real).
  • Ecuaciones catastróficas.
  • Un toque de caos.
  • DEs estocásticos.
• Cálculo.
  • Diferenciación.
  • Diferenciación automática.
  • Cuadraturas.
• Optimización.
  • JuMP.
• Simulaciones estocásticas.
  • SimJulia.

Tema 8: Visualización

• Visualización textual.
  • Pantallas en línea simples.
  • Luxor.
  • Gráficos de tortugas.
  • PGFPlotes.
• Paquetes gráficos básicos.
  • PyPlot y PythonPlot.
  • Winston.
  • Gadfly.
• La API de gráficos.
  • Creación de múltiples gráficos usando.
  • Diseños.
  • Recetas.
  • Backends.
• Marcos de visualización.
  • Plotly/PlotlyJS.
  • Gráficos de estadísticas.
  • Makie.
  • Procesamiento básico de imágenes.
  • La familia Images(.jl).

Tema 9: Acceso a la base de datos

• Preliminares de la base de datos.
  • Interfaz con bases de datos.
• Bases de datos relacionales.
  • Construcción y carga.
  • Interfaz con una base de datos.
  • SQLite.
  • MySQL.
  • PostgreSQL.
  • Bases de datos JDBC.
• Bases de datos NoSQL.
  • Almacenes de datos KV.
  • Bases de datos de documentos.
• Interfaz con REST.
  • Formatos JSON/BSON.
  • Bases de datos web.
• (El) Queryverse.
  • Consulta del conjunto de datos de acciones.
  • Consultas LINQ.
  • Vega-lite.

Tema 10: Redes y multitarea

• Sockets y servidores.
  • Puertos conocidos.
  • Sockets UDP y TCP.
  • Un servidor de eco de "mundo de espejos".
• Trabajar con la web.
  • Métodos HTTP.
  • Funciones de utilidad.
  • Servidores TCP.
  • Enrutamiento.
  • Mux.
  • Rastreadores web.
  • Genie.
• Tareas y trámites remotos.
  • Tareas.
  • Trámites remotos.
  • Agujas y PI(ns).
  • Matrices distribuidas y Map-Reduce.
  • Ejecución en varias máquinas.
• Orígenes de datos distribuidos.

Tema 11: Las páginas traseras de Julia

• Configuración de Julia y el sistema operativo.
  • Obtener fuentes de Julia.
  • El subdirectorio .julia.
  • Julia.
  • Configuración(es) de inicio.
• Julia independiente.
  • Scripting.
  • Imágenes del sistema.
• Herramientas de desarrollo.
  • Cadenas de documentos.
  • Consejos de rendimiento.
  • Depuración.
  • Revisión.
  • Perfiles.
• Creación de paquetes.
  • A "funky" module.
  • Creación del diseño.
  • Colaborando con Git.