1.2 juliacon2024 2024-07-09 2024-07-12 4 00:05 https://pretalx.com Europe/Amsterdam TU-Eindhoven -1.350 Workshop 2024-07-09T09:00:00+02:00 09:00 03:00 Everybody wants fast code, but not everyone knows how to write it. Thankfully, Dagger.jl can help you write fast, parallel code with such ease as you've never known before. In this workshop, we will teach you everything you need to know to use Dagger effectively, and work through building example parallel programs with Dagger. juliacon2024-43438-productive-parallel-programming-with-dagger-jl Accelerated & large-scale computing /media/juliacon2024/submissions/D3Y7KW/Final-medium_JjEvDmJ.jpg Przemysław SzufelJulian P Samaroo en Traditional parallel programming can be very hard to do effectively, as there are many prerequisites to know, and many tools that need to be used correctly and combined for maximum performance. Because of this, many programmers never learn how to write code that can scale beyond a single thread or a single server; and when parallelism is added to code, it often only supports one or a limited number of systems and hardware devices, which excludes users with unsupported systems from using that code effectively. Dagger.jl aims to help fix this problem for Julia code, by providing a full parallel programming environment that closely matches how users already write code. Instead of forcing users to learn a new programming paradigm or opinionated API, Dagger provides a variety of familiar interfaces - like tasks, arrays, tables, and graphs - so that users can pick the interface that matches their existing code and algorithms. And once any of those interfaces are used, Dagger seamlessly parallelizes the user's code and allows it to run automatically on multiple CPUs, multiple servers, on a variety of GPUs, and more, and even manages data by moving it to disk when available memory is tight. This workshop is focused on users who feel comfortable with Julia, but struggle with adding parallelism to their code. This workshop will start out by introducing Dagger and explaining how it works at a high level. Then, we will dive into the various programming interfaces (tasks, arrays, tables, graphs, and more) that Dagger provides, show how they can be used just like their non-Dagger counterparts, and then work through an example program built with each programming paradigm. Along the way, we will also see how to user Dagger's logging and profiling capabilities to gain insights into what Dagger is doing behind the scenes, so that we can better observe where our parallelism is coming from. If there is enough time, we will also cover more advanced topics like how to utilize GPUs, MPI interfacing, and more. false GitHub https://pretalx.com/juliacon2024/talk/D3Y7KW/ https://pretalx.com/juliacon2024/talk/D3Y7KW/feedback/ TU-Eindhoven -1.350 Workshop 2024-07-09T13:30:00+02:00 13:30 03:00 Julia offers the flexibility of a high-productivity language while providing control, performance, and compatibility with high-performance computing (HPC) hardware. This workshop demonstrates how Julia makes modern HPC accessible. It covers resource configuration, distributed computing, code optimization for CPUs and GPUs, and versatile workflows. Participants will have the opportunity to experience it firsthand with a hands-on session on a GPU-powered supercomputer. juliacon2024-43634-hands-on-with-julia-for-hpc-on-gpus-and-cpus Accelerated & large-scale computing /media/juliacon2024/submissions/NTQZJJ/Julia_for_HPC_-_workshop_vdgRdKX.png Carsten BauerLudovic RässJohannes BlaschkeIvan Utkin en **URGENT: You have a workshop ticket and plan to attend the workshop in person? Then please apply for a NERSC account as soon as possible!** Check out the instructions [here](https://github.com/JuliaHPC/juliacon24-hpcworkshop). Why to wait hours for computations to complete, when it could take only a few seconds? Tired of prototyping code in an interactive, high-level language and rewriting it in a lower-level language to get high-performance code? By its design, Julia offers the flexibility of a high-productivity language, without sacrificing the control, the performance, and the idiosyncrasies that are often demanded by high-performance computing (HPC) hardware. This workshop demonstrates how modern HPC is made accessible to a broad range of users using Julia. We will cover technical backgrounds and hands-on examples in contemporary uses of HPC systems: resource configuration and management; distributed computing; optimising code of CPUs and GPUs; sophisticated workflows that can run (almost) anywhere! If you’re using HPC systems right now, or if you’re just curious about HPC, this workshop is right for you. **Program** The workshop consists of 2 parts: 1. You will learn the basics of how to develop applications and workflows for HPC systems. Topics covered in the first part are: - Managing your software environment on HPC systems - Multithreading - Distributed computing (structured and unstructured communication using [MPI.jl](https://github.com/JuliaParallel/MPI.jl), [Distributed.jl](https://github.com/JuliaLang/Distributed.jl), and [Dagger.jl](https://github.com/JuliaParallel/Dagger.jl)). - Developing code for GPUs. Each of the topics above will be presented in the form of technical background, and accessible hands-on examples. Since performance is key, we will also cover the relevant performance optimization tools for each area. 2. Once you’re armed with the necessary knowledge, we will spend the second part developing an HPC application on a supercomputer: [NERSC’s Perlmutter system](https://www.nersc.gov/systems/perlmutter/). The application you will implement will be driven entirely from NERSC’s Jupyter Hub, and it will make use of multiple nodes and GPUs. Packages you will learn about/use: [MPI.jl](https://github.com/JuliaParallel/MPI.jl), [Dagger.jl](https://github.com/JuliaParallel/Dagger.jl), [HDF5.jl](https://github.com/JuliaIO/HDF5.jl), [IJulia.jl](https://github.com/JuliaLang/IJulia.jl). We will provide access to training accounts on NERSC’s “Perlmutter” system. Please apply to get our training account no later than a week before the workshop. **Details will be posted here: https://juliaparallel.org/tutorials/.** **Goals** By the end of this workshop, you will have acquired or refreshed the basics of how to develop applications and workflows for HPC systems using Julia. In the first part, you will learn about basic tools using simple examples. Then, in a second part, you will develop a parallelized version of a serial code and run it on NERSC’s GPU-accelerated supercomputer Perlmutter. We look forward to having you on board and will make sure to foster exchange of ideas and knowledge to provide an as inclusive as possible event. **Prerequisite Knowledge** This workshop assumes a basic knowledge of the Julia language (language structure such as functions and modules, control flow, and data types including arrays), and coding best practices (such as git, ssh, and limited usage of the Bash command line interface). We will cover the fundamentals of multi-threading, distributed, and GPU computing; as well as how these relate to modern HPC systems. Now prerequisite knowledge in these areas is needed. false https://pretalx.com/juliacon2024/talk/NTQZJJ/ https://pretalx.com/juliacon2024/talk/NTQZJJ/feedback/ TU-Eindhoven -1.354 Workshop 2024-07-09T09:00:00+02:00 09:00 03:00 Acausal modeling tools such as ModelingToolkit, Modelica, and Simscape are widely used for industrial modeling, simulated real-world phenomena such as hydraulic, HVAC, and multibody systems. In this tutorial we will dive into how to easily build large-scale high-fidelity models with ModelingToolkit and use its embedding within the Julia programming language in order to transform high level descriptions into simpler equations and simulate the resulting models with the tools of Julia's SciML. juliacon2024-43873-hierarchical-component-based-modeling-with-modelingtoolkit-jl SciML Chris RackauckasMichael Tiller en ModelingToolkit is the symbolic modeling layer of Julia's SciML. SciML covers many areas of numerical modeling and simulation, such as linear systems of equations, nonlinear systems of equations, differential equations, and optimization. Similarly, ModelingToolkit is a symbolic modeling language which covers the same interfaces and shuttles to the underlying numerical solvers. What makes ModelingToolkit interesting is its ability to allow for reusable component-based modeling and its ability to perform automatic simplification of the resulting equations. This allows for efficient hierarchical modeling, where libraries of components define items like engines and air compressors, and then modelers can easily build large models by connecting the existing physical components to generate composed models. The resulting composed model is then simplified to give a representation of he system that is fast to simulate, but without being slow to model. In this workshop we will showcase how to build steady state models, transient models, and optimization models. We will showcase the ModelingToolkitStandardLibrary as a source of pre-built components that can be used to quickly get started, and we will show how ModelingToolkit interacts with the growing set of tooling around it, including graphical user interfaces (GUIs), specialized solvers, and model analysis tooling. This includes: - Moment closure expansions - File readers for importing models (SBML, CellML) - MathOptInterface special integrations for Optimization - Structural identifiability analysis - Linearization and much more. false https://pretalx.com/juliacon2024/talk/YPPSBF/ https://pretalx.com/juliacon2024/talk/YPPSBF/feedback/ TU-Eindhoven -1.354 Workshop 2024-07-09T13:30:00+02:00 13:30 03:00 If there is something YOU know about a physical system, AI shouldn’t need to learn it. How to integrate your system knowledge into an ML development process is the core topic of this hands-on workshop. The entire workshop evolves around a challenging use case from robotics: Modeling a robot that is able to write arbitrary messages with a pen. After introducing the topic and the considered use case, participants can experiment with their very own robot model. juliacon2024-44391-scientific-machine-learning-using-functional-mock-up-units SciML /media/juliacon2024/submissions/9KQJFS/Icon_w0WIAUe.png Tobias ThummererLars Mikelsons en This workshop focuses on the integration of Functional Mock-Up Units (FMUs) into a machine learning topology. FMUs are simulation models that can be generated within a variety of modeling tools (https://fmi-standard.org/). Together with deep neural networks that complement and improve the FMU prediction, so called NeuralFMUs can be created. Example use cases that show the potentials of this technique are given during the introduction. The workshop itself evolves around the modeling of a Selective Compliance Assembly Robot Arm (SCARA), that is able to write user defined words on a sheet of paper. A ready to use physical simulation model (FMU) for the SCARA is given and shortly highlighted during the workshop. However, this model – as any simulation model – shows some deviations if compared to measurements from the real system. These deviations result from unmodeled so called slip-stick-friction: The pen sticks to the paper until a force limit is reached, but then moves jerkily. A hard to model physical effect – but not for a NeuralFMU. The workshop divides into the following slots: - [5min] Preparing notebook - [60min] Thematic introduction: Scientific Machine Learning / Hybrid Modeling / SCARA - [10min] Coding Together: Examination of the used model (FMU) and data - [75min] Exploring the notebook: Designing and training the hybrid model - [30min] Wrap-up, Results, Closing the workshop After completing the workshop, participants will be able to answer the following questions: - What is hybrid modeling and what are advantages/disadvantages compared to modeling based on physical principles or pure machine learning models? - How can the physical modeling and machine learning world be connected? What needs to be considered? - What are NeuralODEs and NeuralFMUs? - How does the choice of signals between physical model (FMU) and machine learning model influence the training success and computational performance? - ... and more! Equipped with the knowledge about the necessary steps to build a proper hybrid model for the SCARA, workshop participants will have an easier time dealing with their own hybrid modeling applications. Participants only need access to a computer with Julia installed (tested under v1.10) running Windows (tested Windows 10) or Linux (tested Ubuntu 22.04 LTS). To ensure a productive experience for all participants, major parts of modeling and coding are pre-implemented as interactive Pluto-Notebook. This way, participants can explore the topic at their own pace according to their previous knowledge. The notebook stays available after the workshop. false Workshop Notebook Workshop (Presentation) Slides https://pretalx.com/juliacon2024/talk/9KQJFS/ https://pretalx.com/juliacon2024/talk/9KQJFS/feedback/ TU-Eindhoven 0.242 Workshop 2024-07-09T09:00:00+02:00 09:00 03:00 Computational models are a valuable tool to study dynamic interactions and the evolution of systems behavior. Our hands-on and interactive workshop will demonstrate how personalized models can be more rapidly generated in Julia using various SciML packages combined with custom implementations. We will cover the implementation of ODE models in Julia, parameter estimation and model selection strategies including parameter sensitivity and identifiability analysis. juliacon2024-44390-julia-for-systems-biology-generating-personalized-models Biology & Life Sciences Max de RooijShauna O'DonovanNatal van Riel en Computational models offer a valuable tool for understanding the dynamic interactions between different biological entities, especially in biomedical applications. Personalizing these models with data can shed light on interindividual variation and project future health risks. However, model generation can be computationally expensive. Our hands-on and interactive workshop will demonstrate how personalized models can be more rapidly generated in Julia. We will be mainly using DifferentialEquations.jl combined with Optimization.jl and custom implementations of sensitivity and identifiability analysis approaches. Useing an in-house model of the glucose-insulin system, we will cover the implementation and resolving of ODE systems in Julia, including importing in SBML. We will provide a guide on model selection including parameter sensitivity and identifiability analysis, highlighting efficiencies that can be achieved using Julia. Additionally, we will discuss strategies for parameter estimation, including the benefits of regularization, using a publicly available data set of meal responses. Short presentation will be used to provide necessary background and theory and all methods will be implemented in a Jupyter notebook to facilitate independent learning. false https://pretalx.com/juliacon2024/talk/EFCQMK/ https://pretalx.com/juliacon2024/talk/EFCQMK/feedback/ TU-Eindhoven 0.242 Workshop 2024-07-09T13:30:00+02:00 13:30 03:00 Wanna learn how to write a stellar documentation, that will satisfy newcomers, make them quickly and efficiently learn your software, and even motivate them to become contributors? Then join this workshop all about one of the most important aspects of software development: _documentation!_ You will learn the core principles of good docs, tips & tricks, and you will write good docs yourself, during the workshop! Plus you'll learn to create docs and host them online using Documenter.jl! juliacon2024-39590-writing-and-maintaining-an-exceptional-documentation General Morten PiibelehtFredrik EkreGeorge Datseris en _**Note: you should bring the codebase you want to document with you in this workshop! The exercises are applied to your own codebase!**_ This workshop is all about documentation. It's one of the most important aspects of code and software: it makes your code accessible to others, makes their experience with it pleasant, makes them wanna keep using it for the long run, and lowers the threshold for them to become contributors! Whether you are a maintainer of several registered Julia packages, or a just someone with an unregistered codebase that you believe can be useful for others, this workshop will be of use to you! The workshop will be fully hands-on, and will be composed by several iterations of [lecture -> application] for the covered topics. The main things it will cover are (among others, and depending on the real-time flow): 1. Core principles of what makes a good documentation. 1. The skeleton of a good documentation: exceptional, unambiguous docstrings. 1. The different depths of exposition approach to documentation. 1. The introductory tutorial. 1. Tips & tricks for increasing clarity in the docs. 1. Intro to Documenter.jl: key syntax and functions. 1. Using Documenter.jl+Literate.jl to generate a runnable tutorial. 1. Layouting documentation pages. 1. Using Documenter.jl to compile a documentation locally into HTML. 1. Using Documenter.jl to deploy documentation online on a GitHub repository. 1. Using DocumenterCitations.jl to cite literature robustly. 1. Tips for reducing maintainance burden. false Workshop Slides (please download!) https://pretalx.com/juliacon2024/talk/GFCSRB/ https://pretalx.com/juliacon2024/talk/GFCSRB/feedback/ TU-Eindhoven 0.264 Workshop 2024-07-09T09:00:00+02:00 09:00 03:00 Kick-start JuliaCon 2024 with this half-day workshop to pick up the language. Discover what makes Julia special and start writing your own code right away. No prior Julia experience is necessary; this workshop is geared towards anyone with basic programming knowledge from another language. juliacon2024-49355-introduction-to-julia General Matt Bauman en The goal of this workshop is to provide you with a broad overview of the language and establish a foundation for the rest of the week. We will cover Julia's syntax and data structures as well as its marquee features, including multiple dispatch, its type system, and a few common packages. false https://pretalx.com/juliacon2024/talk/7NGHZP/ https://pretalx.com/juliacon2024/talk/7NGHZP/feedback/ TU-Eindhoven 0.264 Workshop 2024-07-09T13:30:00+02:00 13:30 03:00 Rust is great but not for Julians - unless you come to this talk and learn to go around the rougher spots we face when interacting with Rust for real world scenarios. juliacon2024-44416-julia-and-rust-safer-abstractions-and-ffi-workshop General Miguel Raz Guzmán Macedo en We'll cover stuff like: - Basic and Advanced LSP setup for the best Rust integration - Common Rust footguns that will be encountered by Julia folks - A small project to generate bindings using `cbindgen` and `diplomat` - Miss BenchmarkTools.jl? We'll cover the best of `divan` - Iterators tricks to speed up your Rust code false https://pretalx.com/juliacon2024/talk/RCZT83/ https://pretalx.com/juliacon2024/talk/RCZT83/feedback/ REPL (2, main stage) Ceremony 2024-07-10T08:50:00+02:00 08:50 00:10 Opening the first day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer. juliacon2024-53124-opening-ceremony Raye Kimmerer en Opening the first day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer. false https://pretalx.com/juliacon2024/talk/ACGZ3A/ https://pretalx.com/juliacon2024/talk/ACGZ3A/feedback/ REPL (2, main stage) Keynote 2024-07-10T09:00:00+02:00 09:00 01:00 It is time again to take a look at what new exciting things have happened with Julia; the language, the package ecosystem and the community. Join us as we explore these advancements and celebrate the progress of Julia in 2024. juliacon2024-45603-state-of-julia-2024 General Kristoffer CarlssonLilith HafnerElliot Saba en It is time again to take a look at what new exciting things have happened with Julia; the language, the package ecosystem and the community. Join us as we explore these advancements and celebrate the progress of Julia in 2024. false https://pretalx.com/juliacon2024/talk/3EZMQM/ https://pretalx.com/juliacon2024/talk/3EZMQM/feedback/ REPL (2, main stage) Silver sponsor talk 2024-07-10T10:00:00+02:00 10:00 00:15 Juliet is the first robot programming language that is low-latency real-time multitasking while being safe and fully dynamic with automatic memory management as supported by the new real-time virtual machine Romeo. Juliet&Romeo provides a Julia-compatible platform for machine control, with digital twins and AI features co-existing as Julia packages. juliacon2024-51434-juliet-romeo-making-julia-a-hard-real-time-robot-language Klas NilssonKan Wu en Robots are machines that are system-programmable by robot producers and system integrators, and then user-programmable by different means for defining the task at hand. System programs have so far been written in unsafe languages like C++, also used for implementing an interpreter for the user language. User languages have up to now been programmatically very limited and specific for each robot brand, while on the other hand supporting interactive motion programming quite well, including simplified multi-tasking control and backwards execution as required for a robot programming language. It is hereby announced a new more advanced take on robot programming, with simplicity for non-programmers in mind: Juliet is the first robot programming language that is low-latency real-time multitasking while being safe and fully dynamic with automatic memory management as supported by the new real-time virtual machine Romeo. Juliet&Romeo (1) provides a Julia-compatible platform for machine control, with Digital Twins and AI features co-existing as Julia (2) packages. (1) Juliet&Romeo is a registered trademark of Cognibotics AB and Estun Automation Co, Ltd. (2) Julia is a registered trademark of Julia Computing Inc. false https://pretalx.com/juliacon2024/talk/NFEKFJ/ https://pretalx.com/juliacon2024/talk/NFEKFJ/feedback/ REPL (2, main stage) Platinum sponsor talk 2024-07-10T10:15:00+02:00 10:15 00:25 JuliaHub has been developing JuliaSim - a modern modeling and simulation tool that leverages Julia and ModelingToolkit.jl’s unique capabilities. In this talk, we will show how JulaSim’s capabilities are being used across industrial, automotive and aviation firms. Gary Mansouri, Chief Architect of Systems MBE at Boeing, will join us for a conversation on the process of model based design. juliacon2024-51433-juliasim-bringing-julia-to-industrial-modeling-and-simulation Chris RackauckasViral B. ShahGary Mansouri en JuliaHub has been developing JuliaSim - a modern modeling and simulation tool that leverages Julia’s unique capabilities. JuliaSim aims to bridge the two cultures problem in engineering product design, combining vastly better modeling and simulation capabilities along with code deployment capabilities. JuliaSim builds upon the ModelingToolkit.jl framework by adding a GUI as well as a new compiler backend. In addition, JuliaSim also includes a set of advanced model libraries for HVAC, batteries, and Multibody (with new ones being continuously developed). In this talk, we will show how JulaSim’s capabilities are being used across industrial, automotive and aviation firms. Gary Mansouri, Chief Architect of Systems MBE at Boeing, will join us for a conversation on the process of model based design and digital engineering related to systems product development. Boeing is a leading global aerospace company and is committed to innovating for the future, leading with sustainability, and cultivating a culture based on the company’s core values of safety, quality and integrity. false https://pretalx.com/juliacon2024/talk/HDY8LE/ https://pretalx.com/juliacon2024/talk/HDY8LE/feedback/ REPL (2, main stage) Talk 2024-07-10T11:00:00+02:00 11:00 00:30 This is a tutorial on how to use the tools shipped with Julia in Core.Compiler to manipulate the Julia IR and thus change how the program is compiled. It includes running custom code transforms (like for autodiff), custom optimization passes, and introducing custom intrinsics. This talk is for advanced Julia users, who want to understand and (ab)use the internals. juliacon2024-43067-adventures-in-julia-ir-plundering-core-compiler Julia Internals and Tooling Frames Catherine White en Slides: https://raw.githack.com/oxinabox/JuliaCon2024_IR_talk/main/reveal.js/index.html Julia uses several intermediate representations (IR) during the compilation process. The abstract syntax tree (AST), untyped IR, typed IR, LLVM IR. Different transforms happen as these different stages, and they can be extended by you. In contrast to previous talks presented at JuliaCon, the focus of this talk is on typed-IR, rather than the untyped IR commonly manipulated with Cassette or IRTools.jl. This talk will cover in detail how passes transform the code, showing how to implement and deploy custom passes for optimization. This will allow you to control how your code is optimised, or even introduce new semantics beyond what is possible at the lexical/syntax level via conventional metaprogramming. The exact content and methods presented in this talk are likely to break without warning, as they use extensively the internals of the language which are subject to change without regards to SemVer. However, the general learning and approach will remain relevant. false https://pretalx.com/juliacon2024/talk/D3H79J/ https://pretalx.com/juliacon2024/talk/D3H79J/feedback/ REPL (2, main stage) Talk 2024-07-10T11:30:00+02:00 11:30 00:30 Recent improvements to compilation caching in Julia have made it feel a lot more snappy :) Except when you use non-native compilation (think GPUs or Automatic Differentiation) :( In this talk I will dive into recent progress on non-native compilation caching, how Julia performs caching in the first place and my thoughts on compiler plugins juliacon2024-44428-compiler-plugins-and-non-native-execution-caching Julia Internals and Tooling Valentin Churavy en Compiler plugins have a rich history in Julia, starting with approaches like Cassette.jl (and it's cousin IRTools.jl) that used generated function and code reflection to implement non-standard semantics. These were followed by a family of tools that extend the compiler interface (`AbstractInterpreter`) and method overlay tables which currently power GPUCompiler.jl and others. While these tools can perform *within* Julia session caching, they currently can not perform *across* session caching leading to large latency spikes. We will walk through Julia's caching infrastructure, explore the challenges involved and discuss a currently proposed solution. A secondary challenge with the use of `AbstractInterpreter` based tools is that there is no robust execution story, there is hope that the solving the non-native caching problem will also enable a solution for the execution of non-native code. false https://pretalx.com/juliacon2024/talk/D88XFU/ https://pretalx.com/juliacon2024/talk/D88XFU/feedback/ REPL (2, main stage) Talk 2024-07-10T12:00:00+02:00 12:00 00:30 Homomorphic encryption allows one to perform computations on encrypted data and obtain the same result as with the original, unencrypted data. This makes it possible to securely process sensitive data in untrusted compute environments. In this talk, we will demonstrate how to easily set up and run homomorphically encrypted computations in Julia and show which kind of operations are possible. We will present examples for secure algorithms and discuss challenges and limitations in practice. juliacon2024-44189-secure-numerical-computations-using-fully-homomorphic-encryption General Michael Schlottke-LakemperArseniy Kholod en Today's widespread availability of commercial cloud providers makes it possible for many researchers and companies to offload compute-intensive tasks to machines in the cloud. However, processing sensitive information such as engineering, financial, or medical data on cloud systems comes with an inherent risk of data exposure or theft in case the systems are compromised. Homomorphic encryption can mitigate this risk by not requiring any trust in the compute environment: Since the data is encrypted before being transferred to the cloud, the underlying raw information cannot be obtained by a malicious party as long as the decryption key is stored securely on premises. There exist several open-source libraries for performing homomorphic encryption, most of which are implemented in compiled languages such as C/C++. They are often nontrivial to use and require a compiler (and frequent recompilation) during development. Our goal is therefore to lower the threshold for using modern, high-performance homomorphic encryption implementations and to facilitate rapid prototyping for experimentation with new applications. For this purpose, we have created two Julia packages, [OpenFHE.jl](https://github.com/sloede/OpenFHE.jl) and [SecureArithmetic.jl](https://github.com/sloede/SecureArithmetic.jl). OpenFHE.jl wraps the state-of-the-art C++ library [OpenFHE](https://github.com/openfheorg/openfhe-development) and provides Julia bindings via [CxxWrap.jl](https://github.com/JuliaInterop/CxxWrap.jl). All required binaries are available as precompiled JLL packages and are downloaded automatically upon installation. SecureArithmetic.jl is a convenience layer on top of OpenFHE.jl, allowing one to express homomorphic encryption algorithms in a more succinct and easier-to-understand manner. The idea is that one can use SecureArithmetic.jl for initial prototyping of new ideas, and to then switch to OpenFHE.jl primitives only where more detailed control is necessary. We will begin this talk with a brief introduction to the fundamental concepts of homomorphic encryption in general and the CKKS scheme for approximate computations with real numbers in particular. This is followed by a demonstration of how to use homomorphic encryption in Julia using OpenFHE.jl and SecureArithmetic.jl. We will present some examples for secure algorithms building upon these packages, such as the numerical simulation of partial differential equations. Finally, we will discuss some of the challenges experienced when working with homomorphic encryption and analyze practical limitations such as performance or algorithmic complexity. The target audience for this talk is computational scientists and research software engineers interested in secure numerical computations with Julia. No prior knowledge of homomorphic encryption is required. Some familiarity with numerical methods for partial differential equations is helpful but not strictly necessary. Repository with presentation slides and reproducibility code: https://github.com/hpsc-lab/talk-2024-juliacon-secure_numerical_computations false https://pretalx.com/juliacon2024/talk/U739BS/ https://pretalx.com/juliacon2024/talk/U739BS/feedback/ REPL (2, main stage) Talk 2024-07-10T14:00:00+02:00 14:00 00:30 Cryptography is a necessity for everyday life as well as for industrial applications. However, Julia packages seem to be lagging behind. What can we do about this? juliacon2024-44163-the-cryptography-packages-in-julia-what-is-missing General Jorge Alberto Vieyra Salas en This is an analysis and comparison of the existing packages in Julia and what is needed to be as complete as other programming languages, e.g. python and rust. Python has a plethora of cryptographic packages that are very easy to use and are widespread. This for sure has helped on python adoption. Sometimes vendors write solutions in their preferred programming language, e.g. Java, C, C#, etc, and also they go out of their way to also have a python version. Other languages like Rust and Go also have a large cryptography ecosystem, sometimes more than one package for the same application. In this talk I will survey the current state of cryptographic packages that are available in Julia and what in my opinion is needed to enable julia wider adoption in other areas besides scientific computing. false https://pretalx.com/juliacon2024/talk/F9JTK3/ https://pretalx.com/juliacon2024/talk/F9JTK3/feedback/ REPL (2, main stage) Talk 2024-07-10T14:30:00+02:00 14:30 00:30 Julia 1.11 rewrites Array from being an opaque type implemented mostly in C to being just another type in Julia. In order to do this, we introduced a new, more primitive type for homogenous data storage, called Memory. Then we could re-use that work to add an AtomicMemory type that allow for better expressing multi-threaded memory operations. And along the way, also added the full set of atomic operators to globals, known as Binding types. In this talk, we we will look at the new Memory type, t juliacon2024-43386-memory-in-julia Julia Internals and Tooling Jameson NashOscar Smith en Prior to Julia 1.11, Array was a special object in Julia. Operations like resizing and creation had to be done completely in C, which created overhead and made some of the code much harder to write and difficult for the compiler to optimize. Array also had some features that were unnecessary for some uses (e.g. resizing and multiple dimensions) which imposed a small cost. To fix this, in https://github.com/JuliaLang/julia/pull/51319, we added a new, lower level Memory type, which allowed re-implementing all of Array in Julia code on top of it. This moved much of the complexity around resizing and copying an array into pure Julia code. And it allowed a few important data types, that don’t need all of Array’s features (such as Dict), to avoid a small amount of overhead. This has led to some great performance improvements. For example, push! on Array is now roughly ~2x faster, and a number of types in Base now use slightly less memory. Along the way, we also added support for doing more with atomic operations (especially https://github.com/JuliaLang/julia/pull/52868). By making a simpler Memory type as the basis for an Array, we could also introduce an AtomicMemory that reused most of the same code (and even shares the GenericMemory base class!). This gives both multi-threaded and single-threaded Julia programs alike new and powerful ways of expressing high performance algorithms. false https://pretalx.com/juliacon2024/talk/CYJ7V7/ https://pretalx.com/juliacon2024/talk/CYJ7V7/feedback/ REPL (2, main stage) Talk 2024-07-10T15:00:00+02:00 15:00 00:30 This presentation explores the design and implementation of a new feature in Pkg, enabling the installation of "apps" - Julia programs launched directly by their name in the terminal. juliacon2024-44366-app-support-in-pkg Julia Internals and Tooling Kristoffer Carlsson en Most Julia packages function as "libraries," loaded by users or other packages, with their functions (API) being subsequently called. However, certain Julia packages are better categorized as "applications" where you don't really call any functions in them but either communicate with them though stdin and stdout or via a GUI. Notable examples include Pluto.jl and IJulia.jl. Currently, to launch these, one must initiate a Julia session, load the package, and execute specific commands like `Pluto.run()` or `IJulia.notebook()`. For such application-oriented packages, initiating them by simply typing their name in the terminal would be more convenient. Additionally, installing applications in a shared environment with other packages can lead to compatibility conflicts due to dependency issues. This presentation introduces a new functionality in Pkg where a Julia package can declare itself to contain applications. Users can then effortlessly install these applications using Pkg, making them readily executable from the terminal. This feature encompasses handling updates, precompilation, and other aspects to ensure a seamless user experience. false https://pretalx.com/juliacon2024/talk/UKX9BF/ https://pretalx.com/juliacon2024/talk/UKX9BF/feedback/ REPL (2, main stage) Lightning talk 2024-07-10T15:40:00+02:00 15:40 00:10 JuliaScript.jl provides `juliascript` runner with which you really just do `juliascript yourscript.jl`. Enjoy speed for julia scripts! juliacon2024-44483-juliascript-jl-simply-run-julia-scripts-at-max-speed Julia Internals and Tooling Stephan Sahm en When building Julia scripts myself, I couldn't find any way to make them simply fast out of the box. This package solves this. The difficulty behind the scene is that Julia's precompilation is build for packages, not for scripts. Hence `juliascript` automatically translates your script into a respective package with optimal precompilation. A single runner, everything automated. Furthermore, `juliascript` is also a tiny wrapper around PackageCompiler.jl, but more on this in the talk. false https://pretalx.com/juliacon2024/talk/GT98W8/ https://pretalx.com/juliacon2024/talk/GT98W8/feedback/ REPL (2, main stage) Lightning talk 2024-07-10T15:50:00+02:00 15:50 00:10 ScopedValues are a new language feature in Julia 1.11, in this talk I will discuss their uses and some implementation details. juliacon2024-44421-scopedvalues-what-are-they-good-for Julia Internals and Tooling Valentin Churavy en ScopedValues allow for the propagation of values using dynamic scope, that means that in contrast to global values different tasks executing at the same time can see different values. This makes ScopedValues a useful tool for propagation of options in a composable manner. false https://pretalx.com/juliacon2024/talk/FR8MVT/ https://pretalx.com/juliacon2024/talk/FR8MVT/feedback/ REPL (2, main stage) Talk 2024-07-10T16:00:00+02:00 16:00 00:30 A deep dive into dependency management processes, associated tooling, and lessons learned integrating with Julia’s package management system from a different technology stack. juliacon2024-44044-renovating-automated-dependency-management-in-julia Julia Internals and Tooling Joris KraakAnant Thazhemadam en For the longest time, dependency management in Julia, for all its pros and cons, has had a single answer - CompatHelper. However, there is a much larger ecosystem built around dependency management tooling in general, which doesn’t support Julia. This talk is primarily about dependency management processes, the current state of dependency management in Julia, and how we added Julia support to Renovate, a very popular dependency management tool. We will be giving an overview of the landscape of dependency management tools, highlighting standardised dependency management processes, while emphasising the need for a standardised and popular system that has a wider scope. We will evaluate the merits (and demerits) of the popular options available, keeping in mind their scope of dependency management. In particular, we will talk about Renovate, and the efforts to add Julia support to it. We will discuss what “adding Julia support to Renovate'' entails. This covers the underlying structure of how Renovate works giving insight into the processes and workflows it would support, and more importantly, how we integrated it to work with Julia (specifically, with Julia's package management system). Of course, any such endeavour to add tooling support is not without challenges, and as such, we will discuss the challenges we’ve faced and what it would take to overcome them. false https://pretalx.com/juliacon2024/talk/RW8RQS/ https://pretalx.com/juliacon2024/talk/RW8RQS/feedback/ REPL (2, main stage) Talk 2024-07-10T16:30:00+02:00 16:30 00:30 Almost every Julia user is well acquainted with the package manager, *Pkg*, and uses it to add, update, and remove packages from their package environments. Behind the scenes Pkg is supported by a global distribution network of Julia-powered *package servers* that host registries, packages, and artifacts. In this talk we will take a look at how this infrastructure is configured and how it is being used to deliver packages from developers to users. juliacon2024-44478-pkg-en-route-the-logistics-behind-the-package-manager Julia Internals and Tooling Fredrik Ekre en When adding or updating a package using Pkg the first step is to *resolve* the package environment. The output of the resolver is the version of the package, and the versions of all dependencies, that should be installed. The next step is to make sure the required packages and artifacts are available on the users machine. Since installation directories of packages (`~/.julia/packages`) and artifacts (`~/.julia/artifacts`) are shared between all package environments it is quite likely that some of the required resources are already available, but the remaining ones must must be downloaded. By default Pkg requests missing resources from package servers hosted by the JuliaLang organization at <https://pkg.julialang.org>: a global distribution network of over 50 servers spanning 10 server regions and 5 continents. Each server runs an instance of [PkgServer.jl](https://github.com/JuliaPackaging/PkgServer.jl) which is an open source reference implementation of a package server written in Julia. In this talk we will take a detailed look at package server infrastructure. We will discuss how Pkg interacts with the servers (the simple *package server protocol*) and the implementation of PkgServer.jl. We will learn how new package releases are routed from developers to users. We will take a look at how <https://pkg.julialang.org> is designed and configured in order to minimize data transmission and latency, and show some interesting data and statistics gathered from the server network. Finally we will discuss how one can setup a custom package server for a company, a compute cluster, or simply for your local machine. Slides: https://docs.google.com/presentation/d/1UgRIHlrc3C2Li3YL0kwnnbXMv31nXXLY1bR-Y2F0_sQ/edit?usp=sharing false https://pretalx.com/juliacon2024/talk/TKLH9U/ https://pretalx.com/juliacon2024/talk/TKLH9U/feedback/ REPL (2, main stage) Talk 2024-07-10T17:00:00+02:00 17:00 00:30 A well defined public API enables users to update a package with confidence that their code will not break and lets IDEs and the REPL help users discover the public functionality of a package. This talk describes currently available mechanisms and community conventions for declaring a public API, highlights the new `public` keyword and its use in tooling, and discusses future work to help declare APIs more clearly and help folks respect APIs more easily. juliacon2024-44398-the-public-keyword-and-how-public-apis-work-in-julia Julia Internals and Tooling Lilith Hafner en ## Motivation for declaring a public API - facilitates upgrading packages in conjunction with symver - documents useful functionality (both to humans and to tooling) - the existence of a well defined public API prevents folks from using an implicit definition like "is it documented" and therefore allows folks to document internals ## The `public` keyword and it's role in existing conventions - "if it's in the manual it's public" and why that is problematic for REPL users - syntax for marking a symbol public - the current "if it's marked public and documented" convention that Julia itself follows - what to do about behavior not tied to a specific symbol - interfaces ## What exactly is marked public - bindings are marked public - publicity is recursive - exports are automatically publicised ## Tooling support - REPL helpmode warns displaying the docstring of a nonpublic binding - REPL autocomplete (#51327) - other tooling that is added or in progress by the time of the talk ## Future work - marking fields of a struct public - disabling internal access by default (#52314) - formally specifying interfaces false GitHub https://pretalx.com/juliacon2024/talk/KGQ8KL/ https://pretalx.com/juliacon2024/talk/KGQ8KL/feedback/ REPL (2, main stage) Keynote 2024-07-10T17:40:00+02:00 17:40 01:00 Current solutions to key 21st-century challenges are fundamentally limited by the functional properties of known materials. Designing new materials increasingly relies on computational modeling leading to research questions across multiple scales and scientific fields. While we believe Julia is well-poised to aid with tackling these challenges, Julia tools cannot simply duplicate the many well-established software solutions. We discuss challenges for Julia and outline opportunities going forward juliacon2024-45602-materials-modeling-bonding-across-atoms-code-and-people Physics & Quantum Chemistry Michael F. HerbstRachel Kurchin en Current solutions to key 21st-century challenges (such as climate change, food insecurity, healthcare, and communications) are fundamentally limited by the functional properties of known materials. Designing new materials increasingly relies on computational modeling with state-of-the-art workflows frequently interweaving first-principles with empirical modeling as well as data-driven approaches. To make advances, we often must establish novel connections across fields such as physics, chemistry, computer science, and applied math. The Julia language and user community are well-poised to address these challenges. However, with many well-established software solutions and their respective user communities already in existence, Julia tools cannot just duplicate existing functionality. Rather, it is crucial to integrate and add value to existing (often monolithic) codebases and software ecosystems. In this talk, we will discuss existing efforts in this area --- both by ourselves as well as the broader JuliaMolSim community --- and outline remaining challenges and opportunities going forward. false Github Slides (updated as we go along) https://pretalx.com/juliacon2024/talk/RDGSFV/ https://pretalx.com/juliacon2024/talk/RDGSFV/feedback/ REPL (2, main stage) Ceremony 2024-07-10T18:40:00+02:00 18:40 00:05 Closing the first day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer. juliacon2024-53123-closing-ceremony Raye Kimmerer en Closing the first day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer. false https://pretalx.com/juliacon2024/talk/NGLEET/ https://pretalx.com/juliacon2024/talk/NGLEET/feedback/ If (1.1) Lightning talk 2024-07-10T10:50:00+02:00 10:50 00:10 I will introduce the latest enhancements in MIToS. MIToS is a Julia package crucial in bioinformatics for analyzing protein sequences and structures. It has undergone several updates, including modernized Pfam, SIFTS, and PDB modules and advanced merging operations in the MSA module. A cookbook has also been introduced, offering practical insights into MIToS' capabilities. Attendees can learn about the current state and exciting future of MIToS. juliacon2024-44356-mitos-evolution-riding-the-bioinformatics-wave Biology & Life Sciences Diego Javier Zea en In this presentation, I will explore the latest updates and future directions of MIToS, an essential Julia package for bioinformatics that focuses on protein sequences and structures. MIToS has undergone several updates to keep up with the rapidly changing landscape of bioinformatics, especially in this era of deep learning and big data. The talk will begin with a brief introduction to the evolution of bioinformatics to understand the importance and impact of the recent MIToS updates. I will then focus on some of the most significant adaptations, highlighting the new concatenation capabilities of the MSA module. Next, I will present the MIToS Cookbook to demonstrate how attendees can effectively utilize MIToS for various bioinformatics tasks. Finally, I will conclude the talk with a future outlook for MIToS, discussing potential upcoming features and modifications. I will also discuss the planned integration with BioJulia, emphasizing the synergy between MIToS and other Julia community packages. false MIToS' GitHub Repo GitHub Talk Slides https://pretalx.com/juliacon2024/talk/RM9TMC/ https://pretalx.com/juliacon2024/talk/RM9TMC/feedback/ If (1.1) Talk 2024-07-10T11:00:00+02:00 11:00 00:30 This project addresses a critical challenge in clinical data analysis, particularly in oncology. We propose a mathematical model for cancer patients' disease progression, merging stochastic dynamics from various data modalities. Utilizing Bayesian inference, we illustrate this with a simulated study on tumor growth, metastases, and patient survival. Leveraging Julia, our approach provides estimation of combined stochastic models, paving the way for comprehensive clinical trajectory analysis. juliacon2024-43590-combined-stochastic-models-for-cancer-patient-trajectories Biology & Life Sciences Vincent Wieland en One of today's foremost challenges in analyzing clinical data is the integration of different data modalities. Patients -- especially in oncology -- undergo a wide range of diagnostics which yield diverse measurement types including both discrete and continuous quantities, often in a longitudinal setting, as well as time-to-event data. In this project, we develop a computational approach for combining the different stochastic dynamics underlying such measurements into one mathematical model describing cancer patients' disease progression, and demonstrate the use of Bayesian inference for the resulting set of model parameters. To illustrate this, we consider a simple example where one observes the size of a primary tumor, the number of different tissues affected by metastases, and the survival status of a patient. The first is growing continuously and modeled as an ordinary or stochastic differential equation, whereas the second and third are discrete events that are described as Poisson jump processes with intensities dependent on the other components. Additionally, we introduce measurement noise on the tumor growth observations. The resulting multidimensional process together with its discrete observations can be seen as a Hidden Markov Model whose parameters are to be estimated. We examine various different models from this class, which mainly differ in the description of the continuous primary tumor growth, using simulated datasets. The first use deterministic growth laws through an ODE, the last uses a version of a geometric Brownian Motion to represent the tumor size. All models are further extendable via the parametrization of the transition rate parameters through different covariates. For the simulation of the continuous processes modelling the tumor growth we use the functionalities of the SciML ecosystem in Julia. However, for the simulation of the two combined jump processes a self-implemented modified next reaction method algorithm showed the most accurate and reliable performance. Therefore, we couple the different simulation algorithms for robust creation of artificial data. Model parameters are then learned using a likelihood-based Bayesian inference framework. In the simplest ODE case, it is possible to retrieve a closed form of the corresponding likelihood function, which can then be maximized. The posterior distribution of the parameters is then be obtained by the use of MCMC sampling methods. For the SDE case, we aim for the computation of a partly analytical and partly approximated likelihood function for the maximum-likelihood estimation and sampling. Furthermore, we will leverage advanced Particle filter algorithms, a class of Markov chain Monte Carlo methods targeting the posterior distribution by approximating the likelihood trough repeated sampling of a population of particles. The performance of the model, including uncertainty quantification and robustness, is evaluated through an extensive simulation study. We showcase results obtained using an implementation solely in the Julia programming language. The SciML ecosystem provides us with a framework for expressing and solving continuous stochastic processes, whereas Julia's modularity makes it easy to combine these with our own simulation routines for jump processes. Additionally, it also allows a tidy integration of analytical and numerically approximated functions in the simulation-based inference scheme of particle filters. The latter benefits crucially from Julia' speed and parallelization. In summary, this newly proposed approach of combining different dynamics into one stochastic model creates valuable groundwork for clinical trajectory analysis, as it allows for a more holistic description of patient outcomes. Furthermore, it sheds light on the interplay of different stochastic processes joined into one single process and starts the development of efficient simulation and estimation methods for such classes of combined stochastic models using the Julia programming language. In future work, this can be further extended to study the effect of different therapy choices on patients' survival. Additionally, mixed effects can be included to better incorporate inter-individual variability. false Talk Slides https://pretalx.com/juliacon2024/talk/K7VK3D/ https://pretalx.com/juliacon2024/talk/K7VK3D/feedback/ If (1.1) Talk 2024-07-10T11:30:00+02:00 11:30 00:30 BiochemicalAlgorithms.jl is a redesign of the popular **B**iochemical **Al**gorithms **L**ibrary (BALL), the largest open source C++-framework of its kind. We focused on three main design goals: efficiency, ease of use and **r**apid **a**pplication **d**evelopment (RAD). Our library provides functionality for file I/O, molecular modelling, molecular mechanics methods, and molecular visualization, and hence can serve as a foundation for developing applications within the Julia ecosystem. juliacon2024-44342-structural-bioinformatics-with-biochemicalalgorithms-jl Biology & Life Sciences Jennifer Leclaire en Development times play a crucial role in the process of implementing structural bioinformatics applications. Ideally, frameworks for molecular modelling and simulation are easy and intuitive to use without sacrificing too much computational efficiency or numerical stability. BiochemicalAlgorithms.jl is our attempt of providing such a framework. BiochemicalAlgorithms.jl is a complete Julia-centric redesign of the popular **B**iochemical **Al**gorithms **L**ibrary (BALL), the largest open source C++-framework for structural bioinformatics, created in 1996 [1,2]. Switching our development from C++ to Julia has greatly simplified conforming to our design goals in many ways. While setting up a development environment for BALL is a highly nontrivial task these days, installing BiochemicalAlgorithms.jl is trivial. The code in BiochemicalAlgorithms.jl is -- in our opinion -- often much more readable, with greatly reduced boilerplate, and much closer to the abstract algorithmic formulations. The availability of high-quality numerical code for many problems we face in structural bioinformatics also helps to greatly improve code quality and accelerates development. While the port to Julia is not yet feature-complete, BiochemicalAlgorithms.jl already provides well documented core data structures for typical molecular entities such as atoms, bonds, molecules, etc. These core data structures are accompanied by a selection of molecular modelling and mechanics techniques. Software packages in structural bioinformatics often focus on one or two specific tasks such as the implementation of a force field. In contrast, BiochemialAlgorithms.jl, accompanied by the visualization counterpart BiochemicalVisualization.jl, attempts to cover the full molecular modelling pipeline, containing building blocks such as file import and export of several molecular file formats, methods for inferring missing atoms, bond building algorithms, molecular force fields, structural optimization, and docking algorithms. BiochemicalAlgorithms.jl's structured interface enables the rapid prototyping of ideas, such as the implementation of new energy functions or docking algorithms, as well as fully featured applications, and is suited for the interoperability with other Julia packages for molecular modelling like Molly.jl [3]. Together with Julia's excellent ecosystem for scientific machine learning, it can form the basis for novel applications of deep learning techniques (using, e.g., Flux.jl[5]) in the context of molecular modelling and simulations, or of Bayesian optimization techniques (using Turing.jl[4]) for molecular docking. In our talk, we will show how to perform common tasks in structural bioinformatics, such as reading molecular structures from files, preprocessing them to add missing atoms and bonds, inferring atom types, performing structural optimization, and run a docking algorithm. Further, we will demonstrate how our framework can be used to easily implement new methods and algorithms. ### References [1] Hildebrandt, A. et al. BALL - biochemical algorithms library 1.3. BMC Bioinformatics 11, 531 (2010). [2] Kohlbacher, O. & Lenhof, H.-P. BALL—rapid software prototyping in computational molecular biology. Bioinformatics 16, 815–824 (2000). [3] Greener, J. G. Differentiable simulation to develop molecular dynamics force fields for disordered proteins. 2023.08.29.555352 Preprint at https://doi.org/10.1101/2023.08.29.555352 (2023). [4] Innes, M. et al. Fashionable Modelling with Flux. Preprint at https://doi.org/10.48550/arXiv.1811.01457 (2018). [5] Ge, H., Xu, K. & Ghahramani, Z. Turing: A Language for Flexible Probabilistic Inference. in Proceedings of the Twenty-First International Conference on Artificial Intelligence and Statistics 1682–1690 (PMLR, 2018). false GitHub https://pretalx.com/juliacon2024/talk/DFNXCK/ https://pretalx.com/juliacon2024/talk/DFNXCK/feedback/ If (1.1) Talk 2024-07-10T12:00:00+02:00 12:00 00:30 Personalised computational models of cardiovascular physiology have the potential to revolutionise patient-specific diagnosis and prediction. This study introduces a novel workflow that efficiently identifies the optimal bio-markers for cardiovascular personalisation, leveraging ModellingToolKit.jl, GlobalSensitivity.jl and QuasiMonteCarlo.jl. The outcome of our research is a more reliable and more practically focused personalisation of complex cardiovascular models. juliacon2024-44353-the-personalisation-of-cardiovascuar-models-using-julia Biology & Life Sciences /media/juliacon2024/submissions/RGCLVE/Workflow_Harry_fLOs0DQ.png Harry Saxton en 1 - Background and the Problem Cardiovascular diseases stand as the foremost cause of death globally. Surgeries and treatments aimed at cardiovascular issues carry inherent risks and may not achieve desired clinical outcomes, influenced by patients' specific physical conditions. In the operating theatre, interventional cardiologists have access to increasingly sophisticated measurements for assessing patient vasculature. However, certain physiological quantities remain either indirectly measurable or are prone to measurement noises. Mathematical and computational models play a crucial role in supporting clinical diagnosis and decision-making through in silico Decision Support Systems. Yet, the integration of these in silico models into clinical practice is hindered by the challenge of personalisation - determining the required values for individual patients' model input parameters, some of which are bio-markers, based on measured clinical data. This process involves solving an inverse problem, marked by its complexity, uncertainty, and computational intensity. 2 - Methods Recent advancements in computational data assimilation have led to the development of various cardiovascular models, utilising hemodynamics and other low-order models to quantitatively establish the interdependence of a patient’s systemic and pulmonary vasculature properties. We employ Zero-dimensional (0D) models, mapping physiological variables, such as pressure, volume, and flow, to electrical counterparts like voltage, charge, and current. Each physiological compartment has a distinct representation with mechanical parameters portraying the "true" physiology of a patient. Structural identifiability analysis is employed to ascertain the estimability of parameters and necessary measurements for personalisation. Sensitivity analysis uncovers the most influential parameters affecting model outputs, while parameter orthogonality analysis examines the independent effects of individual parameters. Through a combination of sensitivity and orthogonality investigations, we identify a set of unique input parameters optimisable to a patient’s data using powerful techniques like the Unscented Kalman Filter (UKF). This comprehensive approach, as illustrated in the attached figure, enhances the precision of personalising complex cardiovascular models, advancing their clinical utility and effectiveness. 3 - The Julia Aspect While the research conducted is incredibly applied, there is a computational workflow enabling the intersection between clinical practices and in-silico investigations. In the talk, we examine the different stages of the proposed personalisation workflow and highlight how Julia aids us at each stage. From utilising ModellingToolKit.jl to create cardiovascular models to using GlobalSensitivityAnalysis.jl for studying model uncertainty, along with other packages enabling the generation of personalised cardiovascular models. We will spotlight some of the main challenges encountered in this process and how we've overcome them, such as performing parallel simulations on varying data types and accessing observed variables from MTK. This talk outlines a workflow for those interested in model analysis and emphasises how Julia can be utilised to produce clinically impactful work. 4 - Achievements and Impact This study introduces a novel workflow efficiently identifying optimal bio-markers for cardiovascular personalisation, incorporating practical and structural identifiability, sensitivity analysis, orthogonality, and Kalman-based optimisation methods to determine the most informative and clinically usable model inputs. The outcome of our research is a more reliable and practically focused personalisation of complex cardiovascular models, empowering clinicians to provide tailored patient-specific treatments. This advancement has significant potential in enhancing cardiovascular diagnosis and ultimately improving patient outcomes. This talk aims to provide others with a workflow on utilising extensive model analysis packages to create a reliable interpretation of any model. false https://pretalx.com/juliacon2024/talk/RGCLVE/ https://pretalx.com/juliacon2024/talk/RGCLVE/feedback/ If (1.1) Talk 2024-07-10T14:00:00+02:00 14:00 00:30 Agent-based modeling is a common tool to explore cell migration and morphogenesis. Faced with biology's complexity, such models bring several implementation challenges that require many different tools. In this talk, I want to present several packages that support agent-based modeling, such as **SpatialHashTables.jl**, **BoundedDegreeGraphs.jl**, and **AgentTools.jl**. I will also briefly discuss a numerical method (PBD) suitable for non-overlap conditions. juliacon2024-44147-tools-for-agent-based-modelling-in-developmental-biology Biology & Life Sciences /media/juliacon2024/submissions/ZR9VRZ/bitmap_QLJOvlW.png Steffen Plunder en Agent-based models (ABM) come in a large variety of different forms and structures, which makes their unified handling challenging and requires a language like Julia, where developers of new models can implement high-performance functions. With [Agents.jl](https://github.com/JuliaDynamics/Agents.jl), Julia already has a great platform for agent-based modeling, which integrates well with the ecosystem. Due to the vast scope of agent-based modeling, it is clear that the fundamental logic of some models requires further tools for their efficient implementation. In my talk, I will present a couple of complementary tools that attempt to solve particular challenges that are present, for example, in applications in biology. The packages are: - [SpatialHashTables.jl](https://github.com/SteffenPL/SpatialHashTables.jl), for neighbor detection in unbounded domains with an ABM-friendly interface. A future aim of this package is, in particular, to allow execution on GPUs or even webassembly. - [BoundedDegreeGraphs.jl](https://github.com/SteffenPL/BoundedDegreeGraphs.jl), for allocation-free graphs which allow efficient interaction networks among agents. - [AgentTools.jl](https://github.com/SteffenPL/AgentTools.jl), a small assortment of functions for dealing with JSON or XLSX files to define heterogeneous and dynamic parameters. I will also briefly show the numerical method called Position-Based Dynamics (PBD) in Julia, which is one of NVIDIA's primary methods for particle simulations in computer graphics applications. As it has not gained much attention in the mathematical modeling community yet, I want to demonstrate how to use PBD in the context of agent-based modeling to avoid overlap and contact between agents in a simple but effective manner. Finally, the talk will show example applications for cell migration, limb bud formation, and epithelial tissue growth to highlight particular challenges for modeling in developmental biology. false GitHub https://pretalx.com/juliacon2024/talk/ZR9VRZ/ https://pretalx.com/juliacon2024/talk/ZR9VRZ/feedback/ If (1.1) Talk 2024-07-10T14:30:00+02:00 14:30 00:30 The NetSurvival.jl package brings standard relative survival analysis modeling routines in Julia. Relative survival analysis is a branch of survival analysis where individuals are subject to two competing risks, but the cause of death is unknown, often for data quality reasons. In these circumstances, standard competing risks approaches are unusable and specific estimators and methods are used (e.g. Pohar-Perme net survival estimator, Graffeo's log-rank-type test among others). juliacon2024-43080-netsurvival-jl-a-glimpse-into-relative-survival-analysis Biology & Life Sciences Oskar LavernyRim Alhajal en Data arising from large cancer studies often lack reliable information about the cause of death (supposed binary: death from the studied cancer or from other causes) for each individual. Relative survival analysis is a subfield of survival analysis specifically targeted at this particular type of datasets. The field's goal is to extract survival curves that only takes into account the deaths from cancer, the so-called net survival curves, for comparison purposes between different groups or directly for diagnostic purposes. For that, a few standard estimators were established in the last 50 years, backed by a wide literature. Standard tools nowadays are composed of R packages, with underlying C and C++ routines, that are hard to read, maintain, and globally use. This package is an attempt to provide a fast, reliable, but most importantly easily maintainable package to implement standard estimators and routines from the field onto the `StatsModels.jl` API. Our hope is that the junction with classical modeling API in Julia will allow later extensions of the existing modeling methods, with a simple interface for the practitioners. In this talk, we present the current state of the implementation: the few tools and methods that were implemented, their integration into the Julian ecosystem, and we showcase the functionalities and performance of the implemented methods. We particularly note that the use of native Julia allows for concision and readability of the code. false https://pretalx.com/juliacon2024/talk/LBU8QU/ https://pretalx.com/juliacon2024/talk/LBU8QU/feedback/ If (1.1) Talk 2024-07-10T15:00:00+02:00 15:00 00:30 Two packages are presented here for cognitive computational modeling. ActionModels.jl builds on Turing, and provides an easy interface for agent-based modeling and hierarchical Bayesian parameter estimation - including regressions, using TuringGLM - of action models of the kind used in computational psychiatry, cognitive modeling, and game theory. As an example, HierarchicalGaussianFiltering.jl then provides easy access to the HGF, a complex and generally applicable predictive processing model. juliacon2024-44505-cognitive-computational-modeling-made-easy-with-julia Biology & Life Sciences Peter Thestrup Waade en With the computational turn psychiatry, cognitive science and neuroscience, there has been an increase in demand for computational cognitive modeling; that is, building computational models of cognitive processes such as learning, perception, memory and decision making. These models can be used for simulation, providing theoretically founded empirical predictions. Often, they are also fitted to participant behaviour in order to estimate per-participant model parameters - used for assessing and building theories based on empirical data, and for finding differences between for example clinical populations, which may in turn be used for diagnostic purposes. The current gold-standard in the field is to use probabilistic languages for Markov Chain Monte Carlo sampling for Bayesian parameter estimation. Due to sparsity of data, and inherent hierarchical structures of many experimental designs, models benefit from hierarchical parameter estimation. The estimated parameters are then often used in regression analyses to test for correlations with experimental implementations and other predictors, but since this is done in a separate step, information is lost. The optimal strategy is therefore to have hierarchical regression and cognitive model in the same model. This is for many researchers, however, often not technically feasible, for it requires knowledge of specialized modeling languages like STAN, and to be able to specify custom regressions and hierarchical parameter structures by hand. Simultaneously, programming custom models can be complicated in itself, providing a technical barrier that is arguably among the greatest limitations for cognitive computational modeling. Leveraging Julia's powerful modeling library Turing, and exploiting the solution to the two-language problem present in other available software solutions, ActionsModels.jl provides a generally applicable and easy-to-use framework for cognitive and behavioural modeling. Needing only a simple input-output structure specified by the user - and containing an array of the most used cognitive models from the field - this package lets the user flexibly simulate from one or multiple models, and provides an easy, TuringGLM-based framework for including multilevel regressions (i.e., statistical models) and cognitive models (or, more generally, action models) in one framework. This should make cognitive computaitonal modeling available to the broader scientific community without sacrificing the customisability that high-end users will rely on. As an example of using the package for complex models, I also present HierarchicalGaussianFiltering.jl, which implements the generalized Hierarchical Gaussian Filter (HGF), a generally applicable variational Bayesian predictive processing based computational model of learning and perception. In its new, generalized form, the HGF can be used to create cognitive models for a variety of tasks and contexts - and can, due to its close relation to the Kalman Filter, also be used for signal processing in volatile and noisy environments. false Github page for ActionModels.jl Github page for HierarchicalGaussianFiltering.jl Slides https://pretalx.com/juliacon2024/talk/Z8MJK8/ https://pretalx.com/juliacon2024/talk/Z8MJK8/feedback/ If (1.1) Lightning talk 2024-07-10T15:40:00+02:00 15:40 00:10 Today, neuroscience is generating data more than ever before. A central challenge is how to effectively leverage this unprecented data deluge while embracing existing and emerging domain knowedge. We discuss how emerging developments happening in scientific machine learning present untapped opportunities to advance the field. To harness this potential, we present the first version of NeuroDynamics.jl which aims to provide the building blocks towards next generation modelling in neuroscience. juliacon2024-44486-neurodynamics-jl-next-generation-models-in-neuroscience Biology & Life Sciences Ahmed ElGazzar en While the causes of single neuron spikes have been understood for decades, the processes that support collective neural behavior in large-scale cortical systems are less clear. Understanding such large-scale processes is essential to uncover the neural basis underlying cognitive and behavioral functions and dysfunction. Thus, modeling neural dynamics across different scales of organization and levels of abstraction has been an area of great interest in neuroscience. In our work, we aim to develop a framework to enable the integration of different modeling techniques under a common language. NeuroDynamics.jl provides a suite of well-established and emerging models used in neuroscience. These range from biophysical, phenomenological, data-driven, and, most importantly, hybrid models. These hybrid models capitalize on recent developments in the scientific machine learning community to tackle long-standing challenges that exist with current models. We provide tutorials to show how these hybrid models can be used to understand the neural computation underlying cognitive and behavioral tasks, system identification for neural control, neural decoding, as well as normative modeling of neural function. The long-term vision of NeuroDynamics.jl is to be a one-stop shop for modeling, simulation, analysis, and control of any neural system. false https://pretalx.com/juliacon2024/talk/E77Z9D/ https://pretalx.com/juliacon2024/talk/E77Z9D/feedback/ If (1.1) Lightning talk 2024-07-10T15:50:00+02:00 15:50 00:10 This project leverages the Julia programming language to construct a robust mechanistic model for understanding infectious disease transmission and reporting. Integrating diverse data sources, i.e. officially reported case counts and wastewater measurements, we address the inherent limitations of delayed reports, underascertainment and high stochasticity of observations. The efficiency and modularity of Julia empower us to tackle this complex modeling and estimation task effectively. juliacon2024-43439-integrative-stochastic-modeling-of-infectious-disease-with-julia Biology & Life Sciences /media/juliacon2024/submissions/PER87K/image_mR5QhaJ.png Vincent Wieland en The global spread of the COVID-19 pandemic has highlighted the importance of monitoring the real-time spread and predicting future disease dynamics to inform intervention policies. Mathematical modeling of infectious disease dynamics - including the estimation of relevant parameters - have become a key objective of this effort. However, basing the inference approach solely on confirmed infections yields several challenges. The foremost is the problem of underascertainment of infections. Individuals who do not experience symptoms after being infected are not likely to seek testing. Additionally, insufficient testing capacities and a lack of public awareness may cause underascertainment. Therefore, our approach proposes a mathematical model combining case count data with wastewater-based surveillance data, which reports the viral concentration in the wastewater from fecal shedding of the infected individuals. Wastewater-based surveillance is a promising tool for monitoring public health, but still in its infancy. One of its major challenges is the inherently high stochasticity of the observations in the low-cases regime. Furthermore, quantitative links to disease dynamics and reliable predictions are still under development. The combination of these two data sources may help to overcome the numerous challenges inherent to each of them. The proposed mathematical model consists of a multi-level epidemic model for the dynamics on the population level that jointly models the number of new infections, infection-confirmation lag times and ascertainment probabilities utilizing case count data. This is expanded by an simple advection-dispersion-decay model for the RNA transport in the wastewater. With this, the transmission model can be informed by viral concentration measurements. The resulting multi-hierarchical model is well interpretable due to its mechanistic nature, while taking care of measurement errors and uncertainty in the data using a probabilistic description of the modeled quantities. Parameters shall then be learned using a Bayesian inference framework based on the likelihood function, which is partly analytically available and partly approximated by sampling schemes. After parameter estimation, we want to conduct simulation studies to evaluate the performance of the model, including uncertainty quantification and robustness. Furthermore, we then aim to apply the model to publicly available data from Canadian cities. In summary, we employ the Julia programming language to simulate the dynamics of an infectious disease by incorporating diverse real-world data sources. Julia's modularity allows a neat integration of the different processes included in the model, while its clear syntax makes it easy to resemble the mathematical formulas needed and reduce code complexity. Especially, the simulation intensive inference framework benefits from Julia's speed and possibility for parallelized computation. With our talk we aim to contribute not only insights into integrative modeling of serious infectious disease, but also provide an overview of our considerations and experiences when solving models with hierarchical random variables using the Julia programming language. false Talk Slides https://pretalx.com/juliacon2024/talk/PER87K/ https://pretalx.com/juliacon2024/talk/PER87K/feedback/ If (1.1) Talk 2024-07-10T16:00:00+02:00 16:00 00:30 GAIO (Global Analysis of Invariant Objects) is a package for set oriented numerics in dynamical systems. It provides algorithms for discretisation of the Koopman operator among other uses. The Koopman operator has been of much interest in the last decade, since it can be used in order to compute, e.g., almost invariant, cyclic and coherent sets (to name just some uses). Originally written in the 90s in C, GAIO has been redesigned in Julia and is concise, while outperforming the original. juliacon2024-43293-fast-elegant-set-oriented-numerical-analysis-using-gaio-jl Math(s) /media/juliacon2024/submissions/AYASGT/logo_s3ures1.png April Herwig en In this talk, we present a Julia version of GAIO. The data structures and the algorithmic interface have been completely redesigned such that the code of the algorithms is very concise and close to their mathematical pseudocode. At the same time, the performance is equal or better than the one of the C version. This is illustrated through an example: an algorithm for computing attractors is devised and implemented. It is tested on a classical example of a strange attractor from dynamical systems literature. GAIO makes extensive use of multiple dispatch to construct various discretisation techniques for cell mapping, as well as to interact with the established scientific computing ecosystem (DynamicalSystems, DifferentialEquations, Makie, etc.). Thanks to Julia's CUDA package, GPU acceleration is as easy as setting a keyword argument during initialisation. This is shown at the end of the talk. Code: https://github.com/gaioguys/GAIO.jl Documentation: https://gaioguys.github.io/GAIO.jl/ false Slides https://pretalx.com/juliacon2024/talk/AYASGT/ https://pretalx.com/juliacon2024/talk/AYASGT/feedback/ If (1.1) Talk 2024-07-10T16:30:00+02:00 16:30 00:30 In this talk we will present a simple library for rendering audible in real time (audification) the numerical solutions of systems of ordinary equations (continuous dynamical systems). This library can be used as a pedagogical tool for gaining insight on the different kinds of bifurcations in dynamical systems and also as a resource for creating new sound synthesizers or the simulation of musical instruments. juliacon2024-44312-real-time-odes-for-sound-synthesis-and-parameter-exploration Math(s) /media/juliacon2024/submissions/DVHRYL/Screenshot_2024-07-09_115715_qJs20Sp.png Manuel Camilo Eguia en The qualitative description of continuous dynamical systems relies mainly on the study of the topological changes in the organization of the flux in the phase space formed by the variables of the system. Here we present a tool that complements the more common visual representation taking the variables as a multichannel audio output, after proper time scaling, rendering audible the behavior of the system. This is done by streaming the solutions obtained by the DifferentialEquations.jl package through a wrapper of the PortAudio library. We will present some prototypical examples of dynamical systems and show how their audification can be used to unveil in a fast way the role played by their control parameters. We will end showing an example of a saxophone model that can be played in real time through a Pluto interface. false Real Time Audio Differential Equation Package Pluto Presentation of the Talk Examples of Interactive Pluto Notebooks using RealTimeAudioDiffEq.jl https://pretalx.com/juliacon2024/talk/DVHRYL/ https://pretalx.com/juliacon2024/talk/DVHRYL/feedback/ If (1.1) Talk 2024-07-10T17:00:00+02:00 17:00 00:30 Julia's ecosystem excels in Differential equation solving but lacks tools for fractional differential equations where FractionalDiffEq.jl, a package for solving these equations, can bridge this gap. At JuliaCon 2024, we'll discuss its architecture and use in solving complex fractional differential equations, and outline its future development within the SciML ecosystem. **Recent advances in BVP solving will also be presented, mainly focusing on new solvers and future plans.** juliacon2024-43342-solve-fractional-differential-equation-with-fractionaldiffeq-jl Math(s) Qingyu Qu en Fractional-order differential equations have increasingly gained attention as a compelling subject, particularly in recent decades, offering more nuanced representations in natural models from a fractional-order perspective. Tracing back to the origins of 'non-integer' calculus, a concept first contemplated by Leibniz and L'Hôpital, numerous scientific luminaries have contributed tirelessly to the advancement of fractional calculus. This field has proven particularly instrumental in accurately describing phenomena in diverse areas such as viscoelasticity, acoustics, rheology, and polymeric chemistry. Additionally, the application of fractional derivatives has emerged as an exceptionally fitting approach for characterizing the memory and hereditary properties inherent in a variety of materials and processes. The SciML organization has achieved remarkable success in developing numerical solvers for differential equations. However, there are certain types of differential equations that [SciML has not yet supported](https://github.com/SciML/DifferentialEquations.jl/issues/461). Since the 20th century, fractional calculus and fractional differential equations have emerged as significant areas of interest in science and engineering, extending the principles of integer-order differential equations. Historically, most numerical software for these equations has been developed in MATLAB and suffered from a lack of consistent maintenance, leaving a gap for unified, user-friendly tools. Addressing this need, FractionalDiffEq.jl is an innovative package within the SciML ecosystem, integrating efficient algorithms specifically designed for fractional differential equations (FDEs). Leveraging the common interface of SciML, FractionalDiffEq.jl not only simplifies user interaction but also ensures seamless integration with other SciML packages. Currently, FractionalDiffEq.jl adeptly handles fractional order ordinary differential equations and delayed differential equations, representing a significant stride forward in computational science and engineering tools. The [FractionalDiffEq.jl](https://github.com/SciFracX/FractionalDiffEq.jl) package follows the design pattern of DifferentialEquations.jl. To solve a fractional differential equation problem, we first define a ```FDEProblem``` according to our model, use ```FODEProblem``` for common fractional ordinary differential equations, use ```FDDEProblem``` for delay fractional differential equations etc. Then pass the defined problem to ```solve``` function and choose an algorithm to solve our problem. ```julia prob = FDEProblem(fun, order, u0, tspan) sol = solve(prob, alg(), dt) ``` ```julia prob = FDDEProblem(fun, phi, order, u0, constant_lags=[tau], tspan) sol = solve(prob, alg(), dt) ``` There is still a long way to go for FractionalDiffEq.jl to become a mature package. We are working hard to improve the performance of the package and add more algorithms. The future plans included but not limited to: * Keep adding more high performance algorithms. * Make the usage of API more simple and elegant. * Write more illustrative documents for usability. * Integrate with the SciML ecosystem to provide users more useful features. false https://pretalx.com/juliacon2024/talk/ZLG9BB/ https://pretalx.com/juliacon2024/talk/ZLG9BB/feedback/ If (1.1) Poster 2024-07-10T18:30:00+02:00 18:30 00:30 Time-reversible or symplectic methods are very useful for long-term integration of planetary systems with a constant step size. However, in the case of n-body problems involving close encounters, adaptive time-stepping is required. We present a SIMD-vectorized integrator for few-body problems which incorporates a robust time-reversible adaptivity mechanism that makes it highly performant for the long-term numerical integration of problems with close-encounters. juliacon2024-44141-few-body-integrator-with-time-reversible-adaptivity-in-julia Posters MikelAnder Murua en Time-reversible or symplectic methods are very useful for long-term integration of planetary systems with a constant step size. The 16th order method implemented in our package SciML/IRKGaussLegendre.jl is both time-reversible and symplectic, and includes a SIMD-vectorized version IRKGL16-SIMD (presented in Juliacon2020) that is particularly efficient for problems without close encounters. However, numerical precision degrades greatly during close encounters if constant step size is employed. Close encounters are common, for instance, in simulations of the orbital evolution of the Solar System when some asteroids or comets are included in the model. Hence, a robust numerical integrator of few-body problems must include some adaptive mechanism to deal with close encounters. Unfortunately, with conventional time-step adaptivity strategies the advantages of symplectic methods is lost. We present an integrator for few-body problems, which based on IRKGL16-SIMD, that incorporates a robust time-reversible adaptivity mechanism that makes it highly performant for the long-term numerical integration of problems with close-encounters. Fortunately, time-stepping strategies that preserve the reversible structure of the n-body problem are possible, for instance, by applying reversible stepsize strategies introduced in [1], which require an explicitly given expression of the stepsize as a function of the positions and velocities. In our code, we make use of an appropriate step-size function for the n-problem proposed in our previous work [2,3]. We show some numerical experiments with few-body problems that demonstrates the efficiency and robustness of our code. Repository: https://github.com/mikelehu/NbodyIRKGL16.jl References - [1] Reversible Long-Term Integration with Variable Stepsizes, E.Hairer and D. Stoffer. SIAM Journal on Scientific Computing (1997). https://doi.org/10.1137/S1064827595285494 - [2] Global Time-Renormalization of the Gravitational N-body Problem, M. Antoñana, P. Chartier, J. Makazaga and A. Murua. SIAM Journal on Applied Dynamical System (2020). https://doi.org/10.1137/20M1314719. - [3] Majorant series for the N-body problem, M. Antoñana, P. Chartier and A. Murua. Iternational Journal of Computer Mathematics (2021). https://doi.org/10.1080/00207160.2021.1962848 false https://pretalx.com/juliacon2024/talk/HGML7Z/ https://pretalx.com/juliacon2024/talk/HGML7Z/feedback/ If (1.1) Poster 2024-07-10T19:00:00+02:00 19:00 00:30 As many of you may know, I am the creator of cloud.jolin.io, a hosted notebook service for Pluto notebooks. I am going to give you background insights about how it works and where it should go. juliacon2024-44475-how-i-created-a-hosted-notebook-service-for-pluto Posters Stephan Sahm en The hosted Pluto service is really Pluto-first at its core. I want to show you, that this brings crucial advantages which are yet unseen in other ecosystems. The biggest one: It enables simplicity for DevOps. Further, you will hear details about Pluto, Kubernetes, Distributed, HTTP, React, etc. false https://pretalx.com/juliacon2024/talk/YB8CJQ/ https://pretalx.com/juliacon2024/talk/YB8CJQ/feedback/ If (1.1) Poster 2024-07-10T19:30:00+02:00 19:30 00:30 This package wraps (measured) data into a function which supports coordinate transformation parameters. Upon calling this returned function, the data is interpolated according to the transformation into an array. Currently supported N-dimensional transformations are shift and zoom, or an affine transformation. It also supports automatic differentiation over its transform parameters, enabling its use in fitting and inverse modeling problems. juliacon2024-44408-datatofunctions-jl-representing-transformed-data-as-a-function Posters Hossein Zarei Oshtolagh en It is sometimes useful to fit measured data (e.g. an image of a star) with a functional representation of the image of a star (the point spread function) parameterized by position, zoom and rotation. However, sometimes such functional model representations are hard to come by. Therefore, high-quality measurements of a star can serve as an example of such a point spread function. Rather than first fitting this example data with another parameterized function (e.g. a polynomial representation) and implementing the required transformation parameters, we simply wrapped the data into a functional representation using `Interpolations.jl`. For a fast application of this scheme, it is essential that no memory is allocated for each individual interpolation event. In the current version of `DataToFunctions.jl` we support different coordinate transformations, which are all free of memory allocations during coordinate calculations (using the `StaticArrays.jl` toolbox). One coordinate transformation supports shifting and scaling. Another more general one supports an N-dimensional affine transformation based on homogeneous coordinates (i.e. adding one extra dimension of value 1 to each coordinate vector and using an (N+1)x(N+1) matrix for the transformation). For two-dimensions (N=2), there is also an easy-to-use form of the affine transformation, spelling out shift, shear, rotation and scaling as individual parameters. Returned is a function encapsulating the underlying data to be used for further work, like fitting the new data. The advantage of this method is that we do not fit any function to the measured data. So, we do not approximate the data used for fitting, but use it directly for fitting via interpolation. We provide a few examples to showcase possible use-cases of our toolbox. false https://pretalx.com/juliacon2024/talk/X8EKWF/ https://pretalx.com/juliacon2024/talk/X8EKWF/feedback/ Else (1.3) Lightning talk 2024-07-10T10:50:00+02:00 10:50 00:10 In this talk we will show you how to boost your latent SciML model, significantly increasing its performance and data efficiency. In particular, we will present GOKU-UI, an evolution of the continuous-time generative model GOKU-net, which incorporates attention mechanisms and a novel multiple shooting training strategy in the latent space. On both simulated and empirical brain data, it achieves enhanced performance in reconstruction and forecast tasks while effectively capturing brain dynamics. juliacon2024-44490-raising-the-ki-of-a-sciml-model SciML Germán Abrevaya en Scientific Machine Learning (SciML) is a burgeoning field that synergistically combines domain-aware and interpretable models with agnostic machine learning techniques, often yielding increased interpretability, generalizability, and data efficiency [1, 2, 3]. Latent Ordinary Differential Equations (Latent ODEs)[4, 5] are VAE-like generative models that encode time series data into a latent space ruled by a differential equation which is parametrized by a neural network. Building on Latent ODEs, Linial et al. [6] introduced GOKU-nets (Generative ODE Modeling with Known Unknowns), which fundamental difference with the former is the inclusion of a predefined differential equation structure as a prior for the latent dynamics. Compared to LSTM and Latent-ODE on pendulum videos and cardiovascular system modeling, GOKU-net excelled in reconstruction, forecasting, reduced training data needs, and offered better interpretability. While leveraging the power of the Julia SciML Ecosystem and Flux, we not only implemented the GOKU-nets in Julia, broadening the original model's spectrum to incorporate other classes of differential equations, but also introduced two key enhancements: (1) the addition of attention mechanisms to the main part of the model that infers the parameters of the differential equations and (2) a novel training strategy based on the multiple shooting technique [7, 8] in the latent space. These modifications have led to a significant increase in its performance in both reconstruction and forecast tasks, as demonstrated by our evaluation on simulated and empirical data. Our _GOKU-nets with Ubiquitous Inference_ (GOKU-UI) outperformed all baseline models on synthetic datasets even with a training set 16-fold smaller, underscoring its remarkable data efficiency. Furthermore, when applied to empirical human brain data, while incorporating stochastic Stuart-Landau oscillators into its dynamical core, our proposed enhancements markedly increased the model's effectiveness in capturing complex brain dynamics. GOKU-UI demonstrated a reconstruction error five times lower than other baselines, and the multiple shooting method reduced the GOKU-nets prediction error for future brain activity up to 15 seconds ahead. By training GOKU-UI on resting state fMRI data, we encoded whole-brain dynamics into a latent representation, learning a low-dimensional dynamical system model that could offer insights into brain functionality and open avenues for practical applications such as the classification of mental states or psychiatric conditions. Ultimately, our research provides further impetus for the field of Scientific Machine Learning, showcasing the potential for advancements when established scientific insights are interwoven with modern machine learning. During this presentation, attendees will develop a comprehensive understanding of both the foundational GOKU-net model and its advanced iteration, GOKU-UI. We will showcase through experimental evidence the performance improvements these advancements bring, while also explaining the rationale and specific details behind the enhancements. We hope that attendees will learn from our experience, enabling them to implement similar strategies to rise the Ki of their own SciML models. <br/><br/> Paper: https://openreview.net/forum?id=uxNfN2PU1W Codes: https://github.com/gabrevaya/TMLR_GOKU-UI <br/><br/> [1] Baker, Nathan, et al. Workshop report on basic research needs for scientific machine learning: Core technologies for artificial intelligence. USDOE Office of Science (SC), Washington, DC (United States), 2019. [2] Rackauckas, Christopher, et al. "Universal differential equations for scientific machine learning." arXiv preprint arXiv:2001.04385 (2020). [3] Shen, Chaopeng, et al. "Differentiable modelling to unify machine learning and physical models for geosciences." Nature Reviews Earth & Environment 4.8 (2023): 552-567. [4] Chen, Ricky TQ, et al. "Neural ordinary differential equations." Advances in neural information processing systems 31 (2018). [5] Rubanova, Yulia, Ricky TQ Chen, and David K. Duvenaud. "Latent ordinary differential equations for irregularly-sampled time series." Advances in neural information processing systems 32 (2019). [6] Linial, Ori, et al. "Generative ode modeling with known unknowns." Proceedings of the Conference on Health, Inference, and Learning. 2021. [7] Ribeiro, Antônio H., et al. "On the smoothness of nonlinear system identification." Automatica 121 (2020): 109158. [8] Turan, Evren Mert, and Johannes Jäschke. "Multiple shooting for training neural differential equations on time series." IEEE Control Systems Letters 6 (2021): 1897-1902. false GitHub https://pretalx.com/juliacon2024/talk/ULXMLY/ https://pretalx.com/juliacon2024/talk/ULXMLY/feedback/ Else (1.3) Talk 2024-07-10T11:00:00+02:00 11:00 00:30 What's the point of a DSL for modeling if the solution can't be accessed using the model's variables? No one remembers what `sol[1]` is. SymbolicIndexingInterface.jl is a new package in the SciML ecosystem. It defines an interface to allow symbolically defined systems and their solutions to be efficiently indexed using symbolic variables. Any DSL implementing the common interface will automatically support symbolically indexing the relevant data structures. juliacon2024-43285-symbolicindexinginterface-jl-symbolic-indexing-for-everyone SciML Aayush Sabharwal en DSLs such as ModelingToolkit allow creating models using symbolic variables and writing the relevant equations similar to how they're written mathematically. SymbolicIndexingInterface was created to allow accessing the values of these symbolic variables without having to dig through internals of the relevant libraries. The intent of `sol[x]` is much more obvious than `sol[1]`. Not to mention, the order of variables is not guaranteed and may be changed by the modeling library. Most notably, SymbolicIndexingInterface is designed to be independent of the modeling DSL and symbolic framework, providing access to powerful indexing capabilities if a data structure implements its interface. Any type implementing the interface can be queried for the values of it's symbolic variables. Multiple variables can be queried at once using (arbitrarily nested) tuples and arrays, and the result is type-inferred if the queried collection of variables is completely concretely typed. SymbolicIndexingInterface can create functions that cache the metadata needed to access a particular symbolic quantity, allowing for efficient queries/updates to the same quantity repeatedly. false https://pretalx.com/juliacon2024/talk/RCXMYX/ https://pretalx.com/juliacon2024/talk/RCXMYX/feedback/ Else (1.3) Talk 2024-07-10T11:30:00+02:00 11:30 00:30 The idea behind the JuliaSim Modeling Language (JSML) was to rethink how we describe the composition of complex system models in ModelingToolkit.jl (MTK). JSML takes a strictly declarative approach and focuses on encapsulating behavior into reusable component models and then composing them into complex hierarchical system models. All imperative aspects of the modeling and still handled via Julia. juliacon2024-43441-juliasim-modeling-language-composing-complex-systems-with-mtk SciML Michael Tiller en There are several methods for creating models for ModelingToolkit. The simplest way is to declare whatever variables or parameters the model includes along with the equations used to describe the systems behavior. From here, ModelingToolkit finds the most efficient approach for solving that system. It is also possible to use a collection of Julia macros to describe reusable component models and systems composed of these reusable component models. The JuliaSim Modeling Language (JSML) approach adds yet another way of composing ModelingToolkit models. Instead of building on top of Julia imperative semantics to describe and construct models, JSML takes a declarative approach. It provides a domain specific language (DSL) for defining reusable component models (their equations, parameters, connectors) and how these components are connected in order to define systems. The hope is that this DSL provides a very focused way of describing the behavior and composition of models that makes for an easier learning curve, better diagnostics, static analysis and a greater ability to reason about such models. These components will leverage Julia functions for any imperative semantics they require. JSML models are fully compatible with both ModelingToolkit.jl as well as the JuliaSim modeling environment. In practice this means that JSML defines not just how the components behave, but also how they are rendered in a graphical environment. Model libraries leverage the Julia package manager and can therefore be fully versioned and dependent on other model libraries. false Slides (no video) https://pretalx.com/juliacon2024/talk/HEFX3B/ https://pretalx.com/juliacon2024/talk/HEFX3B/feedback/ Else (1.3) Talk 2024-07-10T12:00:00+02:00 12:00 00:30 ModelingToolkit Standard Library has adopted several conventions to standardize model definition across Julia. And it has amassed new model libraries. The new DSL interface for ModelingToolkit now supports arrays, branching and looping statements and more for building complicated models. This talk showcases these. juliacon2024-44241-updates-to-standard-library-the-native-dsl-of-modelingtoolkit SciML Bradley CarmanVenkatesh Prasad en New sub-libraries and additional components are added to the ModelingToolkitStandardLibrary (MSL). And the library has adopted sign convention for input components with through variables. These updates will be showcased here. The ModelingToolkit now has a new DSL, @mtkmodel, which greatly simplifies defining models. While simple models are straightforward to define, with branching and looping statements, complicated components can be modeled too. This talk gives more insight into defining such models and interpreting the metadata, including understanding the internal representations of user inputs. This talk will also discuss best practices and conventions in defining components and models, and the interpretation of common error messages. Additionally, this talk will introduce the macro @mtkbuild to assemble a ModelingToolkit model for solving. This talk will be a short guide on all one has to know to use this DSL-based modeling. And it will be a discussion on using and contributing to the ModelingToolkitStandardLibrary. false Github Github https://pretalx.com/juliacon2024/talk/ZFD78L/ https://pretalx.com/juliacon2024/talk/ZFD78L/feedback/ Else (1.3) Talk 2024-07-10T14:00:00+02:00 14:00 00:30 Julia's SciML represents nearly a hundred of some of the most widely used Julia packages. How's it doing? In this talk we will discuss many of the latest improvements, where we are lacking, and the near future roadmap. This is made to be a celebration of our wins and an appreciation of our lingering challenges, highlighting to the community what to be proud of but also what needs more time to cook. juliacon2024-43198-state-of-julia-s-sciml-ecosystem SciML Chris Rackauckas en SciML is huge. If I say "I am using a SciML package", that could mean DifferentialEquations.jl, but it could also mean NonlinearSolve.jl, or ExponentialUtilities.jl, MuladdMacro.jl, or anything in the long tail. Yet it is treated, maintained, and documented as a cohesive whole. But in terms of maturity, that is definitely not the case. This talk will highlight and put firm grading on the maturity of different parts of the project, where pieces like the ODE solvers are highly mature while other aspects like GPU-based optimizers or high index DAEs have a medium level of maturity, while other promising and popular libraries such as MethodOfLines.jl have a lot Discourse discussion but are knowingly at an immature stage. Part of this talk is to paint in broad strokes a picture of the current state of the ecosystem to help the general user base better understand the current state of the project. But I think another major point is really, what's next? Some pieces that are immature are the main focus of the current development, especially aspects like boundary value problems, complementary problems, and parallelism in nonlinear optimization. Other areas such as uncertainty quantification schemes have been progressing but comparatively lack the team activity in comparison to some of the other focus areas. We hope to outline the lay of the land but also provide some perspective on the driving forces behind this progression to both highlight our near future goals but also indicate the road blocks that potential contributors can use as a starting point for helping the project themselves. false https://pretalx.com/juliacon2024/talk/QKU8BE/ https://pretalx.com/juliacon2024/talk/QKU8BE/feedback/ Else (1.3) Talk 2024-07-10T14:30:00+02:00 14:30 00:30 Dynamic models via ordinary differential equations (ODEs) are often used to model biological processes. However, ODE models often have unknown parameters that must be estimated from data. This corresponds to minimizing an objective function. PEtab.jl is a Julia package for setting up parameter estimation problems for dynamic models in Julia. Here, I will introduce PEtab.jl, and benchmark results on how PEtab compares against non-Julia tools for parameter estimation. juliacon2024-43391-petab-jl-efficient-parameter-estimation-for-dynamic-models SciML Sebastian Persson en Dynamic model in biology and in the pharmaceutical industry often have unknown model parameter, such as reaction rates, that must be estimated from experimental time-series data. This parameter estimation problem involves formulating a likelihood function, which subsequently is minimized via numerical methods. For simple cases, the likelihood function can easily be coded by using the SciML ecosystem in Julia. However, for more complex cases, like when the model includes events, data is collected under various simulation conditions, or the model should be at a steady state at time zero, correctly coding a likelihood function is a time-consuming and error-prone process. [PEtab.jl](https://github.com/sebapersson/PEtab.jl) is a Julia package that makes it easy to create parameter estimation problems in Julia. This by leveraging various features from the SciML ecosystem. In this talk I will cover: * How to import problems specified in the [PEtab](https://github.com/PEtab-dev/PEtab) standard format for parameter estimation problems. * How to import SBML models with [SBMLImporter.jl](https://github.com/sebapersson/SBMLImporter.jl) - the importer used by PEtab to import dynamic models in the SBML standard format. * How to easily setup parameter estimation problems directly in Julia, where the dynamic models can be provided as either a [Catalyst.jl](https://github.com/SciML/Catalyst.jl) `ReactionSystem` or a [ModelingToolkit.jl](https://github.com/SciML/ModelingToolkit.jl) `ODESystem`. * Which gradient computation methods to use. PEtab.jl integrates with ForwardDiff and SciMLSensitivity, allowing gradient computations through both forward and adjoint approaches, however, selecting the best method can be non-trivial. Lastly, I will address the question: *Should Julia be used for parameter estimating dynamic models in biology and pharmaceutical research?* There already exist excellent tools for dynamic modelling in biology, such as [pyPESTO](https://github.com/ICB-DCM/pyPESTO), which utilizes [AMICI](https://github.com/AMICI-dev/AMICI) as simulation engine. To evaluate how PEtab.jl compares against AMICI we conducted an extensive benchmark on real models with real data. false Slides https://pretalx.com/juliacon2024/talk/NY8P98/ https://pretalx.com/juliacon2024/talk/NY8P98/feedback/ Else (1.3) Talk 2024-07-10T15:00:00+02:00 15:00 00:30 Julia's SciML is a large ecosystem of numerical solvers, modeling tools, utility libraries, and much more. What are the guiding principles of what makes "a SciML library"? In this talk we will go into detail about the contribution and code practices of the SciML organization. We will highlight how we've made the interfaces more concrete, the continuous benchmarking practices, high-level error messages, and other improvements seen throughout the last few years. juliacon2024-43121-docs-ci-tests-error-messages-and-interfaces-in-julia-s-sciml SciML Chris Rackauckas en The focus of this talk is not on speed and numerics but on infrastructure: how is it done and why. SciML's contribution format is codified in the SciML Style and COLPRAC which specify a repeatable format for large-scale reproducible numerical ecosystems in the Julia ecosystem. We want to share our processes and practices so that other Julia organizations can adopt the policies and procedures we are using to scale. The first discussion is on documentation. The [SciML documentation](https://docs.sciml.ai/Overview/stable/) greatly differs from a standard Julia package documentation because it's documenting hundreds of packages and attempting to not silo them but emphasize how they should be used together. We will discuss some of the high-level design principles involved, how Multidocumenter.jl is used to piece it all together, some of the major wins seen with this approach, and some of the downsides. Next we will focus on the testing infrastructure of the SciML organization. The SciML organization might have some of the most expensive and comprehensive testing on Github for open source projects in general, and we will discuss why this is required for detailed studies of numerical solvers. We will discuss the various kinds of tests that are used, including ones not standard in other repos like downstream testing and downgrade testing, all to build a more stable system. All of this discussion is easily repeatable by audience members by simply going to one of the repos and copying the .github/workflows scripts! Next we will talk about error messages and interfaces. But Julia doesn't have interfaces? Well with SciML we have over the years built many interface packages to thoroughly document our interfaces and requirements in order to make it easy to statically check for high level correctness directly from type definitions. We will describe why ArrayInterface.jl, StaticArrayInterface.jl, and RecursiveArrayTools.jl exist, the interesting questions like "if you have an array A, how do you make the best Jacobian matrix for it?", and the new and improved error messages that SciML throws if interface incompatibility is detected. You will likely learn a lot about the edge cases of generic programming and how the SciML libraries have been made to support "any wild inputs", but importantly, understand how that has evolved from the wild west into a maintainable and testable system with strong guarantees on generic behavior. Finally, we will discuss the continuous benchmarking practices of the SciML ecosystem. We believe benchmarks are never complete, they are always evolving, and they are not a tool to win arguments but to improve code. Thus what really matters is making benchmarks that evolve over time to continue help you learn more about what the right strategies should be. We will describe how the SciML generic interfaces facilitate easier benchmarking and where we are currently lacking. false https://pretalx.com/juliacon2024/talk/99QN9H/ https://pretalx.com/juliacon2024/talk/99QN9H/feedback/ Else (1.3) Lightning talk 2024-07-10T15:40:00+02:00 15:40 00:10 Structural identifiability is a property of a dynamical model that determines if the model parameters can be inferred uniquely in the absence of noise. StructuralIdentifiability.jl allows to assess the identifiability of dynamical models described by ODEs. In this talk, we will present new functionality in StructuralIdentifiability.jl, which allows one to find all identifiable combinations in the model under consideration and automatically reparametrize the model to make it fully identifiable. juliacon2024-44453-model-reparametrization-with-structuralidentifiability-jl SciML Alexander Demin en As a result of recent work, new functionality has been implemented in StructuralIdentifiability.jl. We would like to introduce this functionality in our talk. This new functionality allows the user to find, in a matter of seconds, all rational functions of parameters and states that are identifiable in the model of consideration and, possibly, reparametrize it. To the best of our knowledge, other open-source state of the art software cannot do that. Identifiability analysis and reparametrization is an important step of model design, so we expect that the topic of the talk would be of interest to practitioners in modeling and control. During the presentation, we will try to avoid the technicalities, and instead focus on simple but meaningful examples. We plan to include a short demo to demonstrate the package capabilities. For further details, one can consult the relevant tutorial pages from the package documentation: https://docs.sciml.ai/StructuralIdentifiability/v0.5.2/tutorials/identifiable_functions/ https://docs.sciml.ai/StructuralIdentifiability/v0.5.2/tutorials/reparametrization/ This work is a joint result by Alexander Demin, Gleb Pogudin, and Chris Rackauckas. false https://github.com/SciML/StructuralIdentifiability.jl https://pretalx.com/juliacon2024/talk/WR9WPA/ https://pretalx.com/juliacon2024/talk/WR9WPA/feedback/ Else (1.3) Lightning talk 2024-07-10T15:50:00+02:00 15:50 00:10 To improve our understanding of biological processes, dynamic models are built that describe the human blood glucose after a meal. However, these models are typically built based on population averages and therefore cannot capture the full scope of individual dynamics. Using SciML to incorporate machine learning techniques into these models, we aim to improve model personalisability. juliacon2024-42686-personalising-models-of-human-blood-sugar-using-sciml SciML /media/juliacon2024/submissions/SWG7QE/juliacon_talk_tXGVg5y.png Max de Rooij en Precision nutrition aims to provide personalised dietary recommendations in order to improve overall metabolic health, opposed to general dietary recommendations. By using the Eindhoven Diabetes Simulator (EDeS), a mechanistic model of human response of blood glucose and insulin to standardised meals, we aim to capture relevant and biologically interpretable parameters of current metabolic health. However, this model was built to describe population average responses and fails to describe the full extent of inter-individual variability. To improve the model's ability to capture personalised meal responses, and to improve the relevance of individual model parameter values, the framework of neural universal differential equations was used. By incorporating a neural network into targeted components of the model, we can specifically increase the model's flexibility, without compromising strong biological bias that enables parameter estimation on limited data. In this talk, we present results on training universal differential equations on sparsely sampled human data using physiology-informed regularisation and the recovery of personalised glucose-driven insulin production using conditional neural networks in universal differential equation models. In this way, the hybrid model enables us to improve our understanding of individual variation in blood sugar responses to meals, and provides interpretable measures to aid in the design of personalised dietary recommendations. false https://pretalx.com/juliacon2024/talk/SWG7QE/ https://pretalx.com/juliacon2024/talk/SWG7QE/feedback/ Else (1.3) Lightning talk 2024-07-10T16:00:00+02:00 16:00 00:10 JuliaSim HVAC provides a comprehensive suite (based upon ModelingToolkit.jl) for the modeling and simulation of complex thermofluid systems via a library of pre-built component and refrigerant models that connect to advanced solvers that are customized to system behavior and are composable with the SciML ecosystem. We demonstrate typical workflows of the HVAC engineer: Parameter Estimation, Design Optimization, Control and Machine-Learning based acceleration. juliacon2024-44340-juliasim-hvac-composing-thermo-fluid-modeling-with-sciml SciML /media/juliacon2024/submissions/DLVCHS/Screenshot_from_2024-01-31_11-27-21_Ccs4isG.png Avinash Subramanian en Currently, industrial HVAC modelers use disparate tools for each step such as modeling and simulation, calibration, design optimization, control design, and machine learning. We provide an alternative approach leveraging the JuliaSim platform that enables all of these and more activities to be completed in one environment. The JuliaSim HVAC package provides the following features: 1. Industry-grade pre-built components: • Configurable components for Tube-Fin Heat Exchangers, Compressors, Valves, Fans, Conditioned spaces and Pipes • Drag and drop in GUI for rapid prototyping 2. Thermodynamic property models: • Spline-based thermodynamic property models for several refrigerants (such as R32, R1234YF, R290, R152a, R134a, R410A, R717) • Dry Air and Moist Air 3. Robust Solvers: • Robust solvers that handle stiff nonlinear discontinuous dynamics • Specialized DAE Initialization routines for large-scale models. 4. Composability with Machine Learning Workflows: • Integrate with the Model Optimizer tool for automated model calibration unleashing the power of automatic differentiation of the simulator • Leverage the Digital Echo tool for model acceleration and smoothing out of irrelevant dynamics using neural surrogates. 5. Connect to Controls: • Integrate with the Control packages for PID, Linear and Nonlinear Model Predictive Control (MPC). We demonstrate some of these workflows highlighting the advantages of performing these in a Julia environment versus the current state-of-the-art. false v5 demo https://pretalx.com/juliacon2024/talk/DLVCHS/ https://pretalx.com/juliacon2024/talk/DLVCHS/feedback/ Else (1.3) Lightning talk 2024-07-10T16:10:00+02:00 16:10 00:10 ProcessSimulator.jl provides a tool for chemical process modeling - a key workflow in chemical engineering. Built upon ModelingToolkit.jl that enables writing compact representations of physical phenomena occurring in the unit operations, it supports steady-state (with NonlinearSolve.jl) and dynamic simulation (with DifferentialEquations.jl). It interfaces with Clapeyron.jl and various automatic differentiation packages. ProcessSimulator will be made open-source through the SciML organization. juliacon2024-44343-processsimulator-jl-a-differentiable-chemical-process-simulator SciML Andrés RiedemannAvinash SubramanianVinicius Viena en Process simulation involves connecting multiple unit operation models (such as reactors, separation units, heat exchangers, mixers and splitters etc.) that in sum are involved in the conversion of a feed chemical stream to a product stream. Current commercial tools tend to be siloed, operate as blackboxes and do not provide the functionality of a full-fledged programming language. In addition, supporting next generation workflows requires leveraging recent advances in symbolic-numeric programming and scientific machine learning. ProcessSimulator.jl provides the functionality of both dynamic and steady-state process simulation (process flowsheeting) by making use of the flexibility of ModelingToolkit.jl (MTK) to allow seamless transition between these two modes. While this package is still under active development, the following unique features are highlighted: 1. Robust process flowsheeting leveraging symbolic transformations and automatic differentiation (AD) - Process flowsheeting involves the construction and solution of a nonlinear equation system put together by combining descriptive equation models of each of the unit operations involved. Declarative symbolic modeling languages such as MTK allow library developers and users to write compact high-level representations and let the compiler do the work of simplifying and translating these to efficient numerical routines. - In addition, the generation of exact derivatives for instance by making use of existing AD packages (ForwardDiff.jl, ReverseDiff.jl, Zygote.jl, Enzyme.jl) is key to robust, fast and accurate process simulation. 2. Interface with Clapeyron.jl - an open-source and extensible thermodynamic property package 3. System-level Superstructure Optimization - The package provides an interface to the Julia Math Programming ecosystem (MathOptInterface.jl and JuMP.jl) to provide a large suite of tools for mixed-integer and nonlinear optimization. 4. Interface with the SciML and DifferentialEquations.jl for dynamic simulation. false https://pretalx.com/juliacon2024/talk/LP3XAL/ https://pretalx.com/juliacon2024/talk/LP3XAL/feedback/ Else (1.3) Lightning talk 2024-07-10T16:20:00+02:00 16:20 00:10 In this talk, we present a fast method for estimating parameters from data, when modeling with differential equations. PhysicsInformedRegression.jl works as an extension to the [SciML](https://sciml.ai/) ecosystem, specifically for symbolic models. It'll be shown how to apply the provided method on simulated data for certain examples (SIR, enzyme reactions, lotka-volterra and lorenz attractor). juliacon2024-44314-fast-parameter-estimation-with-physicsinformedregression-jl SciML /media/juliacon2024/submissions/LSCYQJ/lotka_volterra_kZVtRUj.png Marcus Galea JacobsenJonas NielsenAlbert Brincker Olson en [PhysicsInformedRegression.jl](https://github.com/MarcusGalea/PhysicsInformedRegression.jl) is a package which allows the use of [Ordinary Least Squares](https://en.wikipedia.org/wiki/Ordinary_least_squares) to solve the inverse problem for models based on non-linear differential equations. This method has been tested and compared against non-linear optimization methods on Physics Informed Neural Networks, which is an alternative strategy for solving the same problem. Although both methods manage to successfully estimate target parameters, Physics Informed Regression has been shown to outperform in terms of accuracy and speed. Especially for larger and more complicated models. In theory, the method could outperform all non-linear optimization strategies, assuming state derivatives can be computed from data with high accuracy. In our examples we use an implementation of finite differences (`finite_diff`) to compute these derivatives, but in practice alternative methods should be explored, especially for noisy data sampled at a low rate. The method `physics_informed_regression` has been implemented using the [ModelingToolkit](https://docs.sciml.ai/ModelingToolkit/stable/) framework, such that it applies seemlessly to generic models, using only few lines of code. This also implies compatibility with other modules within the ecosystem, such as [Catalyst.jl](https://docs.sciml.ai/Catalyst/stable/) (see enyzyme-reaction example in the repository). false Presentation https://pretalx.com/juliacon2024/talk/LSCYQJ/ https://pretalx.com/juliacon2024/talk/LSCYQJ/feedback/ Else (1.3) Talk 2024-07-10T16:30:00+02:00 16:30 00:30 Scientific machine learning methods that balance mechanist equations with data-driven inference provide novel surrogates that decompose global from local behaviors inherent to high-fidelity stochastic models. This novel approach to surrogate modeling is pioneering advancements in hierarchal calibration of agent-based models that preserve foundational scientific knowledge. juliacon2024-44278-interpretable-hierarchical-calibration-of-agent-based-models SciML Erin Acquesta en Machine-learned models are increasingly being used in lieu of, to complement, or as surrogates for classic computational models. The emerging field of scientific machine learning (SciML) seeks to fuse traditional mathematical modeling with advances in machine learning to handle challenges such as the implementation of numerical solvers, model-form error estimations, and the computational expense of high-fidelity models. SciML models balance mechanist equations with data-driven inference, resulting in computational models that preserve scientific knowledge while readily adapting to the unknown through data-driven discovery. These advancements are setting the foundation for which SciML is providing novel surrogates that decompose global and local behavior inherent to high fidelity stochastic models. This presentation will introduce neural network (NN) function approximations of model-form error to close the gap between ordinary differential equations (ODE) compartmental model to an epidemiological agent-based model (ABM). This universal differential equations surrogate to the ABM allows us to preserve the foundational ODE that represents the global disease dynamics and couples it the NN model-form errors that isolate function approximations for the local behaviors of the ABM. We will then further discussion on using this UDE surrogate to automate hierarchical calibration of ABMs where we decompose global parameter estimations from local parameter influence. false Presentation - PDF version https://pretalx.com/juliacon2024/talk/PUXBCN/ https://pretalx.com/juliacon2024/talk/PUXBCN/feedback/ Else (1.3) Talk 2024-07-10T17:00:00+02:00 17:00 00:30 We introduce `MeshGraphNets.jl`, an open-source library that provides the neural network architecture of *MeshGraphNets* by Google DeepMind in the context of NeuralODEs. It supports full computation on the GPU for accelerated training and evaluation of the system and provide an interface for customizing *MeshGraphNets* for your own use case. We show that the network has an improved understanding of the underlying phenomena on a network derived from a real world hydraulic brake system. juliacon2024-43402-meshgraphnets-jl-adaptation-of-meshgraphnets-as-neuralode SciML /media/juliacon2024/submissions/HDGJMJ/meshgraphnetsjl_logo_klPxdsj.png Lars MikelsonsJulian Trommer en Simulating physical systems with a spatially distributed domain, such as those encountered in fluid dynamics or structural mechanics, requires solving intricate and computationally demanding differential equations. By taking advantage of the mesh-like structure of these methods and incorporating machine learning methods in place of the equations we can significantly improve the computation time during system evaluation. This is the core concept of *MeshGraphNets* and will be discussed in the first part of the talk. The second part will continue with the specific details of the design choices of the Julia packages `MeshGraphNets.jl` and its underlying core package `GraphNetCore.jl`. Designing *MeshGraphNets* as a NeuralODE allows you to incorporate the full suite of ODE solvers from `DifferentialEquations.jl` into both the training and the evaluation process. For example, you can easily switch from a derivative-based collocation training to a solver training to enable the network to more accurately learn the actual physics behind the modeled system. In order to efficiently train the NeuralODE we designed our packages with full compatibility and optimised execution on the GPU in mind. We will conclude our talk by presenting the improvements of a NeuralODE based design in the context of an industrial application in the form of a hydraulic brake system. false GitHub https://pretalx.com/juliacon2024/talk/HDGJMJ/ https://pretalx.com/juliacon2024/talk/HDGJMJ/feedback/ Else (1.3) Poster 2024-07-10T18:30:00+02:00 18:30 00:30 Deep Learning models are often composed of a few building blocks operating on tensors with relatively little control flow compared to more traditional code. Coil proposes a mechanism to extract the tensor subprogram from the model call graph and lift its operations to the MLIR representation. By leveraging the IREE compiler stack, Coil is able to fuse and optimize operations across Julia function calls since the whole model can be observed. juliacon2024-43302-coil-jl-lifting-julia-array-operations-to-mlir Posters Paul Berg en Deep Learning models are often composed of a few building blocks operating on tensors with relatively little control flow compared to more traditional code. Coil proposes a mechanism to extract the tensor subprogram from the model call graph and lift its operations to the MLIR representation. By leveraging the IREE compiler stack, Coil is able to fuse and optimize operations across Julia function calls since the whole model can be observed. false https://pretalx.com/juliacon2024/talk/N8UDQS/ https://pretalx.com/juliacon2024/talk/N8UDQS/feedback/ Else (1.3) Poster 2024-07-10T19:00:00+02:00 19:00 00:30 The deferred acceptance (DA) propensity score approach is a highly credible causal inference method due to its ability to approximate a randomized control trial (RCT) closely. However, this method is typically very complicated and computationally expensive to run, with no published package available in any programming language ecosystem. We developed a package in Julia to run the DA propensity score approach that will be easy for applied researchers in education to use and implement. juliacon2024-44469-a-deferred-acceptance-propensity-score-package-in-julia Posters August GuangJordan Lawson en The deferred acceptance (DA) propensity score approach is a highly credible causal inference method often used in education research due to its ability to approximate a randomized control trial (RCT) closely. However, this method is typically very complicated and computationally expensive to run due to the requirement of specialized knowledge about intricate school assignment systems with a lot of iterative steps and the need for a large number of simulations, i.e., assignment runs. No published package is available in any programming language ecosystem that implements and runs the method, although ad hoc code exists in SAS and R. We developed a package in Julia to run the DA propensity score approach that will be easy for applied researchers in education and impact evaluation research to use and implement and that automatically parallelizes tasks. We plan to benchmark our package against the previous ad hoc implementations to assess package performance. Future work will include incorporating other causal inference methods for a more complete package that allows users to test their own causal inference methods against the DA propensity score approach, all with an eye towards reducing the computational burden of these tests while providing credible causal inference. false https://pretalx.com/juliacon2024/talk/MTLQYA/ https://pretalx.com/juliacon2024/talk/MTLQYA/feedback/ Else (1.3) Poster 2024-07-10T19:30:00+02:00 19:30 00:30 Julia has achieved strong result in heterogeneous compilation such as GPU or IPU. But little work has been carried out for Field Programmable Gate Array (FPGA). Although Julia language with its type system, readability and libraries is an excellent fit for High-Level Synthesis (HLS). The idea is to used Julia IR as a MLIR frontend, develop a new toolchain which can generate representation usable by MLIR HLS tools such as ScaleHLS. juliacon2024-44363-julia-meets-field-programmable-gate-array-fpga Posters Gaëtan LOUNES en Julia has achieved excellent results in the field of heterogeneous compilation, attributed to the flexibility of the compilation toolchain. This is further enhanced by the extension of the compiler through GPUCompiler.jl, enabling smooth targeting of GPU or IPU. Each target defines a new LLVM pipeline tailored to its specific requirements, generating specialized LLVM Intermediate Representation (IR). Field Programmable Gate Arrays (FPGA) are other interesting targets [1], as they focus on energy efficiency and high-throughput contexts. Programming FPGAs traditionally involves using Hardware Description Language (HDL), but this approach is suboptimal due to its reliance on solid hardware knowledge and unwieldy algorithm development. High-Level Synthesis (HLS) has been introduced to address these limitations. State-of-the-art HLS tools, such as Vitis from AMD, employ a Design-Specific Language (DSL) based on C, which is then transformed into LLVM IR using a custom Clang frontend. The LLVM IR contains hardware semantics in the form of various annotations, utilized and transformed by the HLS backend to generate HDL code, such as Verilog or VHDL. While the approach leveraging the Vitis design suite is interesting, it has limitations, particularly due to the closed-source nature of the LLVM IR usage, making integration with new frontends cumbersome. An alternative method employed by many HLS users avoids the direct use of DSL or LLVM IR; instead, they introduce a new toolchain using Multi-Layer IR (MLIR) [2]. MLIR generalizes the concept of IR and its manipulation, introducing new IRs (referred to as dialects in MLIR terminology), which are analyzed and transformed to fit an IR sent to HLS tools. In a manner similar to the <a href="https://github.com/JuliaLabs/brutus">Brutus</a> prototype tool, we propose using Julia IR as an MLIR frontend. The key distinction with Brutus lies in the application of MLIR not to enhance backend compilation but to integrate with state-of-the-art HLS MLIR toolchains such as ScaleHLS [3]. Notably, we aim to leverage Julia IR singularities, such as typed IR or compactness, and incorporate these semantics into MLIR. To achieve this goal, several mandatory changes to the Julia compiler are necessary, including modifying the inliner policy and developing a new toolchain using MLIR with an original dialect. The toolchain for translating Julia IR to MLIR standard dialects is actively being developed, and the compilation stack will be <a href="https://gitlab.inria.fr/glounes/judias.jl">open-sourced</a> and proposed as a tool to the community. This enables the possibility to write Julia application that will run on specific FPGA target. References: [1] B. Biggs, I. McInerney, E. C. Kerrigan, and G. A. Constantinides, High-level Synthesis using the Julia Language, Feb. 2022. arXiv: 2201.11522 [cs]. [2] C. Lattner, M. Amini, U. Bondhugula, et al., MLIR: A Compiler Infrastructure for the End of Moore’s Law, Feb. 2020. arXiv: 2002.11054 [cs]. [3] H. Ye, C. Hao, J. Cheng, et al., ScaleHLS: A New Scalable High-Level Synthesis Framework on Multi-Level Intermediate Representation, Dec. 2021. arXiv: 2107.11673 [cs]. false https://pretalx.com/juliacon2024/talk/RJEPZY/ https://pretalx.com/juliacon2024/talk/RJEPZY/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-10T10:50:00+02:00 10:50 00:40 JuliaHub has been developing JuliaSim - a modern modeling and simulation tool that leverages Julia and ModelingToolkit.jl’s unique capabilities. In this talk, we will show how JulaSim’s capabilities are being used across industrial, automotive and aviation firms. Gary Mansouri, Chief Architect of Systems MBE at Boeing, will join us for a conversation on the process of model based design. juliacon2024-52825-model-based-design-for-system-product-development General Chris RackauckasViral B. ShahGary Mansouri en This Birds of a Feather will discuss how JuliaHub and Boeing work together to build tools and Julia libraries for aviation and on the process of model based design and digital engineering related to systems product development. This session will be lead by Gary Mansouri, Chief Architect of Systems MBE at Boeing and moderated by Chris Rackauckas and Viral Shah. Boeing is a leading global aerospace company and is committed to innovating for the future, leading with sustainability, and cultivating a culture based on the company’s core values of safety, quality and integrity. false https://pretalx.com/juliacon2024/talk/8LQNZL/ https://pretalx.com/juliacon2024/talk/8LQNZL/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-10T11:30:00+02:00 11:30 01:00 The Julia ecosystem for handling geospatial data and analysis is growing and improving. This is a session for anyone interested in geo in Julia to meet package contributors and users to discuss future direction and collaboration efforts. In this community building session we aim to: - Hear what people are doing in Julia and Geo - Develop group goals and common understanding for ecosystem coherence - Uncover gaps and rough edges in the ecosystem - Lower the barrier to getting involved juliacon2024-44381-juliageo-bof-shared-interfaces-and-plans-for-geospatial-julia General /media/juliacon2024/submissions/AAHKS7/juliageo_llm2D2H.svg Rafael SchoutenMaarten PronkFelix Cremer en A rough program: - Introductions: what are you using Julia for, in three words - Show and tell: share your geo packages and projects that don't have their own JuliaCon talks - The good, the bad and the ugly in Julia geospatial: a constructive session of gripe-driven development - Slido poll with questions on datasets, pain points, nice things, integrations, major wishes for the ecosystem false Presentation https://pretalx.com/juliacon2024/talk/AAHKS7/ https://pretalx.com/juliacon2024/talk/AAHKS7/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-10T14:30:00+02:00 14:30 01:00 Being reactive is often considered a bad trait. Taking a reactive approach to the design of systems involving asynchronous behavior, i.a. user interaction through UIs, coordinating long-running jobs, can often be beneficial and result in clean and robust architectures. This session aims to bring together a group of people to share approaches, experiences, challenges and wins in designing and building these types of systems in Julia. juliacon2024-44491-reactive-programmer-support-group General Joris Kraak en Taking a reactive approach to the design of systems involving asynchronous behavior can often be beneficial and result in clean and robust architectures. The Julia ecosystem provides many libraries and frameworks to support building reactive systems, for instance, Observables, Pluto, ReactiveGraphs, Rocket, Signals, Stipple, just to name a few. Designing reactive systems requires a bit of a shift in thinking due to the uncertain nature of asynchronicity, which can take a fair bit of practice, especially when moving beyond mapping simple UI elements onto data structures. This session aims to bring together a group of people to share approaches, experiences, challenges and wins in designing and building these types of systems in Julia. Which packages they prefer for which types of tasks and why, what types of issues are common and how they are solved, etc. false https://pretalx.com/juliacon2024/talk/GLMKTM/ https://pretalx.com/juliacon2024/talk/GLMKTM/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-10T15:30:00+02:00 15:30 01:00 We would like to have an open discussion on "How to use Pluto for teaching" to discuss best didactic practise for teaching with Pluto for supervised and self-learning experience The aim is to raise awareness for good teaching practise (design and instructions) to improve learning experience. juliacon2024-43949-pluto-teaching-with-pluto Notebooks & Graphics Luca FerrantiGerhard Dorn en Open space, everyone welcome, spontaneous contributions welcome Focus on users' learning experience in different setups: 1) guided in class (as homework, additional material and so on) 2) self-study (stumbled over the notebook in the web - MOOC like) Discuss some sample notebooks from a didactic point of view (like 2). Design and instructions for good learning experience depending on following factors: - the setup (self or supervised) - the audience - expectation of passive reading or active coding Agenda: - Introduction of participants round (2 minutes each) - Frame the two learning setups (and collect feedback) and the learner's journey - Brainstorm Dos and Don's for each setup - Review two sample notebooks together - Harvest insights of good design and instructions false Miro Board to share your Pluto lectures and notebooks https://pretalx.com/juliacon2024/talk/ZYLDA7/ https://pretalx.com/juliacon2024/talk/ZYLDA7/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-10T16:30:00+02:00 16:30 01:00 Julia Gender Inclusive is an initiative that aims to provide a supportive space for all gender minorities in the Julia community. In this BoF session we hope to discuss the status of (gender) diversity in the community, plan initiatives, and engage supportive allies. While we focus on gender diversity, we would like to open the discussion up to all facets of diversity to connect organizers of different diversity initiatives and start new initiatives. We invite everyone to get involved! juliacon2024-44367-discussing-gender-diversity-in-the-julia-community Community Xuan (Tan Zhi Xuan)Letícia MadureiraSkylar GeringJulia Gender InclusiveKim Louisa Auth en The objective of this BoF is to create space for discussion and community building among people who feel their gender is underrepresented within the Julia community, as well as allies who want to support us. We aim to create a safe and fruitful discussion about gender diversity, increase awareness of our current initiatives such as the Julia Gender Inclusive Community Hours, receive input on new actions we can take as Julia Gender Inclusive, and reach out to others who want to get involved. This year, we want to further enhance the contact between different diversity initiatives in the community and open the discussion up to different aspects of diversity. false Diversity BoF slides https://pretalx.com/juliacon2024/talk/SQWJ7G/ https://pretalx.com/juliacon2024/talk/SQWJ7G/feedback/ Struct (1.4) Poster 2024-07-10T19:00:00+02:00 19:00 00:30 We present Tsetlin.jl, a Julia implementation of Tsetlin Machines, which are interpretable machine learning models based on propositional logic. Tsetlin Machines have gained prominence by achieving high accuracy on a variety of problems, while also being efficient in terms of speed, memory use and energy consumption. While the original Tsetlin Machine works on binary data, later extensions can handle continuous and categorical data, and have found applications to images, text and speech. Tsetlin juliacon2024-43509-tsetlin-jl-tsetlin-machines-in-julia Posters Darshana Abeyrathna KurugeAndreas Hafver en In 2018, Prof. Ole Christoffer Granmo introduced the Tsetlin Machine and named it after Michael Lvovitch Tsetlin, who invented the Tsetlin automaton. Tsetlin automata are binary state machines that make decisions based on a reward and penalty scheme, and the Tsetlin Machine recognizes patterns by collaboratively organizing these automata into teams. The Tsetlin automata within a team vote whether a pattern is present or not in the input, and the collective decision determines the output. Some advantages of Tsetlin Machines include their interpretability and inherent parallelizability. They have a low energy and memory footprint, yet they have equaled or outperformed state-of-the-art methods on various benchmarks. The algorithms contained in Tsetlin.jl are mostly adapted from the Python versions in https://github.com/cair/TsetlinMachine/. As we get more experienced with Julia, we will try to make use of the strengths of the language to improve the efficiency and flexibility of the models. false https://pretalx.com/juliacon2024/talk/R8L3AE/ https://pretalx.com/juliacon2024/talk/R8L3AE/feedback/ Struct (1.4) Poster 2024-07-10T19:30:00+02:00 19:30 00:30 A poster about accessibility in Pluto and in scientific-computing-world. How can Pluto make scientific computing more accessible, and how can Pluto be more accessible? Also free stickers!! and you can meet the Pluto devs! juliacon2024-43249-pluto-jl-is-scientific-computing-accessible Posters /media/juliacon2024/submissions/ZWVPGG/cutebanner_l9vFsgO.png Fons van der Plas en Pluto's mission statement is to *make scientific computing more accessible and fun*! We all know that computers are fun, but what does it mean for computing to be accessible? This poster highlights different areas of accessibility in scientific computing: - Taking skills into account: easy installation, simple API. - Taking learning backgrounds into account: documentation like "Julia for Matlab users" or "Pluto for Excel users". - Web accessibility: screen reader support, high-contrast mode. - Availability: free and open source, easy to find. The Pluto developers are excited to meet you and discuss the topic at this poster! Come visit us and get a free Pluto sticker :) false https://pretalx.com/juliacon2024/talk/ZWVPGG/ https://pretalx.com/juliacon2024/talk/ZWVPGG/feedback/ Method (1.5) Experience 2024-07-10T10:50:00+02:00 10:50 00:03 Teaching a structural bioinformatics course is challenging as the audience typically consists of diverse academic backgrounds. Here, we describe our experience on teaching a course based on our framework **BiochemicalAlgorithms.jl**, which is a redesign of the open source C++-framework Biochemical Algorithms Library (BALL). The use of Julia allowed to focus more on the actual teaching goals, while the students of the former C++-based course were distracted by complex development cycles. juliacon2024-44462-teaching-structural-bioinformatics-with-biochemicalalgorithms-jl General Jennifer LeclaireAndreas Hildebrandt en Structural Bioinformatics is a highly interdisciplinary research area. A teaching course in this field typically covers topics from various disciplines such as physics(e.g., Newtonian mechanics), mathematics(numerical optimization) and biochemistry (molecular entities like atoms, molecules,...) etc. In order to run and develop applications successfully a profound knowledge of programming and software development is required. In our course, the switch from C++ to Julia enabled the students to focus on learning the algorithms and data structures implemented in BiochemicalAlgorithms.jl. The usage of C++ often impeded learning progress starting already at the level of setting up a development environment for BALL, which is a nontrivial task. In contrast, using Julia resulted in accelerated development times for applications -- based on students feedback -- in more fun. false GitHub https://pretalx.com/juliacon2024/talk/GCNMNT/ https://pretalx.com/juliacon2024/talk/GCNMNT/feedback/ Method (1.5) Experience 2024-07-10T10:53:00+02:00 10:53 00:03 For my Honours thesis, I extended Udell et al.'s work in Generalised Low-Rank Models (GLRMs), making GLRMs a tool for projecting data sets to a "fair" space according to various definitions of fairness. This enables the identifying of features that may act as proxy discriminators for protected characteristics such as gender and age. In this talk, I will share my experience of completing a year-long thesis, using Julia as the primary programming language, from zero Julia knowledge. juliacon2024-43871-notes-from-an-all-julia-honours-thesis General Vikram Sondergaard en I will spend most of the three minutes talking about my journey learning Julia, from first encountering it in Udell et al.'s code to submitting an artifact written entirely in Julia. Because my thesis is in machine learning/computational humanities, I would like to highlight the differences, and in particular the advantages, of programming in Julia where most people would program in Python. It would also be nice to garner interest in making libraries for fair machine learning in Julia, which, as far as I know, do not currently exist. Two major benefits of working with Julia were its performance advantages and intuitive benchmarking suite. As a result, programming in Julia has impacted the outcome of my thesis, especially in particularly tight deadlines. A major moment in my thesis was identifying that my quadratic-time loss function was too computationally expensive to get any meaningful results in time for a major deadline, which I only identified as a result of Julia's benchmarking tools. Being able to compare heap allocations between different algorithms was a major step in my developing a linear-time approximation of my loss function. Another major advantage I found is that Julia is a new language, and the community is tight-knit and supportive. In particular, there was one academic at my home university who is involved in the Julia community, who took the time out to have a meeting with me discussing using distributed programming in Julia to speed up my quadratic-time loss function. Finally, I would like to briefly mention some of the challenges I encountered in programming my thesis artifact in Julia. One particular issue I encountered was an incompatibility between Julia's CUDA library and the matrix inverse function in its LinearAlgebra library, which I only managed to solve by closely following the stack trace and reading more deeply about array programming in CUDA.jl. false https://pretalx.com/juliacon2024/talk/VJ9VQJ/ https://pretalx.com/juliacon2024/talk/VJ9VQJ/feedback/ Method (1.5) Experience 2024-07-10T10:56:00+02:00 10:56 00:03 I spent about one year leveraging Julia for DL research in Computer Vision, including using `Flux.jl`, `FastAI.jl`, `Metalhead.jl`, and loading python models through `PyChainCall.jl`. Happy to discuss my experience. juliacon2024-44465-my-experience-with-deep-learning-research-in-julia General Romeo Valentin en I spent about one year leveraging Julia for DL research in Computer Vision, including using `Flux.jl`, `FastAI.jl`, `Metalhead.jl`, and loading python models through `PyChainCall.jl`. Happy to discuss my experience, including the good (flexibililty, hacking packages, fast custom kernels), the bad (missing models, difficulty to collaborate), and the ugly (gradient bugs, precompile time). false https://pretalx.com/juliacon2024/talk/NVFAVL/ https://pretalx.com/juliacon2024/talk/NVFAVL/feedback/ Method (1.5) Talk 2024-07-10T11:30:00+02:00 11:30 00:30 MaxEntropyGraphs.jl introduces robust graph randomization to Julia using maximum entropy models. It enables the generation of unbiased null models from real networks for hypothesis testing. The package is completely integrated with JuliaGraphs ecosystem and enables researchers to generate random graphs that preserve specific properties, facilitates hypothesis testing and the exploration of network metrics, making it a valuable tool for network scientists. juliacon2024-43486-maxentropygraphs-jl-random-graphs-with-juliagraphs Graphs Bart De Clerck en Network analysis is a powerful tool for understanding the structure and function of complex systems, such as social networks, ecological networks, and biological networks. By examining the connections and interactions between nodes in a network, researchers can gain insights into the underlying processes and patterns that govern these systems. These real-world systems or networks can be represented by the mathematical object that is a graph. Graph randomization is a method commonly used in network analysis to establish null hypotheses and compare an observed graph against random expectations within an ensemble of graphs. For example, graph randomization can be used to investigate whether a particular network exhibits a higher level of clustering than expected by chance, which can provide insights into the presence of community structures within the network. There are many ways to do graph randomization, but maximum entropy null models are specifically useful due to their unbiased parameter estimation, incorporation of constraints, flexibility, statistical robustness, and mathematical simplicity. The MaxEntropyGraphs.jl package can be used to compute the likelihood-maximizing parameters for different null models for a variety of graphs (directed, undirected, bipartite, weighted etc.). It enables users to sample graphs from the ensemble and to compute the expected value of a graph metric directly from the ensemble. The package uses the JuliaGraphs ecosystems for everything graph related, makes us of well-established Julia optimization tools (Optimization.jl) and numerical solvers (NLsolve.jl) to obtain the graph’s likelihood maximizing parameters; leverages the JuliaDiff ecosystem for automatic differentiation and groups the different null models in a single framework. Currently, there are no existing Julia packages offering this functionality. In Python, there are some packages that provide similar functionality (NEMtropy, BiCM, etc.), but these do not always integrate directly with an established Python ecosystem for graphs, use a custom implementation for the numerical solver(s), and do not offer the possibility of using automatic differentiation. Performance testing has shown that the Julia implementation is typically faster than the equivalent Python packages for networks of different sizes and densities. The way forward for this package is to include additional null models that might be relevant for more advanced concepts such as higher-order or multilayer graphs. false https://pretalx.com/juliacon2024/talk/PFAA8M/ https://pretalx.com/juliacon2024/talk/PFAA8M/feedback/ Method (1.5) Talk 2024-07-10T12:00:00+02:00 12:00 00:30 HMMs are a very useful statistical framework, but existing implementations often limit user creativity. With Julia, we can have it all: custom probability distributions, arbitrary types, numerical stability, automatic differentiation, exogenous controls... without giving up on performance! This talk will introduce the package `HiddenMarkovModels.jl` and its main features, but also share useful lessons about leveraging abstraction in scientific software. juliacon2024-43300-fast-and-generic-hidden-markov-models General /media/juliacon2024/submissions/LPWA8D/logo_onLeGcP.png Guillaume Dalle en A Hidden Markov Model is composed of a hidden state sequence and a visible observation sequence. The current state only depends on the previous state, and the current observation only depends on the current state. These assumptions give rise to simple and efficient algorithms for tasks like state inference and parameter estimation. As a result, HMMs are popular in many fields ranging from bioinformatics to speech processing or industrial maintenance. For lack of imagination (or implementations), people often stick to Gaussian HMMs, where each observation follows a normal distribution whose mean depends on the latent state. But if you are willing to think outside the box, you can ask interesting questions: - what if I want to write a custom observation distribution? - can I use arbitrary number types for increased precision? - my transition matrix is sparse, will it break things? - how do I compute gradients of the loglikelihood? - the dynamics depend on external control variables, is that even allowed? All of these demands (and more) are met by `HiddenMarkovModels.jl`, which is the topic of the present talk. We will embark on a tour of the main design ideas, and find that each layer of abstraction unlocks new features without sacrificing speed. The end result is one of the fastest and most flexible HMM packages out there, suitable for a variety of industrial or academic applications. Package repository: <https://github.com/gdalle/HiddenMarkovModels.jl> Documentation and tutorials: <https://gdalle.github.io/HiddenMarkovModels.jl/dev/> Presentation slides: <https://gdalle.github.io/JuliaCon2024-HMM/> Video: <https://www.youtube.com/live/1c4TTosBzzY?feature=shared&t=9672> false GitHub https://pretalx.com/juliacon2024/talk/LPWA8D/ https://pretalx.com/juliacon2024/talk/LPWA8D/feedback/ Method (1.5) Talk 2024-07-10T14:00:00+02:00 14:00 00:30 TensorInference, a package for exact probabilistic inference in discrete graphical models, capitalizes on recent tensor network advancements. Its tensor-based engine features optimized contraction ordering methods, an aspect vital to computational performance. Additionally, it incorporates optimized BLAS routines and GPU technology for enhanced efficiency. In a comparative evaluation with similar libraries, TensorInference demonstrates superior scalability for models of increasing complexity. juliacon2024-43568-probabilistic-inference-using-contraction-of-tensor-networks General /media/juliacon2024/submissions/HTCDFD/logo_CASno7I.svg Martin Roa-Villescas en GitHub repo: https://github.com/TensorBFS/TensorInference.jl JOSS publication: https://joss.theoj.org/papers/10.21105/joss.05700 Reasoning under uncertainty is a key challenge in fields like AI, medical diagnosis, computer vision, and natural language processing. Probabilistic graphical models (PGMs) are crucial for this, representing complex systems' joint probability distributions efficiently. Despite PGMs' utility, probabilistic inference remains a complex task due to the high-dimensional combinatorial optimization involved. To address this, we introduce TensorInference.jl, a Julia package that combines PGMs with tensor network computational power to improve probabilistic inference performance for complex models. Probabilistic inference calculates probabilities from observed data using probability theory axioms. Inference methods are categorized into exact and approximate. Exact methods face NP-hard computational challenges related to the model's treewidth. In contrast, approximate methods like Markov chain Monte Carlo and variational inference, implemented in packages like Stan and PyMC3, offer scalability but lack formal accuracy guarantees. Thus, exact methods are resurging for their accuracy potential. TensorInference.jl utilizes recent tensor network advances to provide exact high-performance solutions for inference problems. It enables tasks like calculating partition functions, computing marginal probabilities, finding likely variable assignments, and drawing posterior samples. Tensor networks, like PGMs, are adept at representing complex system states. Computational efficiency in tensor networks hinges on the contraction sequence; hence, optimizing this order is vital. TensorInference.jl enhances computational tasks using differentiable programming, supports generic element types, and allows for hyper-optimized contraction order settings. It includes advanced contraction methods including a local search-based method, denoted as TreeSA, two methods based on min-cut algorithms, denoted as SABipartite and KaHyParBipartite, as well as a greedy algorithm, denoted as GreedyMethod. Additionally, it incorporates BLAS routines and GPU technology for improved performance. false https://pretalx.com/juliacon2024/talk/HTCDFD/ https://pretalx.com/juliacon2024/talk/HTCDFD/feedback/ Method (1.5) Talk 2024-07-10T14:30:00+02:00 14:30 00:30 The OpenAPI Specification is a machine-readable interface definition language for HTTP APIs. The Julia package OpenAPI.jl along with Julia code generator plugins to OpenAPI Generator help use OpenAPI in Julia projects. This talk will focus on giving a broad overview of OpenAPI and will demonstrate end-to-end examples of using it in Julia - begin with a specification file, generate both server and client side code, generate docs, publish, and use a service. juliacon2024-43193-openapi-jl-for-easy-http-apis General Tanmay Mohapatra en OpenAPI is a popular specification language for HTTP APIs. Many popular HTTP services publish specifications for their APIs in the OpenAPI format. It is useful in defining, versioning, and managing APIs for applications architected with HTTP based services. The Julia package OpenAPI.jl, along with its corresponding plugin to the `openapi-generator` project provides a way to leverage that in Julia applications. This talk will aim to give a quick introduction of OpenAPI, and demonstrate how to use the OpenAPI.jl package in Julia. It would demonstrate how to generate a Julia client quickly to consume a third party service that has published an OpenAPI specification, which is probably a common need. It would also walk through the complete process of defining a spec and generating both server and client side code in Julia. During the talk, at various points, we shall touch upon some internals of the package and code generator, and also some opportunities for improvements. false https://pretalx.com/juliacon2024/talk/FVRB7X/ https://pretalx.com/juliacon2024/talk/FVRB7X/feedback/ Method (1.5) Talk 2024-07-10T15:00:00+02:00 15:00 00:30 A year ago we demoed a Julia-based web application to 50 concurrent users - it failed catastrophically. We launched a team-wide effort to find the root cause of it. Was it Julia or was it our code? Turns out, it was both. juliacon2024-43403-a-retrospect-on-julia-web-services-http-performance-and-memory General Krystian GulińskiPanagiotis Georgakopoulos en Julia based web services are nothing new, but running and scaling them in production was surely going to cause us some issues. After 6 months of investigation and fixes we’re ready to share results and the knowledge acquired. In this talk we’re going to discuss: 1. Tools & Observability primitives to identify bottlenecks and root causes 2. Findings and mitigations for the issues that included: 1. Blocking/sync code paths 2. Memory Leaks/GC performance 3. HTTPS 4. Common performance pitfalls 5. Database performance (connection pooling & non-blocking approach) 3. HTTP.jl performance analysis & pitfalls [1] 4. How to structure HTTP services with performance in mind 5. Beyond HTTP.jl [2] [1] https://discourse.julialang.org/t/julia-can-be-better-at-doing-web-a-benchmark/103300 [2] https://github.com/nginx/unit, https://github.com/JuliaWeb/HTTP2.jl and other up & coming approaches false slides https://pretalx.com/juliacon2024/talk/R7MV7U/ https://pretalx.com/juliacon2024/talk/R7MV7U/feedback/ Method (1.5) Lightning talk 2024-07-10T15:50:00+02:00 15:50 00:10 SpatialDependence.jl is a Julia package for exploratory spatial data analysis (ESDA), spatial weight creation, and testing for spatial dependence (spatial autocorrelation). The package contains functions to create and handle spatial weights matrices from polygon and point geometries. It also has functions for calculating spatial lags, testing for global and local spatial autocorrelation, and plotting choropleth maps. juliacon2024-44199-spatialdependence-jl-exploratory-spatial-data-analysis Data Science and Dynamics Javier Barbero en The package SpatialDependence.jl contains functions to create and handle spatial weights matrices from polygon and point geometries. It also has functions for calculating spatial lags, testing for spatial autocorrelation, and plotting choropleth maps. The talk will show how the SpatialDependence.jl package introduces an architecture for handling spatial weight matrices representing the observation's spatial relationship. The integration with GeoInterface.jl allows the creation of spatial weight matrices from polygons and points geometry obtained from different data sources. We present how to plot choropleth maps using different algorithms to classify observations. In addition, global and local spatial autocorrelation statistics can tell us if geographically close observations have similar or dissimilar values and help us to identify clusters. During the talk, we will briefly describe the package's capabilities in a non-technical language, and how was the experience in developing it in the Julia language. false GitHub Presentation Slides https://pretalx.com/juliacon2024/talk/PV7EPE/ https://pretalx.com/juliacon2024/talk/PV7EPE/feedback/ Method (1.5) Talk 2024-07-10T16:00:00+02:00 16:00 00:30 We have a Julia application that communicates with other services over REST APIs. These services use mutual TLS for authentication, which in turn requires the use of client side TLS certificates. We found that LibCURL was the best way to do HTTPS with client certificates, but with a very C like interface, it was hard for Julia developers to use. This led us to build CurlHTTP, which is a very Julia like interface for doing HTTP(S) with LibCURL. juliacon2024-39350-curling-with-julia-a-brief-overview-of-curlhttp-jl General Philip Tellis en LibCURL.jl and HTTP.jl are the two primary ways to write HTTP clients in Julia. They both have their pros and cons. ##### HTTP.jl While HTTP.jl has a very easy to use interface to access the majority of features, including cookie handling and streaming, it suddenly becomes very complicated when you try to use TLS client certificates. HTTP.jl also doesn't have the ability to do multiple downloads in parallel on a single execution thread. ##### LibCURL.jl LibCURL makes it very easy to do mutual TLS, supporting client and server TLS certificates with well documented APIs, and has a well documented multiple download interface, but it provides a fairly low level API, and is primarily suited to developers familiar with writing applications in C. For our use case, we decided to build a higher level Julia wrapper around LibCURL's HTTP functionality (similar to what SMTPClient.jl does for SMTP over LibCURL), while making some of curl's more complicated features easy to use in a Julian way. ##### CurlHTTP.jl The result is `CurlHTTP.jl`, which provides a high level HTTP interface to LibCURL, supporting single and multiple downloads, mutual TLS, and data streaming. #### Talk Structure This talk will first briefly cover the features of `CurlHTTP` and how to use it. We will then spend a little more time going into some of the nuances and gotchas we faced while developing this library, particularly with passing Julian data types through the C interface and back to our callbacks, and with dealing with memory management in a clean way. false Live Presentation Online Presentation Downloadable Presentation https://pretalx.com/juliacon2024/talk/PSEQNH/ https://pretalx.com/juliacon2024/talk/PSEQNH/feedback/ Method (1.5) Talk 2024-07-10T16:30:00+02:00 16:30 00:30 We published a paper to help Geospatial data scientists when dealing with large noisy contours like electoral maps, water bodies or digital contours. We developed EditBoundary.jl, a Julia native semi-manual technique to reduce noise and points while respecting fidelity with 2 new algorithms. We are excited to apply this method to bring structured quad meshes back into the mainstream - they deserve better! juliacon2024-44297-editboundary-jl-a-quest-to-revive-structured-quad-meshes Math(s) Miguel Raz Guzmán MacedoIvan Méndez en In some problems of cartography and hydrology the contours of water bodies and coastlines are represented by polygonal curves with a high level of detail and thus require a large number of points. The visualization and processing of these contours may have an enormous computing demand on Geographic Information Systems due to such data scales; therefore shape preserving contours with fewer points are needed to deal with these issues. Our overarching research project, UNAMALLA, relies on EditBoundary.jl to carry out this task. We developed algorithms in Julia for such polygonal approximation. In our experiments, they handle 90% point elimination adequately, and at interactive speeds, even for highly detailed and noisy polygons. This work will become part of Meshes.jl and the GeoStats.jl ecosystem for the benefit of all, and is 100% written in Julia. false GitHub https://pretalx.com/juliacon2024/talk/ZGPPW7/ https://pretalx.com/juliacon2024/talk/ZGPPW7/feedback/ Method (1.5) Talk 2024-07-10T17:00:00+02:00 17:00 00:30 In this talk we showcase the advancements of the low-level implementation of ITensors. These advancements seek to tighten the gap between rapid algorithmic development and efficient exascale implementations. Advancements were attained through the generic redevelopment of the backend NDTensors module. We showcase our work via acceleration of the DMRG optimization of the one- and two-dimensional model Hamiltonian problems with controllable accuracy using GPU accelerators. juliacon2024-44076-improving-the-life-cycle-of-tensor-algorithm-development Physics & Quantum Chemistry karl pierce en As the accessibility to advanced computational resources, such as CPU, GPU, and QPU, becomes common to researchers across theoretical and computational disciplines, it is more important than ever to construct robust and generic software frameworks that can facilitate rapid algorithmic development on such resources. One of the biggest challenges researchers have faced in algorithmic development is the complexity of exascale and heterogeneous computer architectures. Some challenges are quite complex, such as constructing efficient memory-distributed algorithms, while others are simple yet cumbersome, such as the syntactic differences in vendor-developed, processor-specific languages. In our most recent efforts in the ITensors software suite, we are attempting to tackle these issues head-on using generic programming. The goal of the ITensors package is to create a domain-specific language for tensor arithmetic and tensor algebra built from the ground up using Julia's robust features in coordination with thoughtful generic programming practices. ITensors is the meeting point between the lower-level tensor implementation and the higher-level, problem-specific algorithm development. In this talk, I will focus on the low-level implementation in the NDTensors module where we are developing generic practices to handle implementation complexities such as dense and sparse tensor arithmetic, buffered memory management, linear and multilinear algebra, GPU implementations, task-management and scheduling, and beyond. We underscore the power of our generic programming strategy by showing multiple methods for accelerating the DMRG optimization of the one- and two-dimensional Hubbard and Heisenberg models, which require only a small number of changes to existing ITensor code and can take advantage of GPU accelerators. false https://pretalx.com/juliacon2024/talk/J39XGJ/ https://pretalx.com/juliacon2024/talk/J39XGJ/feedback/ Method (1.5) Poster 2024-07-10T18:30:00+02:00 18:30 00:30 In this poster, a large-scale mathematical model of the JAK-STAT pathway was implemented in Julia to explore IFN-I ligand discrimination. Model fitting, often time-consuming in large-scale models, was performed to different temporal IFN-I inputs. Julia’s efficiency significantly accelerated this process by expediting sensitivity analysis, parameter estimation and identifiability analysis. The resulting model facilitates investigation into the mechanisms underlying ligand discrimination. juliacon2024-44049-large-scale-mechanistic-modeling-of-immune-pathway-in-julia Posters Michelle van Haften en Type I interferons (IFN-I) play a crucial role in the cell's antiviral, antiproliferative, and immunomodulatory functions. Although multiple IFN-I subtypes activate the JAK-STAT pathway through the same receptor, they induce distinct downstream activation patterns. The mechanisms responsible for this ligand discrimination remain largely unclear. Hence, we employed the Julia Language to adapt the ODE model of the JAK-STAT pathway developed by Kok et al. to investigate IFN-I discrimination, focusing on IFNα and IFNβ. This model, consisting of 41 state variables and 73 parameters, was directly imported into Julia from SBML. Various temporal inputs of IFN-I, including sustained, single-pulse and double-pulse stimuli, were used to calibrate the model. Parameter estimation was performed to improve model fitting to this temporal data, both local and global sensitivity analysis were employed to acquire candidate parameters. Next, the optimal parameter set was determined based on the Akaike Information Criteria. Finally, Profile Likelihood Analysis was employed to assess the identifiability of these parameters. The utilization of the Julia language significantly expedited these computational processes. The resulting model provides a tool for exploring the mechanisms underlying the ligand discrimination of IFN-I. false https://pretalx.com/juliacon2024/talk/X8J38K/ https://pretalx.com/juliacon2024/talk/X8J38K/feedback/ Method (1.5) Poster 2024-07-10T19:00:00+02:00 19:00 00:30 We present `ThreadedDenseSparseMul.jl`, a library that efficiently computes dense-sparse multiplications and outperform competing packages (and `Base.SparseArrays`) in about 20 lines of code (for the basic functionality) by leveraging `Polyester.jl`. We further discuss the effect of Julia's memory layout on the performance and analyze the influence of different threading models. juliacon2024-44471-threadeddensesparsemul-jl-multi-threaded-dense-sparse-matmul Posters Romeo Valentin en Several Julia packages have been implemented to deal with multi-threaded multiplication of sparse and dense matrices, including - `IntelMKL.jl` - `ThreadedSparseCSR.jl` - `ThreadedSparseArrays.jl` - `SparseArrays.jl` (no threading) However, typically these libraries focus on sparse-times-dense multiplications, which are sub-optimal due to Julia's row-major memory layout. We present theory and benchmarks how we can outperform these libraries, as well as existing C/C++ libraries, by 2 to 16x specifically for the dense-times-sparse case by focusing on optimizing cache-locality and `Polyester.jl` for a low-overhead threading model. We will also provide additional comments on the influence of the CPU architecture (cache size etc) on the theoretical and practical performance. false The poster 😎 https://pretalx.com/juliacon2024/talk/VJEVSJ/ https://pretalx.com/juliacon2024/talk/VJEVSJ/feedback/ Method (1.5) Poster 2024-07-10T19:30:00+02:00 19:30 00:30 In many engineering tasks like semiconductor fabrication or laser welding, we face the problem of simulating and controlling the heat conduction. To tackle this issue, we developed Hestia.jl - a Julia library to simply create heat conduction simulations for up to three dimensional models. It offers several options to specify material properties, boundary conditions and actuator configurations for realistic simulation scenarios. This enables us to simulate and control a thermal dynamics at once. juliacon2024-43105-hestia-jl-modeling-and-control-of-heat-conduction Posters Stephan Scholz en Heat conduction is a fundamental physical phenomena and an important research field in process engineering, production technology and material science. Thermal processes must be understood perfectly for example in semiconductor fabrication to produce high-quality microelectronics. Many general purpose solvers like FEniCS or Trixi.jl are used to simulate complex physical problems, but these software libraries often require deep knowledge of the mathematical models and their numerical approximations. In contrast, Hestia only focuses on heat conduction models and offers a toolkit for engineers to simply specify the desired physical behavior. In this talk, we introduce [Hestia.jl](https://github.com/stephans3/Hestia.jl) and we create step-by-step heat conduction simulations from small to large scale. In particular, we explain the choice of material properties and boundary conditions. For example, material properties can be defined as isotropic or anisotropic, and boundary conditions can be specified as heat transfer and heat radiation for each boundary side individually. Furthermore, we show how actuators like heating elements can be included in the simulation to steer the heat conduction and we describe briefly how to design the (optimal) control strategy. As Hestia.jl uses the high-class numerical methods of the SciML ecosystem, we also discuss the interaction between both toolkits. Finally, we evaluate the recent state of Hestia.jl and give an outlook on possible future developments. **Key features:** - Temperature-dependent material properties - Anisotropic heat conduction - Configuration of actuator and sensor characteristics false https://pretalx.com/juliacon2024/talk/PJT3HT/ https://pretalx.com/juliacon2024/talk/PJT3HT/feedback/ For Loop (3.2) Lightning talk 2024-07-10T10:50:00+02:00 10:50 00:10 "Love Julia but hate PowerPoint? This is your solution!" Discover how to effortlessly transform your lightning-fast Julia findings into easily shareable and reproducible insights. Despite Julia's speed, the process of turning results into compelling reports can be a headache with traditional tools like PowerPoint. Hate turning your Julia findings into PowerPoint reports? I'll show you how Quarto and Literate.jl makes it easy to transform Julia code into polished reports in seconds! juliacon2024-44419-accelerate-insights-code-slides-faster Notebooks & Graphics Jack Diamond en "Love Julia but Hate PowerPoint? This talk is your solution!" Discover how to effortlessly transform your lightning-fast Julia findings into easily shareable and reproducible insights. Despite Julia's speed, the process of turning results into compelling reports can be a headache with traditional tools like PowerPoint. And it's beginner friendly! Enter Quarto – a brief overview reveals its potential for painless report creation. Learn how combining Quarto with Julia becomes a game-changer. Leveraging Literate.jl, we'll demonstrate how to supercharge your workflow, making the transition from raw code to polished report seamless. The talk features a quick demo showcasing Quarto's features, emphasizing the simplicity of transforming Julia code into a polished, reproducible report in seconds. Join us and revolutionize the way you share and communicate your Julia-powered insights. No more PowerPoint headaches – just fast, shareable, and easily reproducible results. false Slides with Links/tasks HTML report with Links/tasks https://pretalx.com/juliacon2024/talk/TEPSRM/ https://pretalx.com/juliacon2024/talk/TEPSRM/feedback/ For Loop (3.2) Talk 2024-07-10T11:00:00+02:00 11:00 00:30 While partial differential equations dominate the computational modeling landscape, integral equations provide a powerful and often overlooked alternative for addressing a diverse array of physical phenomena. In this talk we introduce Inti.jl, a new package to accurately and efficiently solve integral equations in two- and three-dimensions. Inti.jl is designed to be user-friendly and extensible, and provides tools for the discretization, solution, and post-processing of integral equations. juliacon2024-44152-solving-integral-equations-with-inti-jl Math(s) Luiz M. Faria en Despite their potential, integral equation methods face underutilization compared to popular methods like finite elements and finite differences. This is largely attributed to the challenges associated with the discretization of the integral operators ---which usually contain singular kernels---, and to the difficulties related to the efficient approximation of the dense linear systems that arise. We believe such challenges have hindered the development of user-friendly and extensible libraries for integral equations, further limiting their adoption. In this presentation, we introduce *Inti.jl*, a Julia package crafted to solve volume and boundary integral equations. *Inti.jl* provides the fundamental building blocks for discretizing and manipulating various commonly used integral operators appearing in mathematical physics, such as the single- and double-layer operators, as well as volume potentials, for a variety of problems of physical interest (e.g. acoustic scattering, Stokes flow, linear elasticity). *Inti.jl* is designed to be user-friendly and extensible, and at present it already offers a wide range of functionalities, including: - Integration with *Gmsh* for the pre- and post-processing capabilities - A unified *API* for the use of modern acceleration techniques such as *Fast Multipole Method* and *ℋ-matrices* by wrapping external packages - Specialized integration routines to handle the singular kernels often appearing in integral equation methods Our main goal with this package is to bridge the gap between researchers who develop efficient methods for solving integral equations, and the potential users of such methods who may not have the necessary mathematical or computational background to implement the methods themselves. false https://pretalx.com/juliacon2024/talk/X8RYLT/ https://pretalx.com/juliacon2024/talk/X8RYLT/feedback/ For Loop (3.2) Talk 2024-07-10T11:30:00+02:00 11:30 00:30 By solving the two-language problem, Julia makes highly performant systems easier to develop. One trade-off we accept is no static language guarantees, which can yield difficulties and runtime errors in production. We explore tools and techniques to assuage these concerns. The cornerstone of our toolbox is interface-driven design, formalizing the "verbs" our types obey. We show how formalizing interfaces can simplify development, improve robustness, and help productionize Julia code. juliacon2024-44378-building-confidently-in-julia-with-interface-driven-design General Sam Buercklin en Julia confers great potential performance to users. However, the path from performant prototype to reliable-but-still performant system in deployment is paved with a growing list of methods to implement, function signatures that may need updating across many methods, and types where some method always seems to be missing but only fails when the code is run. Building large, composable, inter-operable systems in any language is difficult, and Julia is no exception. However, these problems may be especially frustrating within Julia as entire classes of problems may not be caught until runtime, potentially in production. Often, an exhaustive test suite is seen as a panacea to production or robustness woes. Yet, without some standardization of how tests are performed, these tests can be the subject of almost as much maintenance time as the core code itself. For large projects where the size of the test suite grows, so too does the time to encounter failing tests from interface and method signature changes, rather than underlying correctness issues. As the maintenance burden and time to test increases, so too does the likelihood of missing a test and accidentally shipping broken code. This talk proposes that focusing on the interfaces which comprise systems allows us to improve our confidence that code is correct, at least from the perspective of the type and dispatch system. We observe that numerical and algorithmic correctness is often not a rate-limiting problem the Julia community tends to face given its scientific and academic roots, but test suites can often overfit to this style of correctness. Crucially, the highly composable nature of Julia often leads to many implicit or accidental assumptions being held by developers which may not hold in general, resulting in runtime failure when types do not compose as expected or fully satisfy implicit interfaces. Our thesis is that by leveraging tools to implement and enforce interfaces, a functional codestyle to ensure conformity, and building a uniform testing structure, we can more easily manage complexity in a large and growing codebase. These techniques improve productivity by informing developers of what a type implementation needs, simplifying refactor efforts, and catching interface violations which otherwise may slip through the cracks of an incomplete test suite. We explore the idea of managing complexity through interface-driven design via two lenses: the theoretical approach of design patterns and processes with associated tooling, as well as a study of existing packages which showcase interface best practices. From the design perspective, we highlight the existence of packages such as RequiredInterfaces.jl, BinaryTraits.jl, or Interfaces.jl to define, check, and potentially dispatch on interfaces or traits. We will discuss the implications of these packages on developer productivity as documentation and "onboarding" tools, as well as tools to improve trust in our Julia code to be better-behaved in production by reducing runtime errors strictly to logical errors. A discussion of functional codestyle, how it interoperates with interface-driven design, and advantages of a functional approach to logical correctness will be included. Traits and interfaces will be compared and contrasted, viewing traits as a dispatch tool relying on an interface specification. We will discuss the process that goes into developing good interfaces to capture the essence of a problem, chiefly separating the "what" from the "how" of functions. For exemplar packages, we focus on two different approaches: 1. Implementing robust interface testers, such as ChainRulesTestUtils.jl which provides a tester function for rrules and frules 2. Implementing a powerful common "language" and interface for packages to inter-operate, as demonstrated by GeoInterface.jl The implications of these packages and their offerings to improving the developer experience will be emphasized. ChainRulesTestUtils.jl not only verifies an interface implementation, but also checks for the numerical correctness as well. GeoInterface.jl utilizes interfaces to facilitate easy interoperability between packages which satisfy its interface specification. We conclude by reiterating that while the performance of Julia the language is remarkable, the developer experience of building large and robust systems is fraught with difficulties. Yet, taking an interface-driven design approach to Julia leverages the strengths of the Julia language (multiple dispatch, specializing methods, composition of types) to arrive at code which avoids easy but subtle mistakes when working on projects of increasing complexity. By designing projects to prioritize managing complexity as a codebase grows, we hope to ease difficult parts of productionizing Julia codebases. false Slides for presentation https://pretalx.com/juliacon2024/talk/PY8KAH/ https://pretalx.com/juliacon2024/talk/PY8KAH/feedback/ For Loop (3.2) Talk 2024-07-10T12:00:00+02:00 12:00 00:30 AppBundler is a versatile tool that simplifies the bundling of Julia GUI applications across different desktop platforms, including Linux, MacOS, and Windows. This talk discusses its capabilities and showcases the bundling and post-processing steps required to create a double-click installer for each platform. juliacon2024-43533-appbundler-jl-bundle-your-julia-gui-application General /media/juliacon2024/submissions/MH9JZN/appbundler_HMvRpTU.png Janis Erdmanis en Julia's ecosystem has a comprehensive range of GUI framework bindings, remarkably compatible across all major desktop platforms. Deploying Julia applications is straightforward for those with technical know-how, particularly in terms of instantiating the project's manifest file. However, the average user typically anticipates a more streamlined installation process. This includes a double-click installer, with easy access from the system menu, complete with an icon. They also expect a clean uninstallation process that doesn't leave residual files and returns the system to its prior state. In the current digital landscape, major desktop platforms have adopted the concept of self-contained applications running in confined environments. For instance, Windows utilizes the MSIX package format, Linux employs flatpacks and snaps, while MacOS favors app bundles. Each format has unique organizational requirements for application directories, configuration files, and inherent functionalities. This poses a challenge to beginners aiming to package their Julia GUI applications. The introduction of AppBundler marks a significant advancement in simplifying desktop application bundling for Julia. It relies on `main.jl` as the entry point and the project's `Manifest.toml` file to encapsulate all the necessary dependencies, including Julia itself. AppBundler uses a scratch space for caching artifacts, which streamlines the bundling process. It makes it quick, predictable, and convenient for rapid iteration. While it offers cross-platform bundling support for MacOS and Linux, AppBundler necessitates additional postprocessing for Windows and MacOS bundles. However, this is simplified through bundled helper scripts, accompanied by comprehensive documentation to assist developers. Additionally, AppBundler facilitates platform-specific customisation via a recipe system. During the hands-on portion of the talk, we will explore application packaging strategies for Linux, MacOS, and Windows. For Linux, I will demonstrate creating a snap package, showcasing installation, user data storage, and debugging techniques. In MacOS, the focus will be on post-installation procedures, including precompilation, launcher creation, code signing, and `.dmg` file packaging, supplemented by a demonstration video. For Windows, we'll delve into the intricacies of packaging, such as precompilation, the `makemsix` command, and debugging, also accompanied by a video demonstration. The talk will also cover customization options, starting with `Project.toml` variables under the `[bundle]` section. Here, application display names, summaries, and descriptions are defined for user visibility upon installation. We'll then discuss individual bundle configurations using the `meta` directory as the primary source for overriding the bundle recipe. A practical example will feature a GTK application bundled with strict confinement, detailing the specification of plugs in the `snap.yaml` file. We'll include the inclusion of a custom icon, and the redirection of standard output using `init.jl`, along with a custom `precompile.jl` file. Furthermore, we will explore the AppBundler.jl recipe system, demonstrating its utility in creating bundling recipes for uncovered platforms and packaging formats. Finally, the talk will conclude with a discussion on the future directions of `AppBundler.jl`. The session will briefly address the current state of application confinement issues, which are crucial for being able to distribute applications in marketplaces, which I have stumbled upon. Finally, I will propose potential hackathon projects, such as developing a GitHub action script and integrating `PackageCompiler.jl` into the bundling pipeline. false AppBundler Demo Repo GitHub AppBundler Presentation Slides https://pretalx.com/juliacon2024/talk/MH9JZN/ https://pretalx.com/juliacon2024/talk/MH9JZN/feedback/ For Loop (3.2) Lightning talk 2024-07-10T14:00:00+02:00 14:00 00:10 Rooted in Google's Swiss Tables brilliance, the current implementation flaunts 1-byte metadata, elevating successful lookups to unprecedented efficiency. However, this leads to inefficient performance for unsuccessful queries. Enter the paradigm shift: the fusion of metadata intricacies and the precision of Robinhood hashing. Visualize this – rehashing without redundant hash recalculations and lightning fast querying time (both success and failure scenarios). Brace for a `Dict` metamorphosis! juliacon2024-43263-unlocking-lightning-speed-of-julia-s-dict-with-robinhood-hashing Julia Internals and Tooling Koustav Chowdhury en `Problems with Julia's Dict` Julia's Dict is currently using a variation of Swiss Tables which is an open addressing based linearly probed dictionary, but it has certain shortcomings. 1. For each key, value pair in the Dict, we store a byte where 7 bit is hash and 1 bit indicates validity. Storing this metadata allows us to improve the performance of successful lookups but unsuccessful lookups do not benefit from this. 2. During rehashing of the hash table, we have to recompute the hash again for inserting the elements into its proper location and it might be an expensive operation to compute the hash for complex data types. We can make use of metadata to get rid of this shortcoming and improve Dict’s performance during rehash. `Proposed Solution` We can do all of this using a simple concept called RobinHood hashing. We can use metadata to effectively improve rehash performance and time taken for unsuccessful lookups, at the same time not compromising on the lightning speed that we all crave. Blatantly speaking, Robin Hood hashing technique is a variation of linear probing technique which improves over certain shortcomings of the linear probing. The basic idea is to take normal open addressing, and then use one clever trick in order to drastically reduce the variance of the expected average and maximum probe lengths. Shorter expected probe length leads to faster insert, delete and lookup operation on the hash table. The way to do this is: when you probe for a position to insert a new element, if the probe length for the existing element is less than the current probe length for the element being inserted, swap the two elements and keep going. This small operation leads to drastic change in expected probe lengths and we can use this fact to improve the time of unsuccessful lookups. How? Intuitively, this simple swapping operation leads to non-decreasing probe lengths among keys which suffer from "hash collision". During search of a particular key, we can use this fact to terminate our search "early" if our current probe length is greater than the element that we are currently hovering over. Keeping all of the above in mind, the idea that I am proposing is to use 4 byte of metadata per hash table entry and store 3 byte for hash and 1 byte for storing probe sequence length. Storing 3 bytes of hash allows us to save on the time needed to rehash the hash table. 1 byte for storing the probe length allows us to compute the “cost” of occupying a particular location cheaply, thus allowing us to terminate the lookups faster. Another important aspect to discuss with respect to hash tables is the Load Factor. Load factor is often expressed as % and determines the max capacity of the hash table until it has to rehash again. So, a load factor of 90% means that the table can be 90% full before it needs to rehash again. This takes into account both valid keys and “tombstone” entries. Tombstone entries are dummy entries for keys which have been recently deleted. Having these entries results in improving performance of deletions but they contribute adversely to load factor. I experimented with the backward shift deletion technique, which does not keep tombstone entries, but removes the entry from the table and then proceeds to shift back all the neighboring entries to fill the “void” created on deletion. On one hand, this helps to simplify branch conditions for insertions and lookups (because you don’t have to bother about “missing” entries), but on the other hand, this operation of backward shift on the adjacent entries increases the time for deletion. ```Benchmarks``` 1. Although the mean probe length of Dict and RobinDict both stays close to 1 for 10K entries, the variance of RobinDict is much less compared to Dict. For 10K entries, it’s almost one-third of the variance shown by Dict. We see ~3x improvement in the max probe length of RobinDict for 10K entries. For Dict, max probe length can go up to 50 entries, whereas in RobinDict never crosses more than 15. 2. While inserting an entry into Dict, we would see large spikes in the time as we inserted more and more (key, value) pairs. It happens during the time the table rehashes. With the usage of metadata, that “spike” while insertion has completely disappeared. 3. For deleting entries from RobinDict, it’s a tradeoff - while lower probe length would lead to small lookup time, but backward shifting deletion would lead to increase in time. From my benchmarks, ~60% of the time RobinDict outperforms Dict in terms of deletion. 4. For successful lookups, 80% of the time RobinDict outperforms current Dict implementation, while for unsuccessful lookups it outperforms about 60% of the time. To be honest, I expected this value to be slightly on the higher side (like 90%), but there is an extra branch condition introduced (as compared to Dict) in lookup code flow which is causing the increase in time. false https://pretalx.com/juliacon2024/talk/7ZJ3SQ/ https://pretalx.com/juliacon2024/talk/7ZJ3SQ/feedback/ For Loop (3.2) Lightning talk 2024-07-10T14:10:00+02:00 14:10 00:10 CMInject.jl is a numerical simulation framework that simulates nano-particle trajectories through aerosol injectors and their expansion into a vacuum chamber, e.g., single particle diffractive imaging (SPI) experiments. The background gas flow around the particles is simulated using computational fluid dynamics tools and the particles are tracked using a Lagrangian based tool built with Julia. This simulation tool is used to evaluate performance of various aerosol injector designs. juliacon2024-43297-simulating-nano-particle-trajectories-using-cminject-jl Physics & Quantum Chemistry /media/juliacon2024/submissions/MSSGKF/jcon24_sample_2rdGSBQ.png Surya Kiran Peravali en Single-particle diffractive imaging (SPI) is a technique employed to capture the atomic-scale structures and dynamics of (bio-) nano-particles. The complete three-dimensional structure of a nano-particle is reconstructed through a series of two-dimensional diffraction patterns from randomly oriented particles. In SPI experiments, an aerosol injection system is utilized to transfer particles into the gas phase, capturing a collimated particle stream in a vacuum. The design of these injection systems must be continuously optimized to obtain very high density particle streams with less background gas in order to increase X-ray interactions with the particles for generating high-quality diffraction patterns. However, this requires investigating a large parameter space such as operating pressures, geometrical shapes of the injector, size of the particle etc., making experimental characterization and optimization impractical. A numerical framework capable of simulating the flow of the carrier gas in the injection system and the particle trajectories is set up. The fluid flow inside aerosol injector and the vacuum chamber is simulated using a multiscale computational fluid dynamics approach (e.g., OpenFoam/SPARTA-DSMC). Subsequently, the particle trajectories are computed using the forces (e.g., Stokes drag) obtained from interpolated velocity fields along with the Brownian motion of the particles. This framework provides a quick and efficient way to search the experimental parameter space for optimization and also to further understand the physical phenomena (e.g., flow and particle interaction) inside the injection systems. The particle trajectory calculator in this framework was initially programmed and benchmarked in Python. In order to improve the computational performance, it is currently being converted to Julia. Furthermore, the ease of using Julia and the code alignment with the mathematical notations enhances clarity in understanding of the code for potential future contributors. In this presentation, we present the initial bechmarking results of the simulation tool, validate it based on experimental data and evaluate the computational performance by comparing with the former Python version. false https://pretalx.com/juliacon2024/talk/MSSGKF/ https://pretalx.com/juliacon2024/talk/MSSGKF/feedback/ For Loop (3.2) Lightning talk 2024-07-10T14:20:00+02:00 14:20 00:10 We present [Entangled](https://entangled.github.io), a generic tool for maintainable literate programming. Entangled works together with Markdown based documentation tools like `Documenter.jl`, and ships with a build system for running longer computations. We show an example from the Earth Sciences in a package called [`CarboKitten.jl`](https://mindthegap-erc.github.io/CarboKitten.jl), simulating the formation of carbonate reef platforms and their produced limestone stratigraphy. juliacon2024-44266-natural-science-computer-modeling-and-literate-programming Notebooks & Graphics /media/juliacon2024/submissions/BCKDFL/entangled-logo-export_c6Z9URc.svg Johan Hidding en Computer modeling is a vital tool in the natural sciences. However, often the software packages and scripts used in producing scientific output, live a separate life from the published research output. This is a major concern when it comes to reproducibility of results. There are many techniques for literate programming, mixing computer code and literary prose, that try to address this issue. Examples are Jupyter, RMarkdown and in the case of Julia, `Literate.jl` and `Pluto.jl`. None of these solve the issue of code complexity, and their use often results in code that is not well designed, unmaintainable and not reusable. [Entangled](https://entangled.github.io) is a system for literate programming, based on Markdown, that synchronizes code blocks and plain executable code in two directions. Executable code is *tangled* from any number of code blocks and code blocks can be *stitched* back into the markdown when some of the code was edited. This way, the executable code is always the same as which is presented in documentation and we retain the use of IDE features when editing code. Because code is treated like plain text, Entangled is completely agnostic to the used programming language. The resulting code can be reused as any other module. Because Markdown can be exported to HTML using standard documentation tools (e.g. `Documenter.jl`) as well as LaTeX/PDF (using Pandoc), Entangled can be used to write documentation, but also completely self-evaluating journal papers. We show an example from the Earth Sciences in a package called [`CarboKitten.jl`](https://mindthegap-erc.github.io/CarboKitten.jl), simulating the formation of carbonate reef platforms and their produced limestone stratigraphy. Though the Entangled tool is written in Python, the focus of the talk will be on how Literate Programming in general can help disseminate superior tools like Julia in the Matlab dominated world of geoscience. false https://pretalx.com/juliacon2024/talk/BCKDFL/ https://pretalx.com/juliacon2024/talk/BCKDFL/feedback/ For Loop (3.2) Talk 2024-07-10T14:30:00+02:00 14:30 00:30 FUSE.jl is a framework developed in Julia that integrates first-principle, machine-learning, and reduced models to enable comprehensive self-consistent simulations for fusion power plant design. Multi-objective high performance computing (HPC) optimization is used to identify designs that minimize cost while maximizing several physics, engineering, and control performance metrics. Accessible via a web portal and API, attendees learn about FUSE's and Julia's innovative role in fusion energy. juliacon2024-44418-fuse-jl-the-power-of-julia-for-the-fusion-industry Physics & Quantum Chemistry /media/juliacon2024/submissions/CMT7PR/FUSE_picture_xOUzFCO.png Tim Slendebroek en Delivering fusion energy, with its promise of providing a clean and virtually limitless power source, is one of the most compelling scientific and engineering challenges of our time. Julia has enabled a transformation in integrated modeling for fusion device design from a disconnected multi-language approach to a unified framework called the FUsion Synthesis Engine (FUSE). In this talk we introduce FUSE, a framework developed to support General Atomics’ and others’ fusion power plant designs. FUSE has been developed with the purpose of going beyond traditional low dimensionality methods by integrating first-principle, machine-learning, and reduced models in comprehensive self-consistent simulations. FUSE was developed from the ground up exclusively in Julia, with a focus on computational efficiency and scalability Traditional fusion device design methods start with low-fidelity simplified analytical models to identify an operational point that is then further refined with high-fidelity iterative analyses. This approach inevitably leads to design modifications that are hard to integrate in a unified framework because the design process is slow, costly and only allows for the in-depth study of one design at the time. The fusion community typically relies on loosely-coupled, file-based models from various scales and languages. Transitioning to Julia creates a unified ecosystem, enhancing model and data structure retention in memory. This shift results in a 1000-fold speed increase compared to earlier integrated modeling frameworks. Beyond accelerated simulations, adopting Julia significantly improves maintenance, documentation, testing, and deployment of FUSE. FUSE leverages the ITER IMAS data structure standard to facilitate effective data exchange among its various models. This approach not only enables the framework to be modular, allowing for the execution of models of varying fidelity across a broad range of domains, but also ensures its direct applicability to ITER and numerous other tokamak fusion experiments that have adopted the IMAS standard. One of the most prominent features of FUSE lies in its capability to run both stationary and time-dependent simulations. Dynamics are efficiently modeled by coupling physics models that take into consideration the separation of time and spatial scales that naturally occur in a fusion plasma. Other processes, like the dynamics of the thermal conversion systems, which include a network of heat exchangers, turbines, compressors, and generators, rely on the ModelingToolkit.jl package.   When used for fusion power plant design, a multi-objective optimization approach is utilized to efficiently explore designs that meet the stringent requirements of fusion energy generation but also adhere to economic and practical constraints. This optimization process identifies solutions that strike the best balance between cost and performance, covering the diverse domains of physics, engineering, and control systems. FUSE is currently a proprietary framework and outside of the development team, access to the tool is granted via a web portal and REST API, also written in Julia. This approach eases the barrier to entry for engineers looking to optimize a fusion power plant design, as well as to developers interested in including some of the leading-edge features of FUSE in their own software via its API. Attendees at JuliaCon will delve into FUSE's architecture and understand its practical applications in fusion power plant design via technical demonstrations. The session will also cover how developers and users can leverage and build upon FUSE. false https://pretalx.com/juliacon2024/talk/CMT7PR/ https://pretalx.com/juliacon2024/talk/CMT7PR/feedback/ For Loop (3.2) Talk 2024-07-10T15:00:00+02:00 15:00 00:30 Discover the Julia wrappers for Geant4 simulation, a vital C++ toolkit in particle physics, also used in nuclear and medical physics, and space science. Our focus is on a new, user-friendly interface for developers, improving ergonomics while preserving high performance. Explore the enhanced usability, a great advantage over the intricate C++ interface for occasional users developing custom simulations. Join us to explore Julia's empowering role in streamlining particle physics simulations. juliacon2024-44372-geant4-jl-particle-transport-in-julia Physics & Quantum Chemistry Pere Mato en We present the [Geant4.jl](https://github.com/JuliaHEP/Geant4.jl) package, which provides a wrapper to the [Geant4](https://geant4.web.cern.ch) toolkit for the simulation of the passage of elementary particles through matter, which is widely used in high-energy physics as well as in other domains such as nuclear physics, medical physics, and space science. The toolkit is rather large with several thousands of C++ classes. Given the pivotal role of simulation in contemporary high-energy physics experiments, our focus is on unveiling a new, more user-friendly interface tailored for simulation application developers. This interface not only improves ergonomics but also maintains high computational performance, in particular fully exploiting multi-threading. We emphasise the significant advantages this enhanced toolkit usability provides, particularly when compared to the complexity of the C++ interface that occasional users need to use for their customised simulations. The wrappers are based on [CxxWrap.jl](https://github.com/JuliaInterop/CxxWrap.jl) and they are generated automatically using the [WrapIt](https://github.com/grasph/wrapit) tool. This helps enormously on the sustainability, in particular taking into account the size of the Geant4 project. false GitHub Slides https://pretalx.com/juliacon2024/talk/RGM3GL/ https://pretalx.com/juliacon2024/talk/RGM3GL/feedback/ For Loop (3.2) Lightning talk 2024-07-10T15:40:00+02:00 15:40 00:10 We first present the hydrodynamic equations for lyotropic (concentration-dependent) Liquid Crystals (LCs), derived via the thermodynamic GENERIC framework. Next, we showcase the development of a .jl package to solve these equations, combining 1) finite differences (inspired by DiffEqOperators.jl) and 2) the Lattice Boltzmann method (found in Trixi.jl). Solving in 2D and 3D at equilibrium and under different flows, we demonstrate that our methodology allows the prediction of experimental LC data. juliacon2024-44468-lyotropic-liquid-crystals-thermodynamics-numerical-methods Physics & Quantum Chemistry Pablo ZubietaJonathan Salmerón-Hernández en Experimental data found in active lyotropic Liquid Crystals (LCs), typically a nematic phase coexisting with an isotropic fluid and molecular motors, have displayed complex patterns that remain unexplained. These studies raise questions about the effective parameters transforming such chaotic dynamics into coherent motion. To tackle this challenging problem, we use the GENERIC framework to construct a thermodynamically consistent model. In this framework, the time-evolution equations of out-of-equilibrium systems are naturally described by the sum of energy and entropy contributions. With this, we systematically formulate a set of equations, describing the behavior of concentration-dependent (lyotropic) LCs. We solved our equations by using a hybrid lattice Boltzmann code written in Julia that combines 1) finite differences (inspired by DiffEqOperators.jl) and 2) the Lattice Boltzmann method (found in Trixi.jl); the time evolution is integrated using DifferentialEquations.jl. We show that, in 2D, two passive isotropic droplets within a nematic environment can form stable defect cores with topological charges of +1/2 and -1/2, as observed in chromonic LC data. In 3D, the simulations predict the evolution of an axial droplet configuration, as seen in experiments with surfactants. Additionally, we numerically study the effect of our solutions under different type of flows (passive or active). Our findings demonstrate that experimental results can be quantitatively predicted by the proposed GENERIC equations and by this numerical approach. false https://pretalx.com/juliacon2024/talk/QU3SPL/ https://pretalx.com/juliacon2024/talk/QU3SPL/feedback/ For Loop (3.2) Lightning talk 2024-07-10T15:50:00+02:00 15:50 00:10 Employing a tree-based Cartesian mesh, our project presents a distributed parallel solver for kinetic equations, focusing on multi-scale complex flow across a wide range of regimes. juliacon2024-42902-efficient-composable-solver-for-non-equilibrium-flows Physics & Quantum Chemistry Longqing GeTianbai Xiao en As a physical field can exhibit significant inhomogeneity in space and time, a static mesh may lead to computational inefficiencies or inaccurate numerical results. Adaptive Mesh Refinement (AMR) addresses this challenge by redistributing computational resources based on the evolving features of the solution, resulting in a balance between efficiency and accuracy. Besides, the tree-based Cartesian enables a versatile description of boundaries of the computational domain and discontinuous solutions therein[1]. The ongoing project focuses on the numerical solution of kinetic equations. The high concentration of solution and the associated steep slopes highlight the necessity of adaptive discretization[2]. Based on P4est.jl[3] and MPI.jl[4], we develop the distributed quadtree/octree-based solver for multi-scale complex flows across a wide range of regimes. The lightning talk will first introduce the theoretical underpinnings and then showcase the applicability of the solver through comprehensive benchmarks. The pros and cons of the implementation using Julia will be discussed. References [1] Wang, Zhi Jian. “A Quadtree-based adaptive Cartesian/Quad grid flow solver for Navier-Stokes equations.” Computers & Fluids 27 (1998): 529-549. [2] Chen, Songze et al. “A unified gas kinetic scheme with moving mesh and velocity space adaptation.” J. Comput. Phys. 231 (2012): 6643-6664. [3] J. Lampert, M. Schlottke-Lakemper, H. Ranocha. https://github.com/trixi-framework/P4est.jl [4] Byrne, Simon, Lucas C. Wilcox, and Valentin Churavy. "MPI. jl: Julia bindings for the Message Passing Interface." Proceedings of the JuliaCon Conferences. Vol. 1. No. 1. 2021. false GitHub https://pretalx.com/juliacon2024/talk/A88DR9/ https://pretalx.com/juliacon2024/talk/A88DR9/feedback/ For Loop (3.2) Talk 2024-07-10T16:00:00+02:00 16:00 00:30 Jets in high energy physics are sprays of particles resulting from one parent particle produced in a collision at colliders. Clustering the energy deposits of these final particles is vital for reconstructing the properties of the original parent. We present a new Julia package, `JetReconstruction.jl`, which does just that. We discuss the performance compared to existing solutions, particularly in C++, and demonstrate the ergonomics and extensibility we have achieved in Julia. juliacon2024-44373-jet-reconstruction-in-julia Physics & Quantum Chemistry Graeme A Stewart en Jet physics is one of the key areas where we can advance our knowledge of the interactions of fundamental particles. In collider physics, e.g., at CERN's Large Hadron Collider, two beams of counter-rotating energetic particles are impacted head on. This results in the production of new, highly energetic, heavy particles, which are unstable. These decay rapidly into other particles, forming a cascade of many final state stable particles. These particles are detected in high energy physics experiments, particularly in calorimeters, designed to stop and measure the energy of incident particles. The task of grouping these energy deposits is one of the key tasks in high-energy physics event reconstruction. Jets are formed from clustering energy deposits, based on different momentum and geometric criteria. Various desirable properties are stability against small amounts of additional energy (infrared safety) or against a single input splitting into two aligned deposits (collinear safety). As a mature area of study, there is a well known "standard" C++ package, FastJet, which is widely used. However, as Julia becomes more popular in the field, doing reconstruction natively in Julia is desirable. To this end, we have developed the [`JetReconstruction.jl`](https://github.com/JuliaHEP/JetReconstruction.jl) package, with the aim of offering performant and ergonomic interfaces to the problem. We describe the algorithms implemented in the package, including Anti-kT, Cambridge-Achen and Inclusive-kT as well as various pruning and cleaning options. We compare its feature set and performance with FastJet and discuss its potential evolution to become a more general clustering tool. false GitHub Talk (PDF) Reconstruction Animation https://pretalx.com/juliacon2024/talk/LJMZ9W/ https://pretalx.com/juliacon2024/talk/LJMZ9W/feedback/ For Loop (3.2) Talk 2024-07-10T17:00:00+02:00 17:00 00:30 We introduce [FastIce.jl](https://github.com/PTsolvers/FastIce.jl), a novel ice flow model for massively parallel architectures, written in Julia. Leveraging GPUs (Nvidia, AMD) and supporting distributed computing through MPI.jl, FastIce.jl includes a thermo-mechanically coupled Full-Stokes ice flow model. We present the performance testing of FastIce.jl in single-node and distributed scaling benchmarks on LUMI, the largest European supercomputer. juliacon2024-44383-fastice-jl-a-massively-parallel-ice-flow-model-running-on-gpus Accelerated & large-scale computing Ludovic RässSamuel OmlinMauro WerderIvan Utkin en Efficient modeling of ice sheets involves considering multiple coupled physical processes, including thermo-mechanical interactions. While using a Full-Stokes model to resolve ice flow in Greenland and Antarctica provides most accurate results, it can be cost-prohibitive on a large scale with existing software, necessitating the use of high-performance computing (HPC). We introduce [FastIce.jl](https://github.com/PTsolvers/FastIce.jl), a novel ice flow model for massively parallel architectures, written in Julia. Leveraging GPUs (Nvidia, AMD) and supporting distributed computing through [MPI.jl](https://github.com/JuliaParallel/MPI.jl), [FastIce.jl](https://github.com/PTsolvers/FastIce.jl) includes a thermo-mechanically coupled Stokes ice flow model. [FastIce.jl](https://github.com/PTsolvers/FastIce.jl) is written to be easily extensible, and its core is fully differentiable, enabling data assimilation pipelines using adjoint sensitivities and automatic differentiation (AD). In this talk, we present the modular architecture of [FastIce.jl](https://github.com/PTsolvers/FastIce.jl), consisting of core library of components, and monolithic solvers implementing ice flow models. The core library aims to simplify the development of the numerical algorithms on structured grids, and includes functions and data types for working with computational grids, fields, boundary conditions, and discrete differential operators. The solvers build upon the core library and include the computational kernels to integrate the equations of ice motion. We describe our usage of task-based programming in Julia to simplify synchronisation between concurrently running GPU kernels, CPU functions, and MPI communication. We present the performance testing of [FastIce.jl](https://github.com/PTsolvers/FastIce.jl) in single-node and distributed scaling benchmarks on LUMI, the largest European supercomputer. false https://pretalx.com/juliacon2024/talk/VHFAQ8/ https://pretalx.com/juliacon2024/talk/VHFAQ8/feedback/ For Loop (3.2) Poster Session 2024-07-10T18:30:00+02:00 18:30 01:30 It's the JuliaCon 2024 poster session! Come by to see the posters, chat with the presenters, and organize into groups for dinner. juliacon2024-52484-poster-session General en It's the JuliaCon 2024 poster session! Come by to see the posters, chat with the presenters, and organize into groups for dinner. false https://pretalx.com/juliacon2024/talk/KSHPRX/ https://pretalx.com/juliacon2024/talk/KSHPRX/feedback/ Function (4.1) Lightning talk 2024-07-10T10:50:00+02:00 10:50 00:10 We present the package DiffPointRasterisation.jl, which aims to provide a differentiable rasterization medthod for point cloud data. The focus of the package is on rasterizing volumetric 3D point cloud data either to 3D voxel grids or to 2-dimensional (raster) images. This enables gradient-based 3D reconstruction algorithms for e.g. electron tomography. juliacon2024-43370-differentiable-point-cloud-rasterisation General Wolfhart Feldmeier en Differentiable rendering is concerned with making the 3D graphics pipeline differentiable. While this is a very broad and hot topic in Computer Graphics and Computer Vision, the focus of the package DiffPointRasterisation.jl is solely on rasterizing volumetric 3D point cloud data either to 3D voxel grids or to 2-dimensional (raster) images. The implementation and interface however are dimension-independent and could also be used for arbitrary-dimensional data. The package provides fast implementations for the forward- (rendering) and backward- (gradient calculation) process both on CPU and on GPU (via CUDA.jl and KernelAbstractions.jl). Gradients/pullbacks are provided via explicit functions for fast allocation-free calculations, but are also integrated into the ChainRules.jl ecosystem for automatic differentiation. We give a quick overview of the package's capabilities and dive into its single-function interface. We briefly show how we use DiffPointRasterisation.jl in the process of tomographic reconstruction from cryo-electron microscopy data, and conclude by discussing how the package fits into Julia's differentiable computing landscape. false https://pretalx.com/juliacon2024/talk/E7KFJX/ https://pretalx.com/juliacon2024/talk/E7KFJX/feedback/ Function (4.1) Talk 2024-07-10T11:00:00+02:00 11:00 00:30 We present TrixiParticles.jl, an open-source numerical simulation framework designed for accessible particle-based multi-physics simulations and implemented in Julia as part of the Trixi Framework. Besides highlighting the high performance and rapid adaptability of Julia in our implementation, we will demonstrate the application of TrixiParticles.jl through multiple examples in the fields of fluid dynamics, mechanics, and multiphysics. juliacon2024-44439-julia-for-particle-based-multiphysics-with-trixiparticles-jl Physics & Quantum Chemistry /media/juliacon2024/submissions/TPFF8L/falling_sphere_UJT8gvS.png Erik FaulhaberNiklas Neher en Our primary goal is to provide a user-friendly application, accessible even to those unfamiliar with particle-based methods. Therefore, TrixiParticles.jl is designed with easy extensibility in mind, enabling researchers to experiment with new models or methods quickly, without the need to study and modify large parts of the code. We further try to achieve optimal performance without significantly impacting readability or ease of use. This approach allows users not only to prototype new ideas rapidly, but also to efficiently scale up simulations. In our talk, we will present examples of applications in fluid dynamics, mechanics, and fluid-structure interactions. We will also showcase how easily our code can be adapted to new models and used in multiphysics simulations. Furthermore, we will provide an overview of current and future features. Feature highlights: - Multiple Smoothed Particle Hydrodynamics (SPH) schemes to model fluids with free surfaces. - SPH model for modelling elastic solids. - Fluid-structure interaction - Quick setup of complex geometries. - User-friendly post-processing false GitHub https://pretalx.com/juliacon2024/talk/TPFF8L/ https://pretalx.com/juliacon2024/talk/TPFF8L/feedback/ Function (4.1) Talk 2024-07-10T11:30:00+02:00 11:30 00:30 CedarEDA is a new advanced analogue circuit simulation tool. This tutorial will go into how to use it to simulate your electronic circuits. CedarEDA is able to process circuits/models described in Spice, Spectre, Verilog-A or in pure Julia. It is API first and is driven entirely via Julia script. This tutorial is primarily of interest to electrical and electronic engineers, or anyone else with an interest in electronic circuit design. juliacon2024-44239-cedareda-tutorial-a-fresh-approach-to-circuit-simulation General Frames Catherine WhiteKeno Fischer en The tutorial will give you everything you need to get up and running using CedarEDA. It will go through step by step how to use CedarEDA. - How to import/define a circuit - How to perform simulations including: - Transient - DC - AC - Noise - How to compute measures of circuit performance such as rise time, delay, etc - How to setup automated verification of measures, and sweep over values (such as transistor sizes, or resistances etc) and verify which ranges of values are acceptable - How to automatically tune your circuit parameters to achieve eg a minimal delay CedarEDA is currently available as an open source project. The tool is currently very usable, but has some rough edges. false Slides (PDF) https://pretalx.com/juliacon2024/talk/DAJ7YT/ https://pretalx.com/juliacon2024/talk/DAJ7YT/feedback/ Function (4.1) Talk 2024-07-10T12:00:00+02:00 12:00 00:30 Lithium-ion battery models are highly nonlinear systems of stiff, partial differential-algebraic equations (PDAEs). It is challenging to robustly solve the system of equations over a range of inputs and parameters – many commercial and open-source battery modeling tools are prone to sporadic failure stemming from issues in setting up, initializing, and solving these systems. This talk discusses these pitfalls and the solutions implemented in the JuliaSimBatteries.jl package. juliacon2024-44409-juliasimbatteries-jl-robust-pde-models-of-lithium-ion-batteries General Sebastian Micluța-Câmpeanu en JuliaSimBatteries is an advanced lithium-ion battery simulation tool integrating sophisticated electrochemical, thermal, and degradation physics. Utilizing the Doyle Fuller Newman (DFN) model, it can predict a battery's entire lifetime with fast charging 150,000 times faster than real time. The number of connected batteries is scalable from one cell to packs of thousands using electrochemical models. Scientific Machine Learning (SciML) enables the discovery of hidden governing laws from data, such as degradation and low-temperature behavior. Characterize material properties and propose battery designs using the parameter estimation and optimization tools in JuliaSim. Building accurate models are essential for understanding, optimizing, and designing batteries. Physically accurate battery models are computationally expensive and difficult to solve robustly. JuliaSimBatteries is more than 100 times faster than other battery modeling tools while solving the same physics, thanks to the speed of the Julia programming language. Bring your battery workflow to the next level to solve challenging problems: - Pack modeling – JuliaSimBatteries is performant and enables the predictive power of electrochemical models for large-scale battery packs. - Uncertainty quantification – Uncertainty is inherent in battery modeling. JuliaSimBatteries helps mitigate and understand the root causes of uncertainty with JuliaSim Model Optimizer. - Fast charging – Built for robust and efficient simulations, even at the extreme operating conditions of fast-charge. - Degradation – Predict battery lifetime and health with SEI capacity fade models. - Discover hidden physics – Combine physics from our battery models and your data to discover hidden governing laws using SciML tools. - Lifetime prediction – Estimate a battery's entire lifetime with fast charging in under a minute with the DFN model. false https://pretalx.com/juliacon2024/talk/QDZFWW/ https://pretalx.com/juliacon2024/talk/QDZFWW/feedback/ Function (4.1) Talk 2024-07-10T14:00:00+02:00 14:00 00:30 With a growing user-base, DMRjulia v1.0 is undergoing its inaugural release. This software package has been in development for a few years and has been used in previous academic publications for computations on tensor networks for strongly correlated quantum problems. We discuss new algorithms that have been developed in the software package and the interface of those access tools with hardware provided on the Digital Research Alliance of Canada. We will cover the documentation available. juliacon2024-43412-introducing-dmrjulia-v1-0 Physics & Quantum Chemistry /media/juliacon2024/submissions/PG8JXT/Screenshot_2024-01-12_at_05.17.34_oVuCMFK.png Thomas E. Baker en Our talk will cover introductory material related to the use of the DMRjulia library that is pending its v1.0 release https://github.com/bakerte/DMRJtensor.jl and include an existing article for beginners: T.E. Baker, S. Desrosiers, M. Tremblay, M.P. Thompson, Méthodes de calcul avec ré́seaux de tenseurs en physique Can. J. Phys. 99, 4 (2021) [(Basic tensor network computations in physics), arxiv: 1911.11566, p. 20] We will debut a full software tutorial for the software and cases where DMRjulia has led to new developments in modelling of quantum systems, including some that will be released around March 2024. Basic design principles that are native to Julia will be discussed with lessons and recommendations. We also hope to contribute back to the core Julia codebase with some improvements that we have identified. Our software was optimised around a specific hardware implementation on the Digital Research Alliance of Canada’s hardware infrastructure. We will debut public interfaces to use these tools and recap lessons learned on the specific implementation of the library on hardware. We used several packages in the Julia ecosystem to accomplish the best interface possible with the best performance. Our software has been optimized to run efficiently in shared memory environments, including high-performance computing clusters. We will demonstrate results and recap lessons learned in improving performance by utilizing parallelism in background libraries and tuning parameters for a given computing environment. The core of the software package is available online under the DMRJtensor package, but the v1.0 release (scheduled for May) and some helper tools (scheduled for June) will be made available concurrent with some ongoing academic research. We will also cover any new developments with these new capabilities and ways in which DMRjulia can be used for scientific results at the cutting edge of research. We are grateful to the US-UK Fulbright Commission for financial support and being hosted by the University of York. This research was undertaken in part thanks to funding from the Bureau of Education and Cultural Affairs from the United States Department of State. T.E.B. graciously thanks funding provided by the postdoctoral fellowship from Institut quantique. This research was undertaken thanks in part to funding from the Canada First Research Excellence Fund (CFREF). This research was undertaken, in part, thanks to funding from the Canada Research Chairs Program. The Chair position in the area of Quantum Computing for Modelling of Molecules and Materials is hosted by the Departments of Physics & Astronomy and of Chemistry at the University of Victoria. This work has been supported in part by the Natural Sciences and Engineering Research Council of Canada (NSERC) under grants RGPIN-2023-05510 and DGECR-2023-00026. This work is supported in part with support from the University of Victoria's start-up grant from the Faculty of Science. This research was enabled in part by support provided by Research Computing Services at the University of Victoria as well as the Digital Research Alliance of Canada (alliance​can​.ca). false GitHub https://pretalx.com/juliacon2024/talk/PG8JXT/ https://pretalx.com/juliacon2024/talk/PG8JXT/feedback/ Function (4.1) Minisymposium 2024-07-10T14:30:00+02:00 14:30 00:05 Julia's elegance and speed lends itself to applications in scientific computing that requires a strong scientific data ecosystem. Building upon prior successful minisymposia on tabular data, the Scientific Data minisymposium will extend the scope to dealing with annotated, hiearchical, and n-dimensional data. Additionally, the symposium will invite talks on processing large datasets using advanced chunking techniques, distribution of big data via cloud computing and data formats. juliacon2024-41434-scientific-data-minisymposium Scientific Data Minisymposium Mark Kittisopikul, Ph.D.Fabian Gans en A robust scientific data ecosystem is critical to Julia's applications in scientific computing. The ability to handle scientific data interchange allows Julia to interoperate with existing scientific projects which may be using code in other languages such as MATLAB, Python, C, C++, or Rust. Prior minisymposia on data have emphasized the use of Julia with tabular data in CSV files or web friendly data formats such as JSON. Julia's strong support for tabular data and JSON provide a strong foundation to build upon. Scientific data also extends into n-dimensional arrays with dimensions describing space, time, and other parameters such as wavelength that may not be well served these data formats. These datasets are organized into nested hiearchial groups and are annotated with standardized regular vocabulary. Potential topics for the scientific data minisymposium are as follows. 1. Advanced input and output APIs for scientific data. This includes HPC interfaces such as Message Passing Interface (MPI), cloud data APIs, and interfaces with databases. 2. Data formats for scientific data interchange. Discussion of data formats such as HDF5, NetCDF, FITS, Zarr, ADIOS2, and ASDF or their incoporation into data schemes such as scverse would be welcome. 3. Data exchange between threads and (distributed) processes. This especially includes techniques that transfers data while retaining annotations and context. 4. The implementation of abstract interfaces over similar data interfaces. For example, implementing a general n-dimensional chunk based interface supporting multiple data formats. false https://pretalx.com/juliacon2024/talk/EDU9LS/ https://pretalx.com/juliacon2024/talk/EDU9LS/feedback/ Function (4.1) Talk 2024-07-10T14:35:00+02:00 14:35 00:30 DiskArrays.jl provides the AbstractDiskArray interface for chunked and compressed n-dimensional arrays with slow random access. Implementing the interface gives access to a wide set of indexing, views, reductions and broadcasting. Downstream packages can optimize parallel operations on these chunked arrays using the AbstractDiskArray interface. juliacon2024-43424-diskarrays-jl-for-working-with-large-disk-based-nd-arrays Scientific Data Minisymposium Felix CremerFabian Gans en Scientific data formats like NetCDF, HDF5 or Zarr allow storing large array data on local or network drives or in the cloud. Julia packages for these data types provide custom getindex/setindex methods on datastructures that map to an array on disk. However, implementing the full AbstractArray interface has proven to be difficult, since the interface is based on the assumption of efficient access to single array elements. In many cases data are internally stored in compressed chunks, so that a naive implementation of the AbstractArray interface would lead to very poor performance for many IO operations. DiskArrays.jl provides the AbstractDiskArray interface, for which backends only have to implement methods to read and write dense hyperrectanglular subsets of the array for their data type. In addition to read/write support an interface for querying the internal chunking structure of the disk-based array is provided by DiskArrays.jl to simplify the implementation of efficient mapreduce and broadcast operations on these arrays. Downstream packages can work with diskarrays to define chunk-based computations in a backend-agnostic way and we present an overview of how downstream packages like Rasters.jl, YAXArrays.jl or DiskArrayEngine.jl provide efficient and user-friendly ways to perform operations on larger-than memory compressed arrays. false Presentation link Github Presentation https://pretalx.com/juliacon2024/talk/DWTEVS/ https://pretalx.com/juliacon2024/talk/DWTEVS/feedback/ Function (4.1) Lightning talk 2024-07-10T15:05:00+02:00 15:05 00:10 PyramidScheme.jl is a package to easily and efficiently compute pyramids of an array which might be larger than RAM. PyramidScheme.jl provides the Pyramid struct to handle the layers of a pyramid. A pyramid is a collection of subarrays of a larger array so that every layer is half the size in every dimension so that pixels are combined to get to the next level of the pyramid. These different layers allow to lazily give an overview of the data without having to load the whole array into memory. juliacon2024-44375-pyramidscheme-jl-overviews-for-larger-than-memory-arrays Scientific Data Minisymposium Felix CremerFabian Gans en PyramidScheme.jl allows to efficiently compute these Pyramids and to interactively plot them with the Makie.jl ecosystem. PyramidScheme.jl is based on the DiskArrays.jl for the handling of larger than memory arrays and on DiskArrayEngine.jl for the computations on these arrays. In the future, we plan to be able to lazily define computations on DiskArrays so that these computations are only applied to the pixels that are currently used in the interactive plot. In this talk we will show how to use PyramidScheme.jl to easily and efficiently compute the Pyramids from a given DiskArray and how to then interactively plot these Pyramids using Makie.jl. false Github https://pretalx.com/juliacon2024/talk/HYTKA3/ https://pretalx.com/juliacon2024/talk/HYTKA3/feedback/ Function (4.1) Lightning talk 2024-07-10T15:15:00+02:00 15:15 00:10 Often our datasets represent physical space, time or named categories organized along some dimensions. Accessing data by these dimensions and values keeps us focused on the content, rather than how it is stored. DimensionalData.jl facilitates these workflows, with a focus on spatial data, abstractions for other packages to extend, and automated plotting. juliacon2024-43135-dimensionaldata-jl-named-dimensions-for-julia-data Scientific Data Minisymposium Rafael Schouten en DimensionalData.jl is not the first or only package to define arrays and datasets with named dimensions and lookups in julia - AxisArrays.jl, AxisKeys.jl, NamedDims.jl all succeed in this space. But DD is unique in its focus on extensibility, and has spawned many objects inheriting its behaviors, largely across spatial sciences, such as in Rasters.jl, YAXArrays.jl and ClimateBase.jl. It's also generic enough to find uses in statistics, machine learning and image processing. Another focus driven by its spatial use-cases is on being able to accurately represent a wide rang of lookup values and behaviors: - Points or Intervals - Regular or Irregular - Ordered or Unordered - Sampled or Categorical - Linear or Cyclic - grid-aligned or with transformed coordinates This means it can represent the wide variety of CF compliant netcdf files, as well as affine transformed coordinates and projections of GDAL. DD also shines in ease of plotting, with extensive Plots.jl and Makie.jl recipes that automatically put the right values and labels in the right places. This talk will demonstrate the basics of both how to use DimensionalData.jl, and for package developers - how to extend it. false https://pretalx.com/juliacon2024/talk/WPAKG8/ https://pretalx.com/juliacon2024/talk/WPAKG8/feedback/ Function (4.1) Lightning talk 2024-07-10T15:40:00+02:00 15:40 00:10 Rasters.jl extends DimensionalData.jl for working with geospatial rasters. It abstracts over many kinds of multi-dimensional arrays stored in memory, on disk or in the cloud - from sources like GDAL and netcdf, to present spatial raster data as regular julia `AbstractArray`s, but facilitate easy spatially aware indexing, manipulation, plotting and writing. This talk will cover basic workflows and features for raster data manipulation with Rasters.jl. juliacon2024-44415-rasters-jl-raster-data-and-gis-tools-for-julia Scientific Data Minisymposium Rafael Schouten en Rasters.lj adds missing-value handling, tracking of coordinate reference system (crs), lazy operations on larger-than-memory arrays using DiskArrays.jl, and ability to select and plot rasters with rotated or skewed coordinates - to a base of named dimension indexing from DimensionalData.jl. Scripts and packages built on Rasters.jl can treat Raster, RasterStack, and RasterSeries as black boxes. They may hold unopened GeoTiff or NetCDF filenames or urls, Arrays in memory, or CuArrays on the GPU - but they will all behave in essentially the same way - allowing spatial indexing, manipulation and plotting. Rasters.jl also provides a range of common GIS tools for raster manipulation: `aggregate: aggregate data by the same or different amounts for each axis. `mosaic`: join rasters covering different extents into a single array or file. `crop`: shrink objects to specific dimension sizes or the extent of another object. `extend`: extend objects to specific dimension sizes or the extent of another object. `trim`: trims areas of missing values for arrays and across stack layers. `resample`: resample data to a different size and projection, or snap to another object. `rasterize`: rasterize GeoInterface compatible points and geometries. `extract`: extract values from points or geometries. `zonal`: calculate zonal statistics for an object masked by geometries. `mask`: mask an object by a polygon or Raster along X/Y, or other dimensions. While less mature than similar packages in R or python, Rasters.jl already has many ease of use and performance advantages. Operations like rasterization and masking are written in native Julia, so they are fast and work on geometry objects sourced from any packages that implement the GeoInteraface.jl interface. DiskArrays integration means views, permutations, reductions and broadcasts can be performed over larger-than-memory arrays, only being applied when `getindex` is finally called for a specific region. Despite the additional behaviours and geospatial metadata they hold, `Raster` objects are also just regular `AbstractArray`s with standard `Array` behavior. They work with most base methods, and across much of the Julia ecosystem. In most cases they retain their spatial metadata and the ability to be indexed by name, spatial coordinates, time or any other dimensions they may have, and will always plot appropriately in Plots.jl or Makie.jl. false https://pretalx.com/juliacon2024/talk/A8GMVV/ https://pretalx.com/juliacon2024/talk/A8GMVV/feedback/ Function (4.1) Talk 2024-07-10T15:50:00+02:00 15:50 00:30 I will discuss efficient chunk access in HDF5, Zarr shards, and TIFF tiles juliacon2024-53260-efficient-chunk-access-across-hdf5-zarr-and-tiff Scientific Data Minisymposium Mark Kittisopikul, Ph.D. en I will discuss efficient chunk access in HDF5, Zarr shards, and TIFF tiles. This will include recent features added in HDF5.jl and potential hackathon projects. false https://pretalx.com/juliacon2024/talk/BDTQCG/ https://pretalx.com/juliacon2024/talk/BDTQCG/feedback/ Function (4.1) Lightning talk 2024-07-10T16:30:00+02:00 16:30 00:10 We present `KSVD.jl`, an extremely fast implementation of the K-SVD algorithm, including extensive single-core optimizations, shared-state multithreading, pipelined GPU offloading, and an optional distributed executor. With this implementation, we are able to outperform existing numpy-based implementations by ~100x and scale to datasets with millions of samples. juliacon2024-44481-ksvd-jl-a-case-study-in-performance-optimization Scientific Data Minisymposium Romeo Valentin en The K-SVD algorithm has gained recent attention in the application of dictionary learning for large-scale transformer models, see e.g. Bricken 2023. However, as it stands, it has been deemed computationally infeasible when applied to large datasets with millions (or billions) of samples. And indeed, current implementations seem not up to the task; the implementation available as `sklearn.decompositions.MiniBatchDictionaryLearning`, which extensively leverages `numpy` and `joblib`, takes over 3 minutes for ten iterations on a dataset with ten thousand elements (despite multi-threading). For this reason, we present [`KSVD.jl`](https://github.com/RomeoV/KSVD.jl), an implementation of the K-SVD algorithm in Julia. This implementation outperforms sklearn&rsquo;s implementation by about $50\times$ when computing the same problem, can gain an additional $2\times$ by reducing the precision from `Float64` to `Float32`, and can be scaled across many compute nodes with almost linear speedup improvements. That means if, for example, eight compute nodes are available, we can expect a speedup of $(50 \cdot 2 \cdot 8)\times = 800\times$ for moderate to large datasets. Further, `KSVD.jl` also employs several algorithmic modifications that, to the author&rsquo;s knowledge, lead to faster convergence given the same number of compute operations. In this presentation, we will present a breakdown of the optimizations and their effects, as well as guidance on the performance optimization workflow in Julia. In particular we will treat the K-SVD algorithm as a case-study to discuss several different aspects of performance optimization and their applicability in Julia. Specifically, this will include - careful adjustments to the execution order and small algorithmic adjustments, - single-core optimizations like aggressive buffer preallocations, exploiting cache locality, improving the memory layout, and reducing memory movements, - careful multi-threading using small batch updates with frequent cross-communication implemented with Julia&rsquo;s efficient task scheduling, - a custom multi-threaded dense-sparse matrix multiplication implementation ([`ThreadedDenseSparseMul.jl`](https://github.com/RomeoV/ThreadedDenseSparseMul.jl)), - pipelined GPU-offloading for large matrix multiplications (currently unused in the fastest version), - a custom distributed executor allowing to spread the computation over many compute nodes. We hope that the insights we can share will empower others to improve and optimize their code when applicable, and provide some guidelines about the step-by-step breakdown of the process. The package is available at <https://github.com/RomeoV/KSVD.jl>. false The prezzy 😎 https://pretalx.com/juliacon2024/talk/V8VGK9/ https://pretalx.com/juliacon2024/talk/V8VGK9/feedback/ Function (4.1) Lightning talk 2024-07-10T16:50:00+02:00 16:50 00:10 A study of a case of Julia's use for data analysis in the nuclear physics field will be presented. Binary data, coming from a nuclear fusion-fission reaction study, including signals from about 200 detectors, amounted to 20-30 TB. Julia's capability of seamless calling C-libraries, multi-processing schemes and efficient data processing allowed us to analyze this dataset with an ordinary off-the-shelf computer in a reasonable time, without the need to employ HPC. juliacon2024-43470-julia-s-use-in-nuclear-physics-data-analysis-study-of-a-case Scientific Data Minisymposium Krzysztof Miernik en In the field of physics, it is high-energy particle physics that is commonly associated with top high-performance computing. CERN and LHC are one of the staple marks of this branch. But high performance is needed in other areas as well and is not limited to supercomputers only. The older brother of particle physics, nuclear physics, takes advantage of recent developments as well. If we take a look at state-of-the-art computers of the mid 90's today's laptops have similar computational performance. What needed a whole cluster of computers 30 years ago, now can be achieved with a single cheap machine. This, along with the development of detectors, detector setups and acquisition systems, allows for planning larger experiments, while keeping the similar size of scientific groups counting from a few persons up to tens. But there is a catch here: the programming of the HPC machines is and was performed by whole devoted teams. In the nuclear physics field, often the whole data analysis is done by a single scientist or a very small group. Nevertheless, the needs are similar, including, first of all, a programming language capable of fast data processing to analyze relatively large volumes of data. On the other hand, another set of tools is needed for the data analysis, including common operations like plotting, histogramming, fitting, or data manipulation. And this is very often, accomplished in an exploratory data analysis approach, where the final method or expected results are not clearly stated. The typical way to achieve that is to use two languages, one for efficient data processing (C/C++), and preliminary analysis, and the second for convenient, dynamic analysis and visualization (Python or specialized programs). Julia ideally fits into this scheme with its high performance, while keeping dynamic and simplicity, effectively removing the need to master two languages. In a one-person analysis scenario, this is especially welcome. An important feature, needed to unlock the full potential of the modern, multi-core machines, and accomplish efficient data processing, are easily accessible multi-processing capabilities present in Julia. The whole analysis code can be consistently written in one language, from the raw file interpretation to the publication figures, which makes it easy to maintain, reuse and train new members of the group. false Presentation https://pretalx.com/juliacon2024/talk/7LYF7W/ https://pretalx.com/juliacon2024/talk/7LYF7W/feedback/ Function (4.1) Talk 2024-07-10T17:00:00+02:00 17:00 00:30 We present the foundational package for handling High-energy physics (HEP) data stored in .root files, which will enable physicists to use Julia for physics tasks in HEP. Traditionally, HEP software consists of mostly C++ since 2000s, but as the analysis computation becomes more complex, the two-language problem in the physics data analysis grows wider. UnROOT.jl improves quality of life by providing performant reading & writing to support fast "for-loop" style data analysis with ease. juliacon2024-44172-unroot-jl-data-i-o-for-high-energy-physics-in-julia Scientific Data Minisymposium Jerry Ling en We present package that is at the core of high-performance high-energy physics data analysis, UnROOT.jl, a pure Julia ROOT file I/O package that is optimized for speed and ergonomics that can solve the two-language problem in High-energy physics data analysis. We discuss what affects performance in Julia, the challenges, and their solutions during the development of UnROOT.jl. We highlight type stability as a challenge and discuss its implication whenever any “compilation” happens (incl. Numba, Jax, C++) as well as Julia’s specific ones. We also highlight the our quick adoption of the upcoming RNTuple file format/specification in ROOT and ease of implementation in Julia, including reading and writing, that will enable physicists to drop-in Julia to replace any part of a traditional data pipeline. Finally, demonstrate the performance and “easy to use” claim by comparing UnROOT.jl against popular alternatives (RDataFrame, Uproot, etc.) in medium-size realistic benchmarks, comparing both performance and code complexity. false GitHub repo UnROOT.jl Talk slides https://pretalx.com/juliacon2024/talk/RXG3W3/ https://pretalx.com/juliacon2024/talk/RXG3W3/feedback/ Function (4.1) Poster 2024-07-10T18:30:00+02:00 18:30 00:30 With an ever-increasing complexity in supercapacitors’ structure, it has become that much harder to find a feasible circuit model which could and should aid in the physical modelling of a supercapacitor towards a better understanding of the physical processes involved in its electrical behaviour. This work proposes a different method of finding a circuit model for a porous Si-based supercapacitor using ModelingToolkit.jl and DifferentialEquations.jl. juliacon2024-44410-circuit-model-discovery-for-porous-silicon-based-supercapacitors Posters Irina-Nicoleta Bratosin en Supercapacitors have been gaining more attention in the past few decades due to their potential of replacing batteries as the main portable energy storage device and while many breakthroughs have been made in this particular department, there is still an aspect to it that is most often brushed aside, the circuit modelling. Although it is true that performing circuit modelling on a supercapacitor would be a useful tool towards a better understanding of its complex processes that contribute to charge transfer and storage, it is also true that finding the said model is a daunting task. As a consequence, most circuit modelling for a supercapacitor is often made through making an array of assumptions and brute forcing the process until a mathematical equivalent, of which there’s an infinity, rather than a physical equivalent is found. From Occam’s razor, a philosophical principle, to infinite RC ladders, a valid, yet brute force method, it has become apparent that in order for the supercapacitor science to evolve, a better model discovery strategy is needed to constrain the space of possible circuit variants. This work proposes using Julia’s arsenal of modelling tools on supercapacitor data, specifically electrochemical impedance spectroscopy and cyclic voltammetry, towards finding a circuit model directly derived from said data. The main principle of this modelling strategy consists in starting with an RC circuit configuration and updating on it as more information from the data is introduced, so rather than coming up with an infinite RC ladder circuit, the exact configuration of specific resistances and capacitances will be discovered from the information offered by Nyquist, Bode and CV (cyclic voltammetry) graphs. false https://pretalx.com/juliacon2024/talk/7KHQUU/ https://pretalx.com/juliacon2024/talk/7KHQUU/feedback/ Function (4.1) Poster 2024-07-10T19:00:00+02:00 19:00 00:30 The poster studies the optimal distributed architecture to run simulations with Julia-based models in the field of Systems Biology. Julia parallel framework of distributing the code across remote workers is applied to different cluster configurations: managed by HTCondor and Kubernetes through Julia interfaces ClusterManagers.jl and K8ClusterManagers.jl. The poster summarizes InSysBio experience and presents pros and cons of building such computational environment for modeling and simulations. juliacon2024-44263-a-computational-environment-for-simulations-in-systems-biology Posters Ivan Borisov en One of the main computational challenges of Systems Biology and Quantitative Systems Pharmacology is solving large differential equation systems with thousands sets of input parameters. The task becomes even more challenging when multiple therapies and clinical conditions are being modeled. The software and hardware environment to address this problem and speed-up the simulations is of utmost importance for the field. The poster proposes several approaches to address this problem in Julia. Julia ability to easily parallelize the computations and distribute workloads across workers is applied to the following architectures: 1. On-site distributed computational environment managed by HTCondor through ClusterManagers.jl interface. 2. Extension of the local computational resources by adding cloud based compute nodes. 3. Fully cloud-based environment managed by Kubernetes through K8ClusterManager.jl package. The advantages and limitations of the studied approaches are presented in the poster. false https://pretalx.com/juliacon2024/talk/UQWX7N/ https://pretalx.com/juliacon2024/talk/UQWX7N/feedback/ Function (4.1) Poster 2024-07-10T19:30:00+02:00 19:30 00:30 We introduce PlantModules.jl, a package for modeling plant hydraulics in a modular way. Its purpose is to allow the user to define, run and visualize plant models based on an input structure of any desired complexity and scale, from cell to fields of plants. Its base functionality allows for the simulation of water flows based on water potentials in a tree with hundreds of branches in just a few dozen lines of code, and a focus on extensibility allows for easily adding other processes. juliacon2024-44334-plantmodules-jl-a-package-for-modular-plant-growth-modeling Posters Bram Spanoghe en A rising world population and changing environmental conditions have created a need for an increasing food supply using the same amount of agricultural area and under often more difficult growing conditions. A better understanding of plant growth has become essential in achieving this, allowing, among others, the targeted breeding of plants with greater resistance to these changing conditions. Plant models, in turn, have become an indispensable tool for steering plant growth. The state-of-the-art in plant modeling are Functional-Structural Plant Models (FSPMs). These models consider both functional processes such as photosynthesis, water flow, and carbon allocation, as well as the structure of the plant, usually represented as a network of repeating elementary units such as leaves, root segments, or cells. Our package is intended to serve as an addition to the FSPM modeling framework in Julia. Among these, the Virtual Plant Laboratory is a notable collection of FSPM-related Julia packages and already includes a wide range of functionalities, such as graph rewriting for simulating the growth of the structure of a plant through time, visualization functions, and models for calculating certain plant biophysical processes given the weather conditions. What is not yet available is a way to accurately model functional processes over time using sets of differential equations. This package provides this functionality by interfacing with Julia's modeling ecosystem, specifically ModelingToolkit.jl (MTK). As this package aims to maximize ease of extensibility, the intuitive syntax of this modeling package is ideal as it allows users to easily implement their own functional processes as MTK systems and provide high-performance models. Writing out a FSPM in this modeling language by hand would be incredibly time-consuming, since it can consist of over thousands of elementary units that all need to be created and connected. PlantModules.jl automates this process, allowing for modeling plants whose structure consists of many elements or even changes over time. The final contribution of the package is the inclusion of a simple, yet powerful implementation of hydraulics as a functional process. It describes the growth of plant parts due to turgor pressure, which results from water flows in the plant driven by water potentials. This process is often overlooked in favor of carbon-related processes, yet it is also an essential driver of growth and is easily coupled to carbon models. Another advantage of the provided hydraulics implementation is that it works on all spatial scales and can be used in multi-scale models. This type of model, which simulates a system on multiple spatial scales simultaneously, can be very advantageous for modeling plant growth and is also supported by the package. false https://pretalx.com/juliacon2024/talk/R8VRMH/ https://pretalx.com/juliacon2024/talk/R8VRMH/feedback/ While Loop (4.2) Lightning talk 2024-07-10T10:50:00+02:00 10:50 00:10 PiecewiseInference.jl is a novel inverse modelling framework specifically designed for the inference of parameters in large, nonlinear differential equation using time series data. It is based on a segmentation method together with minibatching. We briefly discuss its building blocks and demonstrate its performance with large ecosystem models. PiecewiseInference.jl is a user-friendly package that significantly simplifies the inference of parameters in complex dynamical models. juliacon2024-43562-piecewiseinference-jl-inverse-modelling-for-complex-dynamics General Victor Boussange en The inference of parameters in large, nonlinear differential equation models using time series data poses significant challenges. Bayesian methods, that infer the full posterior probability distribution of the unknown parameters, are computationally expensive and particularly prone to the curse of dimensionality. Alternatively, local-search methods based on variational optimizers are efficient but tend to converge to local minima. Here, we introduce PiecewiseInference.jl, an inverse modelling framework specifically designed for the inference of parameters in large, nonlinear differential equation using time series data. PiecewiseInference.jl improves the convergence of local-search methods by implementing a segmentation method and parameter constraints, which are used in combination with minibatching. By partitioning time-series data into shorter segments, the framework effectively regularizes the loss function, mitigating issues arising from the nonlinearities. The implementation of parameter constraints ensures that both model parameters and initial conditions remain within scientifically and numerically valid ranges, a critical aspect for the successful application of variational optimizers in inverse modeling problems. Furthermore, the use of minibatching in PiecewiseInference.jl mitigates overfitting while reducing memory pressure. We briefly discuss the building blocks of PiecewiseInference.jl and demonstrate its performance on simulated food-web dynamics of increasing complexity. PiecewiseInference.jl is a user-friendly package that significantly simplifies the inference of parameters in complex dynamical models. Its ability to integrate data into complex scientific models enables their systematic testing and continuous development, making it a valuable asset for modelers in various fields. false GitHub Slides https://pretalx.com/juliacon2024/talk/R3HRGW/ https://pretalx.com/juliacon2024/talk/R3HRGW/feedback/ While Loop (4.2) Talk 2024-07-10T11:00:00+02:00 11:00 00:30 By design Julia was designed to be familiar for people coming from MATLAB or python. This is great to attract people, however we need guardrails for people that want to develop performant packages. This will be a series of examples of code from colleagues, how to make them more Julian and a proposal for the language to help these newcomers to write fast and extensible code. juliacon2024-44165-newcomers-experiences-why-do-we-need-a-stricter-julia-mode Community Jorge Alberto Vieyra Salas en People coming from MATLAB and python might find the julia language sort of familiar at first glance, but will not take long until they stumble upon problems stemming from bad habits coming from these other programming languages. One example of this is this recent talk from JuliaCon Local Eindhoven https://youtu.be/RUJFd-rEa0k?si=X4FHouP7ne4Ocv4U These bad habits are not exclusive of people coming from interpreted languages, but also from C and Java because people tend to over-restrict their code. Sometimes both people struggle with the type system because they are not use to it and need better guardrails in order to avoid problems. On top of the survey I will propose a few ideas to change the tools and/or the language to help new people coming to julia either seasons developers or newbies. false https://pretalx.com/juliacon2024/talk/BSKBUG/ https://pretalx.com/juliacon2024/talk/BSKBUG/feedback/ While Loop (4.2) Talk 2024-07-10T11:30:00+02:00 11:30 00:30 Julia-Powered Computerized Cognitive Rehabilitation for Children Cognitive Rehabilitation Therapy refers to set of treatments that help improve a child’s ability to think after a brain injury or illness that affects the brain that aim to improve a child's ability to perform a certain cognitive tasks by retraining previously learned skills and teaching compensatory strategies after overcoming a certain Brain injury or disability. juliacon2024-44249-julia-powered-computerized-cognitive-rehabilitation-for-children General Aditi Raviraj BurseRadhika Shidling Bhangi en As it is important , many Children suffer from brain disabilities and after getting over it , are getting difficulty in performing their cognitive functions in their Schools or any of the environment they are present into. Which would surely affect their lives. The purpose of this study was to understand Children are not able to perform their cognitive functions like Attention, Memory, Language, Social Recognition, Perception & Thinking using Julia Packages. For the above study we need data from various sources. This data includes child’s memory dataset , Attention span datasets, Language skills datasets, IQ level test dataset, problem-solving datasets etc . We had collected data from various sources and implemented using Julia Packages such as DataFrames.jl which will tabulate our data, MLJ.jl to make predictions on our data and PyPlot.jl to plot the results and the other metrics. OUTLINE: Introduction to Cognitive Rehabilitation (2minutes) Importance of Cognitive Functions in Children (2minutes) Julia for Cognitive analytics (2minutes) Approaches and models for Cognitive Rehabilitation(7minutes) Demonstrating a basic forecasting model (5minutes) Results and Discussions (5minutes) Conclusion (2minutes) Question and Answer (5minutes) false https://pretalx.com/juliacon2024/talk/MG8LZV/ https://pretalx.com/juliacon2024/talk/MG8LZV/feedback/ While Loop (4.2) Talk 2024-07-10T12:00:00+02:00 12:00 00:30 The goal of MacroModelling.jl is to reduce coding time and speed up model development by providing functions for working with discrete-time DSGE models. These kinds of models describe the behavior of a macroeconomy and are particularly suited for counterfactual analysis (economic policy evaluation) and exploring / quantifying specific mechanisms (academic research). Due to the complexity of these models, efficient numerical tools are required, as analytical solutions are often unavailable. juliacon2024-43482-macromodelling-jl-developing-and-solving-dsge-models Economics Thore Kockerols en MacroModelling.jl is a Julia package for developing and solving dynamic stochastic general equilibrium (DSGE) models. The package serves as a tool for handling the complexities involved when working with these kind of models, such as forward-looking expectations, nonlinearity, and high dimensionality. The user-friendly syntax, automatic variable declaration, and effective steady state solver facilitate fast prototyping of models. Furthermore, the package allows the user to work with nonlinear model solutions (up to third order (pruned) perturbation) and estimate the model using gradient based samplers (e.g. NUTS, or HMC). Currently, DifferentiableStateSpaceModels.jl is the only other package providing functionality to estimate using gradient based samplers but the use is limited to models with an analytical solution of the non stochastic steady state (NSSS). Larger models tend to not have an analytical solution of the NSSS and MacroModelling.jl can also use gradient based sampler in this case. The target audience for the package includes central bankers, regulators, graduate students, and others working in academia with an interest in DSGE modelling. false GitHub https://pretalx.com/juliacon2024/talk/PSNXYK/ https://pretalx.com/juliacon2024/talk/PSNXYK/feedback/ While Loop (4.2) Talk 2024-07-10T14:00:00+02:00 14:00 00:30 This talk presents how we developed a general, adaptable satellite telemetry analysis system using the Julia language and its ecosystem. The system can fetch the telemetry packets from the mission database, convert the desired telemetry variables, and output a data frame with the information. From here, we can use all the power in Julia language to perform the complicated analysis often required to verify the attitude and orbit control subsystem health. juliacon2024-43407-developing-a-satellite-telemetry-analysis-system General Ronan Arraes Jardim Chagas en In the previous JuliaCon, we presented how we use Julia to develop our next-generation satellites' attitude and orbit control subsystem (AOCS) at the National Institute for Space Research (INPE). During the development, we identified a critical area in which Julia could provide an excellent contribution: telemetry analysis. Telemetry is all the data a satellite sends to the ground, encompassing the information we have to verify the system's health. We also use the same data during the satellite integration when we need to perform several analyses to check if all algorithms and functionalities work correctly. This kind of analysis is particularly challenging for the AOCS. Given the bandwidth limitation, we can only provide a minimal set of parameters to be sent in the telemetry packet. Hence, we must perform many transformations to rebuild all the AOCS internal states, especially during unexpected events. For example, the AOCS telemetry frame usually contains only the satellite position in the inertial reference frame. Thus, to obtain its geodetic position (latitude, longitude, and altitude), we need to convert the inertial frame to an Earth-fixed frame and then transform it from the position vector to geodetic coordinates. Every mission has its telemetry analysis system. However, those environments are usually built for fast telemetry checking, targeting the satellite operators during the daily control routines. Those environments often lack a proper programming platform to perform telemetry data transformation. Given the above discussion, we decided to build a general, adaptable telemetry analysis system for the Julia language. The ecosystem defines a set of general API functions to build the interface with any telemetry analysis system. First, we must define a telemetry source, stating how to obtain and unpack the packets. Afterwards, we define the telemetry database, where all the existing variables are registered, including the transfer functions between the bits in the frame and the engineering values. Given those definitions, the system is capable of fetching and converting the desired telemetry to a DataFrame, where we can use all the power in Julia language to perform any analysis we want. From now on, we expect to use this system in all of INPE's missions, including the tasks in the development stage. System validation happened for the Amazonia-1 mission, which was successfully launched in February 2021, where we implemented the interface with the current telemetry analysis system, SATCS. In this task, Julia proved to be an outstanding alternative. We needed to convert a proprietary language for the transfer functions to Julia code, where we extensively used Julia's metaprogramming capabilities, leading to a high-speed system to convert the telemetry information. After implementing the interface, we could easily access the satellite's telemetry and perform a myriad of analyses. In fact, we quickly designed an automatic telemetry analysis system, running every day, to spot common problems and alert the mission specialists by e-mail if anything is identified. This talk will detail how the system was designed and important study cases obtained from the Amazonia-1 satellite telemetry analysis, stating how the capabilities available in Julia language and its ecosystem were paramount in the development. false GitHub https://pretalx.com/juliacon2024/talk/RVNXNE/ https://pretalx.com/juliacon2024/talk/RVNXNE/feedback/ While Loop (4.2) Talk 2024-07-10T14:30:00+02:00 14:30 00:30 The SatelliteToolbox.jl ecosystem was created almost ten years ago to contain functions for solving satellite-related problems using the Julia language. Since then, it has become an essential asset for the Brazilian National Institute for Space Research (INPE) when analyzing space missions. This talk presents the ecosystem's main functions and shows case studies of demands put by the Brazilian space program that were solved using SatelliteToolbox.jl. juliacon2024-44509-the-satellitetoolbox-jl-ecosystem Aerospace Minisymposium /media/juliacon2024/submissions/9D3TTS/logo_lslf6Vb.png Ronan Arraes Jardim Chagas en We created the SatelliteToolbox.jl package almost ten years ago to provide a set of functions for the Julia language to perform several satellite-related analyses. Since then, this toolbox has been extensively used in many projects of the Brazilian National Institute for Space Research (INPE). Currently, the ecosystem contains functions that can be used to perform many kinds of analyses from the Pre-Phase A up to the operational phase of a satellite. We can create propagators, transform reference systems, compute atmospheric density and magnetic field, and more. This talk presents the main functions of the twelve packages that form the SatelliteToolbox.jl ecosystem. We also show case studies based on actual demands for the Brazilian space program that were addressed by those algorithms. false GitHub https://pretalx.com/juliacon2024/talk/9D3TTS/ https://pretalx.com/juliacon2024/talk/9D3TTS/feedback/ While Loop (4.2) Talk 2024-07-10T15:00:00+02:00 15:00 00:30 A reference model of airborne wind energy systems will be presented, developed for the International Energy Agency. The requirements included a modular design, good extendability and easy installation without using proprietary software and finally interoperability with larger simulation frameworks, written in Python. Julia was chosen for performance, readability and maintainability. The solution consists of a set of eight Julia packages that can be used individually or in combination. juliacon2024-52997-a-reference-model-for-airborne-wind-energy-systems-case-study Aerospace Minisymposium /media/juliacon2024/submissions/NUBDFN/kite_power_tools_vDU0cQy.png Uwe Fechner en Airborne wind energy - harvesting the wind using a tethered wing - is a new technology that promises much lighter, portable wind energy systems that are beautiful to look at. But designing a flying system with low costs and very high reliability is challenging and requires excellent software tools. The International Energy Agency has a working group on airborne wind energy to provide stakeholders (governments, investors) with tools to investigate the economic feasibility of these new type of energy systems. In this context, and based on the PhD thesis of the author, a set of Julia packages was developed to be able to simulate the loads and the performance of these systems in all kind of sizes and environmental conditions. In the presentation, the author will first explain the concept and the status of airborne wind energy and then explain how such models are used. Then the package hierarchy will be explained before diving deeper into the implementation of some of the packages. Finally, some of the challenges of using Julia for such a large software and research project are pointed out. An impressive 3D visualization was implemented using the GLMakie library. The simulation performance using a pure Julia DAE solver is outstanding, a performance of 66 times faster than real-time was achieved. Finally, an outlook on the coming improvements will be presented. false A reference model for Airborne Wind Energy systems https://pretalx.com/juliacon2024/talk/NUBDFN/ https://pretalx.com/juliacon2024/talk/NUBDFN/feedback/ While Loop (4.2) Talk 2024-07-10T15:30:00+02:00 15:30 00:30 In this presentation, we discuss recent developments in Trixi.jl, a numerical simulation framework designed for the accurate computation of the physics of flowing compressible media. We focus on the technical aspect of importing existing meshes into Trixi.jl, exemplified by the utilization of the NACA4412 airfoil mesh from NASA's Turbulence Model Benchmarking Working Group. This functionality provides users with the ability to integrate existing meshes into their simulations. juliacon2024-43981-towards-aerodynamic-simulations-in-julia-with-trixi-jl Aerospace Minisymposium /media/juliacon2024/submissions/XH8KBG/Trixi_Logo_lfmJSCt.png Daniel Doehring en Mesh generation is a complex and critical process at the beginning of every grid-based simulation workflow. We demonstrate how Trixi.jl facilitates this task by showcasing the usage of existing meshes, exemplified by the NACA4412 airfoil meshes from NASA's Turbulence Model Benchmarking Working Group. This functionality represents a substantial leap forward, allowing users to seamlessly integrate well-established meshes into their simulations, a feature particularly significant given the intricacies and resource-intensive nature of mesh generation. In more detail, we discuss the import of bilinear meshes into P4est.jl, a Julia wrapper around the p4est library which provides the datastructures for distributed memory adaptive meshes. As we delve into the technicalities of Trixi.jl, we shine a spotlight on its pragmatic application in real-world aerodynamic scenarios. The presentation underscores the straightforward integration of advanced features, notably adaptive mesh refinement (AMR), automatic differentiation through ForwardDiff.jl and shock capturing, showcasing their utility in enhancing the precision, robustness and efficiency of simulations. false GitHub Repository Slack Channel Documentation YouTube Channel https://pretalx.com/juliacon2024/talk/XH8KBG/ https://pretalx.com/juliacon2024/talk/XH8KBG/feedback/ While Loop (4.2) Lightning talk 2024-07-10T16:00:00+02:00 16:00 00:10 A stabilized finite element method - the Variational Multiscale Method - has been implemented in Julia. It is based on Gridap library, and the parallelization on GridapDistributed and PartitionedArrays. It has been tested to simulate airfoil up to Reynolds 500 000. juliacon2024-44338-variational-multiscale-method-in-julia-for-airfoils-simulations Aerospace Minisymposium /media/juliacon2024/submissions/VQRLQC/du89_vcontour_Z8GA4LP.png Carlo Brunelli en The Variational Multiscale Method has been implemented in Julia relying on the Gridap ecosystem. It solves the Navier Stokes equations using the finite element method with same-order interpolation elements. Thanks to Gridap we can solve the non-linear, time-dependent problem on distributed architecture with satisfying strong and weak scaling. To speed up the computation also a linearized version is implemented. The final system is solved using PETSc. Thanks to Julia it is possible to write equations almost the same as on paper, differently from other programming languages. The main application is to perform implicit LES on transitional airfoils (Reynolds up to 500 000). It has been validated on the sd7003 airfoil and experimental results. It can be shown how easy is also to implement the continuous unsteady adjoint since the PDEs are available. repos: https://github.com/carlodev/SegregatedVMSSolver.jl https://github.com/carlodev/IncompressibleAdjoint.jl Videos: https://www.youtube.com/watch?v=wyJnVTuCC3Q https://www.youtube.com/watch?v=manQpEMwj4Y false GitHub https://pretalx.com/juliacon2024/talk/VQRLQC/ https://pretalx.com/juliacon2024/talk/VQRLQC/feedback/ While Loop (4.2) Talk 2024-07-10T16:10:00+02:00 16:10 00:30 We report on numerical computation of optimal trajectories in space mechanics using Julia code. The talk will address several examples including minimum time orbit transfert computation (CNES) and solar sail control (ESA). Direct transcription and indirect / shooting methods (based on Pontrjagin maximum principle) as well as techniques from convex optimisation will be illustrated on these examples. Current developments based on Julia control-toolbox will be discussed. juliacon2024-44489-trajectory-optimisation-in-space-mechanics-with-julia Aerospace Minisymposium /media/juliacon2024/submissions/UXJWXS/IMG_2863_ZjNRTYv.jpeg Jean-Baptiste CaillauOlivier CotsAlesia Herasimenka en There is a strong trend to use Julia in scientific computing, so as to take advantage not only of the performance but also of the high level traits of the language. These features allow to cast problems and algorithms in a form close to their mathematical definitions. As powerful Julia libraries to solve ODE's and optimisation problems are now available, it is possible to attack efficiently optimal control problems. Space mechanics is a long-standing application of control theory, and we focus on this topic from the classic (though not so simple) maximum height Goddard problem [1] to modern applications stemming from collaborations with space agencies. More precisely, minimum time orbit transfer [2] (collaboration with CNES and Thales Alenia Space) and solar sailing [3] (collaboration with ESA) will be discussed. Several methods will be presented, including direct transcription and shooting. While the first approach consists in a brutal approximation of the infinite dimensional control problem by a nonlinear program with sparse constraints, the second one leverages Pontrjagin maximum principle to ensure a very precise computation of optimal controls. Rather than competing methods, these two approaches must be made to collaborate: direct codes capture the structure of the solution (typically made of bang and singular arcs), which then allows to devise and initialise a tailored shooting function. These points will be illustrated in the framework of ongoing developments of Julia packages from the [control-toolbox](https://control-toolbox.org) [4] suite. [1] Caillau, J.-B.; Ferretti, R.; Trélat, E.; Zidani, H. An algorithmic guide for finite-dimensional optimal control problems. *Handbook of Numerical Analysis*, in Numerical Control: Part B **24** (2023), 559-626. [2] Caillau, J.-B.; Gergaud, J.; Noailles, J. 3D Geosynchronous Transfer of a Satellite: continuation on the Thrust. *J. Optim. Theory Appl.* **118** (2003), no. 3, 541-565. [3] Herasimenka, A; Dell'Elce, L.; Caillau, J.-B.; Pomet, J.-B. Controllability properties of solar sails. *J. Guidance Control Dyn.* **46** (2023), no. 5, 900-909. [4] [control-toolbox.org](https://control-toolbox.org) false OptimalControl.jl https://pretalx.com/juliacon2024/talk/UXJWXS/ https://pretalx.com/juliacon2024/talk/UXJWXS/feedback/ While Loop (4.2) Talk 2024-07-10T16:40:00+02:00 16:40 00:30 One of the main problems in the computation of orbital predictions, is the propagation of the orbital uncertainty. This problem is relevant in a wide range of scenarios, from the design of interplanetary spacecraft trajectories, to the assessment of the hazard posed by an asteroid impacting the Earth. In this talk, we present a technique to propagate large sets of initial conditions in TaylorIntegration.jl via a technique called Automatic Domain Splitting (ADS). juliacon2024-44395-propagating-large-orbital-uncertainty-with-taylorintegration-jl Aerospace Minisymposium Jorge A. Pérez-HernándezLuis Eduardo Ramírez MontoyaLuis Benet en One of the main problems in the computation of orbital predictions, is the propagation of the orbital uncertainty. This problem is relevant in a wide range of scenarios in astrodynamics, from the assessment of the hazard posed by an asteroid impacting the Earth, to the design of interplanetary spacecraft trajectories. A first possibility to tackle this problem, is to solve a given initial value problem (IVP) in terms of Taylor expansions with respect to time and small deviations around a given reference initial condition, a technique known as jet transport (JT). This technique allows to solve IVPs for small neighborhoods around a given reference initial condition. Nevertheless, although our implementation of JT in TaylorIntegration.jl controls the error with respect to time, so far it does not control the error on the Taylor expansions around these small deviations with respect to the reference initial conditions, which under some circumstances can break the accuracy of the IVP solution. In this talk, we present a technique to mitigate this issue. We are implementing in TaylorIntegration.jl a technique called Automatic Domain Splitting (ADS), as introduced by Wittig, et. al. (2015). The idea is simple: we begin with a domain where we can trust JT initially works. As we propagate, whenever an error metric exceeds a tolerance, the current polynomial splits into two JT integrations, each representing half of the original domain. This process is iterated for each new sub-domain throughout an integration, so that the solution for the set of initial conditions is returned as a binary tree of JT solutions. We discuss applications of this technique to modelling of planetary fly-bys by small bodies (asteroids, comets, spacecraft, etc.). false https://pretalx.com/juliacon2024/talk/SQFY3B/ https://pretalx.com/juliacon2024/talk/SQFY3B/feedback/ While Loop (4.2) Lightning talk 2024-07-10T17:10:00+02:00 17:10 00:10 We present `RunwayPNPSolve.jl`, a framework for uncertainty-aware pose estimation for visual landing applications with multiple methods including real-time least-squares minimization + resampling, Monte-Carlo Markov-Chain, and a linear approximation, by leveraging the existing Julia package ecosystem. The package further provides a framework of useful primitives to build simultaneously differentiable, unitful and coordinate-system-aware interfaces, and an interactive visualization pipeline. juliacon2024-44464-runwaypnpsolve-jl-uncertainty-aware-pose-estimation Aerospace Minisymposium Romeo Valentin en Autononomous visual landing systems for personal and commercial aircraft have typically only been available given the use of expensive sensors with a moderate safety certification level. With the recent emergence of high-performing computer vision models using deep learning, a new avenue for such landing systems has opened, and is being pursued by multiple companies such as Acubed (an Airbus company), Daedalean, XWing, Reliable Robotics, and others. However, it is an open problem to construct such systems under the high safety and certification requirements in aviation. Thus, deep learning models are typically only used for image feature estimation (including measures of uncertainty), and more traditional techniques are used for the actual pose estimation and processing of uncertainty estimates. In this talk we will focus on the latter, and showcase our package `RunwayPNPSolve.jl` which leverages Julia&rsquo;s extensive ecosystem for processing pixel features, for example provided as a Normal distribution, to construct a probability distribution over our pose and orientation. In particular, we first present a framework of data primitives tailored for visual landing setting, including - statically typed coordinate systems (e.g. `XYZ`, `ImageProjection`, `LongitudeLatitude`) that integrate with `Geodesy.jl` and `CoordinateTransformations.jl`; - defining the external and (most of the) internal API through `Unitful.jl` interfaces (`m`, `pxl`, `degrees`), while maintaining type flexibility for e.g. `ForwardDiff.jl`&rsquo;s `Dual` types; - a live satelite-view of pose estimation on real runways that integrates with OpenStreetMaps through `Tyler.jl` and a custom runway database; and - interactive visualization capabilities through `Makie.jl`. After presenting the framework, we present several approaches implemented in `RunwayPNPSolve.jl` for the actual uncertainty-aware pose estimation, including - a mathematically sound approach using Markov-Chain Monte-Carlo backed by `Turing.jl`; - a resampling based approach built on top of `NonlinearSolve.jl` (although we are happy to discuss our attempts to use `LsqFit.jl`, `Optim.jl`, and `NLSolve.jl`); - a somewhat uninformed approach that directly differentiates through the iterative least-squares solver from `NonlinearSolve.jl` using `ForwardDiff.jl`; - an efficient linear-approximation requiring only a single (automatic) derivative. If time permits, we will also discuss how we can estimate the quality of the resulting uncertainty estimates by measuring calibration in a variety of way, including a novel method we plan to publish soon. The package including the discussed topics can be found under <https://github.com/sisl/RunwayPNPSolve.jl> and <https://github.com/sisl/MultivariateCalibration.jl>. false The prezzy 😎 The paper 📝 https://pretalx.com/juliacon2024/talk/MVFVGB/ https://pretalx.com/juliacon2024/talk/MVFVGB/feedback/ While Loop (4.2) Lightning talk 2024-07-10T17:20:00+02:00 17:20 00:10 This presentation demonstrates the use of ModelingToolkit based AerialVehicles.jl model libraries, JuliaSimControl and InfiniteOpt for optimal rendezvous/docking of a quadrotor with multiple ground vehicles focusing on the efficient cooperation of ground vehicles with a landing quadrotor. The central theme is the use of a collocation-based approach to optimize control efforts, ensuring a seamless rendezvous between multiple ground vehicles and the quadrotor using a shared time-to-go estimate. juliacon2024-43506-optimal-cooperative-rendezvous-using-aerialvehicles-jl Aerospace Minisymposium Rajeev Voleti en This talk presents an in-depth exploration of a novel solution for the cooperative, optimal multi-vehicle rendezvous problem, focusing on rendezvous of a quadrotor with multiple ground vehicles. The solution, pioneering in its approach, combines a gain-free, time-dependent optimal control problem with a consensus protocol based on shared time-to-go information. This dual-stage method not only streamlines vehicle convergence but also ensures adaptability and efficiency in trajectory refinement. The presentation will be structured into several key sections, each delving into different aspects of the proposed solution: Introduction to Multi-Vehicle Rendezvous Problems: We will begin by providing an overview of the challenges and current state of multi-vehicle rendezvous solutions, particularly emphasizing the complexities of coordinating the rendezvous. This will set the stage for understanding the novelty and necessity of the proposed method. Overview of the Proposed Methodology: The first stage involves solving the optimal control problem to generate initial rendezvous trajectories. Here, the focus will be on the gain-free, time-dependent nature of the control problem and its implications for efficient vehicle convergence. The second stage of our approach refines these trajectories in real-time, employing a consensus-based adaptation protocol. Consensus Protocol and Trajectory Refinement: The consensus based adaption would be such that the time-to-go estimates of the ground vehicles will be set to the time-to-go of the approaching quadrotor and our finite-time control framework would make the approach optimal. Simulation Demonstrations: A significant portion of the presentation will be dedicated to showcasing numerical simulations. These simulations will demonstrate the method's effectiveness, its superiority in terms of convergence and adaptability, and the impact of communication topology on performance. The simulations will utilize JuliaSimControl for optimal control generation and the AerialVehicles model library to model the quadrotor and ground vehicles, providing a practical and visual representation of the method's capabilities. Practical Implications and Applications: The talk will explore the practical applications of this methodology, discussing its potential in various fields such as autonomous transport, logistics, emergency response, and military operations. We will delve into how this solution can help the efficiency and safety of autonomous vehicle operations in complex, dynamic environments. This presentation is designed to provide an understanding of our innovative solution to the multi-vehicle rendezvous problem. Attendees will gain valuable insights into advancements in autonomous systems, optimal control, and consensus protocols, leaving with a deeper appreciation of the complexities and potentials in this rapidly evolving field. false https://pretalx.com/juliacon2024/talk/EKUN3E/ https://pretalx.com/juliacon2024/talk/EKUN3E/feedback/ While Loop (4.2) Poster 2024-07-10T18:30:00+02:00 18:30 00:30 Modern model-based design and decision support in engineering climate change response relies on complex simulation workflows, orchestrating research software in diverse programming languages and compute paradigms. Reproducibility and reuse is challenging due to complex installations, and workflow reproducibility is not seamlessly inherited. We analyze the Time to First Reproduction (TTFR) in such workflows using the Julia ecosystem, drawing insights from two projects in our research group. juliacon2024-44903-seamless-reproducibility-of-complex-simulation-workflows Posters Alan Correa en In the field of engineering climate change response, there is a growing interest in model-based approaches to address complex challenges. For instance, models for simulating shallow free surface flow aid in predicting flooding, landslides, and avalanches for early warning systems and hazard mitigation. Modern methods for model-based design and decision support rely heavily on computational techniques and models implemented within research software, which have been developed over decades. In our research group, we also develop computational methods and models for diverse applications including landslides, subsequently employing them for tasks like sensitivity analysis, model selection, digital twins, uncertainty quantification, and decision support. In these scenarios, integrating and orchestrating existing research software assets into reusable simulation workflows proves to be a practical choice, preventing redundant efforts. Such reproducible and reusable workflows enable transparency, verification and validation, peer review, collaboration, adaptability to new methods, and benchmarking. Achieving reproducibility and reusability in complex computational model-based workflows poses notable challenges, considering the varied programming languages, package managers, and computing platforms employed in research software development. Furthermore, extension of workflow reproducibility from that of individual software assets is not assured, and cumbersome installation procedures often dissuade researchers from experimenting with well-crafted research software. The question then arises: How can we achieve seamless reproducibility of complex model-based simulation workflows involving heterogeneous research software? We try to answer this question by considering two research software projects within our group: 1. PSimPy (https://pypi.org/project/psimpy/) - A Python/R package to orchestrate Gaussian Process integrated Sensitivity Analyses, Uncertainty Quantification & Bayesian Model Calibration. 2. SWEBench - An Emulator Framework to facilitate Benchmarking of Forward Solvers for Thin-film Mass Transport over Complex Geometries. The Julia ecosystem provides an interesting solution to workflow reproducibility that we will analyze in detail. This work particularly emphasizes the Time to First Reproduction (TTFR), a factor that significantly impacts the usability and adoption of software in a research setting. Julia ensures reproducible compute environments through its built-in package manager. Furthermore, its package ecosystem seamlessly enables the installation and utilization of libraries and software from various sources, including Python, R, and pre-compiled binaries via BinaryBuilder. In comparison to individually using other modern solutions, like conda and docker, utilizing the Julia ecosystem allows us to greatly reduce TTFR along with developer and maintenance effort. false https://pretalx.com/juliacon2024/talk/FJRZL7/ https://pretalx.com/juliacon2024/talk/FJRZL7/feedback/ While Loop (4.2) Poster 2024-07-10T19:00:00+02:00 19:00 00:30 This poster presents _featured Pluto notebooks_: a curated collection of Pluto notebooks (interactive Julia notebooks) that can be viewed in Pluto or online. The featured notebooks are intended to onboard new Julia programmers, and to highlight the diversity of work in the Julia community. Featured notebooks are open to submissions from Julia developers of all skill levels; our presentation will showcase this platform to share your ideas and knowledge. juliacon2024-43472-featured-pluto-notebooks-submit-your-own Posters Luka van der Plas en Pluto is a notebook-based Julia environment. It was initially designed to be especially suitable for students and beginners, but has since grown into one of the most popular IDEs for Julia programmers of all skill levels. Featured notebooks are a collection of notebooks that can be viewed in Pluto or online ([featured.plutojl.org](https://featured.plutojl.org/)). Featured notebooks are a way to show users what they can do with Julia and Pluto. For budding programmers, this can mean a simple tutorial on how to use Pluto, or how to use arrays in Julia, but for more experienced programmers, featured notebooks can highlight how Julia is used in different fields, give examples of interactive visualisations that are free to reuse in your own work, or explain more advanced concepts to turn Julia scripts into interactive notebooks. Featured notebooks are a curated collection; anyone can submit their work as a featured notebook, but submissions are reviewed to ensure new Pluto users won't encounter broken or unintelligible notebooks. We encourage Julia programmers to submit notebooks. You don't need to be an expert to write a featured notebook! The notebooks are designed to help beginning Pluto users get underway with their own ideas; as such, short tutorials on basic Julia concepts, or short examples of neat ideas, are very much welcome, and are a great way to contribute to the Julia community when you're still learning yourself. That said, we also very much welcome experienced Julia programmers to share their work. Featured notebooks can highlight how you use Julia in your domain, bring attention to a neat package, or share exercises that you created for a course. The poster presentation will cover all need-to-know information about how to submit notebooks, and what is appropriate to submit. We will also provide some advice to notebook authors on creating engaging stand-alone notebooks. We will also happily answer your questions and discuss your ideas for potential submissions. false https://pretalx.com/juliacon2024/talk/HYW9AW/ https://pretalx.com/juliacon2024/talk/HYW9AW/feedback/ While Loop (4.2) Poster 2024-07-10T19:30:00+02:00 19:30 00:30 Biological systems often include complicated combinations of positive and negative feedback control. Recovering this control network is often difficult, because of both limitations in biological knowledge and available data. In this poster, we present the use of SciML's universal differential equation framework, uniquely available in Julia, for uncovering and personalising mathematical equations for biological modulation points and mechanisms. juliacon2024-44244-learning-biological-modulation-mechanisms-with-sciml Posters /media/juliacon2024/submissions/ZLUFAB/juliacon_poster_IsoBjRP.png Max de Rooij en Biological regulation is the result of the interplay between many molecules in a network of chemical reactions. Through mathematical modelling, parts of the system can be simulated in silico to quickly match biological hypotheses with experimental evidence. However, many components of subsystems of human regulation are often unknown, or cannot be directly measured. Therefore, simplifications are required to keep the model both mathematically identifiable from the available data, as well as biologically meaningful. This process can take a long time, and simplified solutions may work on population averages, but fail more often when applied to personalised data directly. Modelling unknown terms using a neural network, creating a universal differential equation (UDE), and combining this with symbolic regression can enable the data-driven discovery of mathematical model terms that describe the data. This poster describes the systematic application of these universal differential equations in context of control loops and modulation points found in biological models, presenting the use of neural networks to both locate and recover missing modulation points in biological models. Furthermore, it highlights limitations of the inclusion of neural networks related to data sparsity and identifiability. false https://pretalx.com/juliacon2024/talk/ZLUFAB/ https://pretalx.com/juliacon2024/talk/ZLUFAB/feedback/ Reflection (1.2) Poster 2024-07-10T18:30:00+02:00 18:30 00:30 Many multidimensional functions (e.g. a Gaussian) can be written in a (generalized) separable form. `SeparableFunctions.jl` is a package that calculates and represents separable functions efficiently. Upon construction of a function, one-dimensional representations are pre-calculated and effienctly represented in various ways to the user. Compared to a non-separable calculation, this yields significant speed improvements for both CPU and GPU-code alike. Radial functions are also supported. juliacon2024-43695-separable-functions Posters Rainer Heintzmann en Many multidimensional functions can be written in a (generalized) separable form. A good example of such a function is the Gaussian function. Computing such functions by first computing the separable entities and then combining them, or even keeping them in a lazy form can yield significant advantages in computation speed. `SeparableFunctions.jl` is a package, that leverages such advantages. Multidimensional functions are computed by first calculating their single-dimensional representations and then creating the final multidimensional result by an outer product (or sum or max or any other operator). Since the broadcasting mechanism of Julia is fast compared to the evaluation of the function at each multidimensional position, the final result is calculated much faster. The typical speedup can be an order of magnitude. The package supports three forms of representing such separable functions: collecting them, a `LazyArray` representation, and a broadcasting form labelled `_sep`. The latter being the most generic, however, for its application the operator needs to be supplied as follows `.*(my_function_sep...)`. In addition also radial functions (on a Cartesian grid) can be sped up, by exploiting their symmetries and possibly interpolating on a radially pre-calculated grid. The package hosts a number of easy to use separable functions such as `gaussian`, `sinc`, `ramp`, `rr2` and some complex-valued exponentials needed for propagating optical fields or Fourier-based shifting. false https://pretalx.com/juliacon2024/talk/PN3DXY/ https://pretalx.com/juliacon2024/talk/PN3DXY/feedback/ REPL (2, main stage) Ceremony 2024-07-11T08:45:00+02:00 08:45 00:15 Opening the second day of JuliaCon Global 2024 and PyData Eindhoven 2024 with organizing committee member Koen de Raad. juliacon2024-53126-opening-ceremony Koen en Opening the second day of JuliaCon Global 2024 and PyData Eindhoven 2024 with organizing committee member Koen de Raad. false https://pretalx.com/juliacon2024/talk/WPMART/ https://pretalx.com/juliacon2024/talk/WPMART/feedback/ REPL (2, main stage) Keynote 2024-07-11T09:00:00+02:00 09:00 00:50 In a rapidly evolving landscape of semiconductor manufacturing, ASML’s advanced lithography technologies are pivotal in driving Moore’s Law forward. The focus of this talk is ASML’s holistic approach to Software development and acceleration of Software delivery to customers. In addition, we discuss how ASML engages and cultivates Software talents. At the end of this presentation the attendees will have an understanding of ASML’s software ecosystem and its critical role in advancing the future. juliacon2024-45604-software-at-asml-the-force-behind-making-microchips General Maurice du Mee en A full description for this keynote will be announcIn a rapidly evolving landscape of semiconductor manufacturing, ASML’s advanced lithography technologies are pivotal in driving Moore’s Law forward. The focus of this talk is ASML’s holistic approach to Software development and acceleration of Software delivery to customers. Key highlights include our innovative development environment, which fosters seamless integration and rapid iteration amongst teams. In addition, we discuss how ASML engages and cultivates Software talent through strategic initiatives and collaborative projects. By fostering a dynamic and innovative work environment, we empower our engineers to drive technological advancements and operational excellence. At the end of this presentation the attendees will have an understanding of ASML’s software ecosystem and its critical role in advancing the future of semiconductor fabrication.ed and added to the session when it becomes available. false https://pretalx.com/juliacon2024/talk/DMLTLG/ https://pretalx.com/juliacon2024/talk/DMLTLG/feedback/ REPL (2, main stage) Talk 2024-07-11T10:00:00+02:00 10:00 00:30 At JuliaCon Local Eindhoven 2023, we've argued that Julia creates the "1.5 language problem". The goal back then has been to initiate a discussion--and numerous reactions show that a discussion has been initiated indeed. In this talk, we want to recap our original arguments, analyze and summarize the discussion that we've observed online and present some ideas where to take this from here. juliacon2024-43367-language-1-5-revisited Julia Internals and Tooling Michael Tiemann en At JuliaCon Local Eindhoven 2023, we've argued that Julia creates the "1.5 language problem". What's the "1.5 language problem"? Well, Julia has been advertised as a language that can be used for rapid high-level prototyping but also for very fast and efficient low-level code. However, while both aspects can be achieved with Julia code, the necessary coding requirements and styles are very different. The goal of last year's talk has been to initiate a discussion--and numerous reactions show that a discussion has been initiated indeed. It has been the most watched talk on YouTube from the conference [1], and it has created long discussions on the Julia Discourse [2] and Reddit [3]. Today, we recap and refine our original arguments. Then, we will analyze and summarize the discussion that we've observed online. Reflecting on the talk and the online discussion, we will present some ideas and suggestions to where to take this from here. In particular, we will argue that the different styles of Julia programming can be thought of as lying on a spectrum and that a (standardized?) visual guide used in presentations, tutorials, etc. can help a reader identify what sort of expectations they should make about runtime and extendability. Furthermore, we rally a call to arms to create more tutorials that help learners iteratively taking their code bases from the prototyping spectrum to the pedal-to-the-medal speed spectrum. [1] https://www.youtube.com/watch?v=RUJFd-rEa0k&list=PLP8iPy9hna6Tp3QV4akXAd23_O5Vjm_e2 [2] https://discourse.julialang.org/t/does-julia-create-a-1-5-language-problem/107984 [3] https://www.reddit.com/r/Julia/comments/18nyxew/michael_tiemann_julia_solves_the_2_language/ false https://pretalx.com/juliacon2024/talk/YKRZDP/ https://pretalx.com/juliacon2024/talk/YKRZDP/feedback/ REPL (2, main stage) Talk 2024-07-11T10:30:00+02:00 10:30 00:30 Rising from the ashes of its languid repose over the last two years, BinaryBuilder development makes a triumphant reentry into the public world with a brand new implementation and improved ergonomics around almost every aspect of the entire project. Faster, more modular, configurable, and extensible than ever, the new BinaryBuilder release will change the lives of anyone forced to deal with native code compilation. juliacon2024-42181-binarybuilder-2-return-of-the-compilers Julia Internals and Tooling Elliot Saba en BinaryBuilder development hit a plateau about two years ago, when the core developers collected a laundry list of pain points: * Complex software projects such as LLVM do not fit nicely into a single `build_tarballs()` invocation; there are potentially multiple stages to the build, outputs may need to be split across multiple JLLs, different platforms may need different recipes, etc... * Extending BinaryBuilder to work with more compilers/platforms is a painful and arcane process that typically requires someone very well versed in the BB world to take to the finish line. * BinaryBuilder itself was so monolithic and interconnected that small changes could cause failures in seemingly unrelated areas, slowing development dramatically. Once these pain points accumulated to a certain point, the core developers realized that the very architecture of BinaryBuilder (particularly, how the build environment, so called "compiler shards" were constructed) contributed directly to many of these problems. Never to shrink away from ambitious projects, the developers rolled up their sleeves and began a from-scratch rework of every component and subsystem of the BinaryBuilder suite. This talk will cover not just the new end-user capabilities such as staged builds, but also some of the rationale behind the new organization of the codebase and why this organization unlocks new capabilities for users that are not even using BinaryBuilder directly. One consequence of some of the reorganization will be that pieces of the new BinaryBuilder (such as compilers) will be usable outside of the build environment. false GitHub https://pretalx.com/juliacon2024/talk/EJVFMF/ https://pretalx.com/juliacon2024/talk/EJVFMF/feedback/ REPL (2, main stage) Lightning talk 2024-07-11T11:00:00+02:00 11:00 00:10 Infiltrator.jl is a small utility package for interactively debugging performance sensitive Julia code with minimal runtime cost. juliacon2024-44401-infiltrator-jl-no-overhead-breakpoints-in-julia Julia Internals and Tooling Sebastian Pfitzner en Most other debugging solutions for Julia either incur a significant runtime cost (JuliaInterpreter based debuggers) or bad ergonomics (println-based debugging is very limited in power, while gdb-based debuggers are very low-level compared to Julia code). Infiltrator.jl provides a middle ground -- it's a step up from println-debugging in that it provides an interactive REPL whenever a breakpoint is hit, but still functions at the source-code level without the runtime cost of an interpreter. This talk will give a quick overview of Infiltrator.jl's implementation and showcase common workflows for debugging packages and applications. false https://pretalx.com/juliacon2024/talk/STRAXA/ https://pretalx.com/juliacon2024/talk/STRAXA/feedback/ REPL (2, main stage) Lightning talk 2024-07-11T11:10:00+02:00 11:10 00:10 Join us to discover the latest advancements in GenieFramework. This talk will highlight the key updates, including the introduction of GenieBuilder, improved documentation, customization options with custom components, enhanced styling capabilities, and key technical improvements. Attendees will gain insights into how these new features empower developers to build even more powerful and user-friendly web applications using GenieFramework. juliacon2024-44495-what-s-new-in-genieframework Notebooks & Graphics Pere GiménezHelmut Hänsel en - Experience the game-changing capabilities of the new version of GenieBuilder, designed to simplify web application development. - Discover how the updated documentation together with the app gallery provides comprehensive guidance on GenieFramework's functionalities. - Explore the flexibility offered by custom components and how they enable developers to tailor applications to specific requirements. - Learn about the enhanced styling options including tailwind css. false https://pretalx.com/juliacon2024/talk/XZRCQG/ https://pretalx.com/juliacon2024/talk/XZRCQG/feedback/ REPL (2, main stage) Keynote 2024-07-11T11:30:00+02:00 11:30 01:00 AI is fast becoming a significant consumer of the world’s computational power, so it is crucial to use that power wisely and efficiently. Our approaches to doing so must span all levels of the research stack: from fundamental theoretical understanding of the loss surfaces and regularization properties of machine learning models, to efficient layout at the transistor level of floating-point multipliers and RAM. juliacon2024-48301-ai-hardware-and-real-world-ai AI/ML/AD Andrew Fitzgibbon, FRS en AI is fast becoming a significant consumer of the world’s computational power, so it is crucial to use that power wisely and efficiently. Our approaches to doing so must span all levels of the research stack: from fundamental theoretical understanding of the loss surfaces and regularization properties of machine learning models, to efficient layout at the transistor level of floating-point multipliers and RAM. I will talk about projects, such as real-time computer vision on the Microsoft HoloLens HPU (about 3.5 GFLOPS ), which required extreme efficiency in both objective and gradient computations, and how this relates to the training of massive AI models on Graphcore’s IPU (about 350 TFLOPS). Key to this work is how we empower programmers to communicate effectively with such hardware, and how we design frameworks and languages to ensure we can put theory into practice. So this talk contains aspects of: mathematical optimization, automatic differentiation, programming languages, and silicon design. Despite this range of topics, the plan is for it to be accessible and useful to anyone who loves computers. false https://pretalx.com/juliacon2024/talk/AKGE7D/ https://pretalx.com/juliacon2024/talk/AKGE7D/feedback/ REPL (2, main stage) Talk 2024-07-11T14:00:00+02:00 14:00 00:30 Julia's potential is held back by significant usability problems in error messages, debugger operation and performance, and the need for a package, Revise, for live code updates. These diverse issues can be resolved by improving Julia's ability to relate source code written by the programmer to the various internal representations in Julia's compiler. In this talk we will explain this common thread and discuss ongoing work to improve compiler "provenance." juliacon2024-44351-dude-where-s-my-code Julia Internals and Tooling Tim HolyClaire Foster en Julia has enormous strengths and its widespread adoption is well justified. However, there remain important usability barriers in areas such as interactive debugging and live code updates. We believe that resolving these barriers will be an important step towards extending Julia's reach. In this presentation, we will explain how a single common thread underlies several of the most significant usability challenges. We will also discuss ongoing work to resolve these challenges. ## Challenges - Efficient Julia development requires the use of a package, Revise.jl to updating already-compiled code in interactive sessions. There are several things that make Revise complex, but the most important is that to track line numbers in actively-edited files, Revise must *selectively* re-evaluate the package's source code. The Julia compiler doesn't track all the information required for this rather complex task and as a result it is the main source of Revise bugs and of regressions with each new Julia version. - Julia's interactive debugger has poor usability: + it often struggles to relate program state back to the source code as written by the programmer. This happens because the debugger/interpreter is targeted not at raw source code, but at an early-to-intermediate stage of the compilation pipeline. This "lowered code" is difficult to relate back to the original source code. + it exhibits poor performance, interpreting code at speeds that are often four orders of magnitude slower than compiled code. One way to speed it up --- likely by one to two orders of magnitude --- would be to target the interpreter at an even deeper layer of the compilation pipeline, after many of the most costly operations (method lookup, inlining, etc.) have been finished. But at these deeper layers, the challenge of mapping state back to the original source code is currently intractable. - Compiler error messages have low resolution; they refer to line numbers but don't include not the position within a line of the source code. Sometimes they refer to the wrong line of source code. - Debug information in compiled code has low resolution and stack traces may be ambiguous as to which function call was entered. These issues arise because of a mismatch between the user's view of the code as a text file compared to the compiler's view of the code as a heavily processed intermediate representation (IR). In particular, the IR only knows about the source in an incomplete, low resolution way in terms of line numbers that are sometimes inaccurate. ## Steps towards resolution To resolve these issues we need a high precision map from the compiler's various IRs back to the user's source code --- we need to track the *provenance* of every construct in the IR. With this map we can always talk to the user in terms of their source code, solving many usability problems with error reporting and source-level debuggers. In addition, tools like Revise.jl can use this information to know which range of bytes in the source file define which method signatures. For our purposes compilation may be broken into these stages: * Parsing * Macro expansion * Symbolic simplification (code lowering) * Type inference and high level optimization * Low level optimization and machine code generation Provenance tracking during parsing has been improved in prior work as part of the [JuliaSyntax](https://github.com/JuliaLang/JuliaSyntax.jl) package. To improve error message generation during lowering, improve the debuggers, and to simplify Revise, we additionally need to track provenance through the next two stages of macro expansion and lowering and this talk will focus on those areas. Solving problems such as backtrace ambiguities will require changes all the way through to machine code generation; we leave that to future work. Macro expansion presents a particular challenge because user-written macros accept Julia's `Expr` data structure that can't support our goals of high precision provenance. To solve this problem we need new data structures and APIs for macro writers and these need to be opt-in to preserve compatibility. A working proof of concept is available at [JuliaLang/JuliaSyntax.jl#329](https://github.com/JuliaLang/JuliaSyntax.jl/pull/329). Designing a completely new public API for macros also allows us to tackle some long standing macro usability issues including * "automatic hygiene" (no more `esc()`) * issues with expansion of nested macros * precise reporting of errors in the syntax supported by a macro and we'll briefly touch on these points. Reworking code lowering has fewer compatibility constraints but is a fairly large body of code. We'll discuss progress toward rewriting lowering with a particular emphasis on the data structures used. Some of the code analyses implemented in lowering are useful outside the compiler and we'll talk about how to make them accessible for tasks like tool assisted refactoring. false GitHub https://pretalx.com/juliacon2024/talk/HRRRET/ https://pretalx.com/juliacon2024/talk/HRRRET/feedback/ REPL (2, main stage) Talk 2024-07-11T14:30:00+02:00 14:30 00:30 This talk will dive into the world of static analysis for Julia code, a key aspect of ensuring code quality, maintainability, and performance. We will explore the available tools and packages in Julia for static analysis and discuss best practices for integrating static analysis into the development workflow. juliacon2024-44497-static-analysis-of-julia-code Julia Internals and Tooling Gajendra Deshpande en Julia, a high-level, high-performance dynamic programming language for technical computing, has seen a significant rise in adoption for data science, machine learning, and scientific computing. This talk will dive into the world of static analysis for Julia code, a key aspect of ensuring code quality, maintainability, and performance. We will explore the available tools and packages in Julia for static analysis and discuss best practices for integrating static analysis into the development workflow. The goal is to provide the audience with a comprehensive understanding of the static analysis landscape in Julia, enhancing their ability to write clean, efficient, and error-free code. The talk covers following Julia packages 1. Lint.jl: Linting tool for detecting potential errors and code smells. 2. StaticLint.jl: Static code analysis tool emphasizing code structure understanding. 3. JuliaFormatter.jl: Code formatter for maintaining consistent coding styles. 4. CodeTracking.jl: Utility for tracking code definitions. Talk Outline 1. Introduction [5 minutes] 2. Understanding Static Analysis [5 minutes] 3. Demonstration of Static Analysis Tools in Julia [10 Minutes] 4. Best Practices in Static Analysis [5 minutes] 5. Conclusion and Q&A [5 minutes] false https://pretalx.com/juliacon2024/talk/7783BN/ https://pretalx.com/juliacon2024/talk/7783BN/feedback/ REPL (2, main stage) Talk 2024-07-11T15:00:00+02:00 15:00 00:30 Effect analysis, exception types, escape analysis, effect preconditions, non-standard specialization, optimized generics - the compiler team has been busy. What is this all about? juliacon2024-43484-julia-compiler-secrets-static-analysis Julia Internals and Tooling Shuhei KadowakiKeno Fischer en The foundational capability of the Julia compiler from its earliest versions has been a very sophisticated inter-procedural type inference. To a large extent, the capabilities and limitations of this analysis (including such concepts as "type stability") determine which API designs are possible in Julia, and which are prohibitive from a performance standpoint. Over the past few releases and ongoing in current work, the static analysis capabilities of the Julia compiler have been expanded significantly and are no longer restricted solely to type inference. Julia 1.8 introduced the effect system to track additional properties, such as nothrow-ness, effectfulness and other properties. In Julia 1.11, the compiler started making use of escape analysis information for optimization and gained the capability to track and optimize exception types in addition to ordinary return types. Further enhancements are under consideration, including safer replacements of the `@inbounds` and `--check-bounds` macros. In this talk we will look at the current and near future static analysis capabilities of the Julia compiler and explain how the Julia compiler uses these to make your code faster. In addition, we will discuss how these capabilities can be re-used for improving code correctness and how the general infrastructure in `Core.Compiler` can be extended to custom analyses. false Slides (PDF) https://pretalx.com/juliacon2024/talk/UTGSDT/ https://pretalx.com/juliacon2024/talk/UTGSDT/feedback/ REPL (2, main stage) Lightning talk 2024-07-11T15:40:00+02:00 15:40 00:10 Much of the tooling in Julia assumes the user has an internet connection. How should one build and deploy Julia programs when this is not the case? In this talk we'll discuss how to develop and deploy Julia applications in air-gapped environments, including methods for getting your Julia packages onto the air gapped computer, dealing with multiple users/projects, common pitfalls, and more. juliacon2024-43727-julia-in-air-gapped-environments Julia Internals and Tooling Avik SenguptaDeleted User en In air-gapped environments, you may have no or little control over important factors such as: - The version of Julia installed. - The available binary executables. - The platform (e.g. Linux vs. Windows). However, a common restriction is that text files (e.g. Julia code) are easier to move onto the air gapped computer than binaries. This makes Julia a great candidate for applications since many packages are 100% Julia. In this talk we'll discuss what options are available to you under different restrictions, including: 1. How to set up the air gapped environment for a single user. 2. How to set up the air gapped environment for multiple users. 3. How to build artifacts for the air gapped machine (even if the platform is different than your host machine). 4. What to do when including Pkg's artifacts isn't an option for you. While we can't possibly address every security restriction of every air gapped environment, we'll make the bare minimum assumptions that 1) you are able to move directories of text files into the air gap, and 2) Julia is installed. false Presentation https://pretalx.com/juliacon2024/talk/B9PBBC/ https://pretalx.com/juliacon2024/talk/B9PBBC/feedback/ REPL (2, main stage) Lightning talk 2024-07-11T15:50:00+02:00 15:50 00:10 Interfaces.jl is an attempt to solve Julias lack of explicit interface declarations. It provides macros to define and implement interfaces concisely, and functions to test and check that they are implemented correctly. Its subpackage BaseInterface.jl defines some common Base Julia interfaces using Interfaces.jl. This talk will cover things learned writing and using the package, and hopefully inspire some discussion on the future of interfaces in Julia more broadly. juliacon2024-44411-interfaces-jl-base-and-package-interface-tests-for-your-objects Julia Internals and Tooling Rafael SchoutenGuillaume Dalle en Julia lacks a built-in method for defining strict interfaces. Instead, we use an ad-hoc combination of inheritance, traits, documentation, interface tests, and usually, run-time errors when something is not implemented! At the same time we rely heavily on shared interfaces for high levels of package interop, and this combination makes better interfaces a common request from Julia developers. There are a number of efforts underway exploring how interfaces could work better in Julia. This is just one of those, and certainly not the most sophisticated one! The general assumptions of Interfaces.jl are that: - Interfaces can enforce both run-time and compile-time constraints, e.g. it is reasonable to insist that a method must return a positive valued `Int` - Interfaces often need optional components, such as mutability in AbstractArrays - Interfaces can be tested for package types only if given a specific object with that type - Interfaces definitions should provide traits other packages can check - Interface implementations should be verified during tests or package precompilation - The easiest way to define an interface is to simply provide a named list of functions that test all the mandatory and optional ways an object should behave. We get these properties by defining a simple NamedTuples of functions, and a mechanism to make some of those names optional in the `@interface` and `@implements` declarations. By providing data during `@implements` declarations we can also programmatically test interfaces implementations in any object, package or multiple packages with a single command. Slides: <https://rafaqz.github.io/JuliaCon2024-Interfaces/> Video: <https://www.youtube.com/live/Bo3k4oD1Avg?feature=shared&t=27085> false GitHub https://pretalx.com/juliacon2024/talk/GXWLAW/ https://pretalx.com/juliacon2024/talk/GXWLAW/feedback/ REPL (2, main stage) Talk 2024-07-11T16:00:00+02:00 16:00 00:30 We will explain new options for ahead-of-time compilation of julia programs that we have been developing. First, there is a new compiler driver `juliac` that provides a more traditional gcc-like command-line interface. Next, we are adding new compiler modes that allow generation of smaller binaries by opting-in to assumptions that hold for some important classes of programs. juliacon2024-44458-new-ways-to-compile-julia Julia Internals and Tooling Jeff BezansonGabriel Baraldi en We will explain new options for ahead-of-time compilation of julia programs that we have been developing. First, there is a new compiler driver `juliac` that provides a more traditional gcc-like command-line interface. Next, we are adding new compiler modes that allow generation of smaller binaries by opting-in to assumptions that hold for some important classes of programs. false Slides https://pretalx.com/juliacon2024/talk/FUTLND/ https://pretalx.com/juliacon2024/talk/FUTLND/feedback/ REPL (2, main stage) Talk 2024-07-11T16:30:00+02:00 16:30 00:30 “GreenSpeed” leverages Julia and the GenieFramework to calculate sustainability KPIs for the synthesis of complex organic chemicals. We cover the display of chemical reaction trees, their visualization in a Sankey Diagram and editable trees and tables to allow for the manual correction of incomplete or wrong datasets. We also show an admin panel for debugging, file modification and application of hotfixes. juliacon2024-44479-greenspeed-sustainable-chemical-synthesis-right-from-the-start General Helmut HänselSara Wirsing en We will showcase "GreenSpeed", an innovative industrial application developed using Julia and the GenieFramework. GreenSpeed enables Merck to calculate sustainability Key Performance Indicators (KPIs) for complex organic chemical synthesis, facilitating informed decision-making and driving positive environmental change. Attendees will learn how GreenSpeed integrates electronic lab journals, allowing users to assess the environmental impact of different substances and their reactions. The application employs dynamic tree structures and visualization techniques, such as the Sankey Diagram, to illustrate the flow of materials during synthesis processes as well as the completeness of the underlying data. By utilizing Julia's computational power, GreenSpeed performs complex calculations and generates insightful visualizations, empowering businesses to make informed decisions about synthesis routes and optimize resource utilization. The application also supports dynamic selection fields, editable trees, and editable tables to allow for the manual correction of incomplete or wrong datasets. GreenSpeed's admin panel will be highlighted, providing system administrators with debugging tools, file modification capabilities, and the ability to apply hotfixes to ensure smooth operation and continuous improvement. The talk will present real-world examples, showcasing how Merck has utilized GreenSpeed to assess sustainability, identify improvement areas, and enhance production practices. In summary, the talk will offer attendees a comprehensive overview of GreenSpeed's capabilities in calculating sustainability KPIs for complex organic chemical synthesis. The application utilizes Julia and the GenieFramework to enable powerful and flexible web-based sustainability assessment, empowering businesses to make informed decisions, optimize resource utilization, and ensure a greener future. false https://pretalx.com/juliacon2024/talk/MQXHT9/ https://pretalx.com/juliacon2024/talk/MQXHT9/feedback/ REPL (2, main stage) Keynote 2024-07-11T17:10:00+02:00 17:10 01:00 Sonic Pi is a free code-based music creation and performance tool that targets both education and professional musicians. It is possible for beginners to code fresh beats, driving bass lines and shimmering synth riffs. All this whilst teaching core computer science concepts such as sequencing, functions, variables, loops, data structures and algorithms. This talk will briefly introduce Sonic Pi before taking a deep technical nose-dive into some of the interesting requirements of live coding. juliacon2024-45606-sonic-pi-live-coding-as-a-tool-for-next-gen-education General Sam Aaron en Sonic Pi is a free code-based music creation and performance tool that targets both education and professional musicians. It is possible for beginners to code fresh beats, driving bass lines and shimmering synth riffs. All this whilst teaching core computer science concepts such as sequencing, functions, variables, loops, data structures and algorithms. This talk will briefly introduce Sonic Pi before taking a deep technical nose-dive into some of the interesting requirements of live coding systems. We'll touch on concurrency, distributed programming, temporal logic, deterministic randomisation, event streams, hot swapping code and domain specific languages. Get ready for some serious live coded beats and a window into an exciting future of computing education. false https://pretalx.com/juliacon2024/talk/NT7MUE/ https://pretalx.com/juliacon2024/talk/NT7MUE/feedback/ REPL (2, main stage) Ceremony 2024-07-11T18:10:00+02:00 18:10 00:15 Closing the second day of JuliaCon Global 2024 and PyData Eindhoven 2024. juliacon2024-53122-closing-ceremony Rob de Wit en Closing the second day of JuliaCon Global 2024 and PyData Eindhoven 2024 with organizing committee member Rob de Wit. false https://pretalx.com/juliacon2024/talk/KCGZMP/ https://pretalx.com/juliacon2024/talk/KCGZMP/feedback/ If (1.1) Talk 2024-07-11T10:00:00+02:00 10:00 00:30 LIME, a model-agnostic AI framework, illuminates the path to local explainability, primarily for classification models. Delving into the theory underpinning LIME, we explore diverse use cases and its adaptability across various scenarios. Through practical examples, we showcase the breadth of applications for LIME. By the presentation's conclusion, you'll have gained insights into leveraging LIME to clarify individual prediction logic, leading to more accessible explanations. juliacon2024-52461-explainable-ai-in-the-lime-light PyData en Although AI toolkits have simplified model implementation, understanding and interpreting these models remain challenging. With regulatory frameworks like the EU AI Act emphasizing explainability, the need for tools like LIME is paramount. This presentation will provide an in-depth overview of LIME (Local Interpretable Model-agnostic Explanations), highlighting its utility in facilitating model comprehension. No prior expertise is assumed. Beginning with an explanation of LIME's theory and its practical implementation in Python, we'll then delve into diverse classification scenarios to showcase LIME's effectiveness. Additionally, we'll explore how the original LIME framework has been extended to handle time series data. false https://pretalx.com/juliacon2024/talk/SVFQT9/ https://pretalx.com/juliacon2024/talk/SVFQT9/feedback/ If (1.1) Talk 2024-07-11T11:15:00+02:00 11:15 00:30 This talk will explain the multifaceted risks associated with building custom AI solutions, both from Responsible AI and Safety perspectives, and explore ways to mitigate them, to ensure that as AI professionals we create non-harmful AI systems. juliacon2024-52469-risks-and-mitigations-for-a-safe-and-responsible-ai PyData en The rapid advancement of AI technologies, especially in the LLM space, is opening countless opportunities across all industries to apply in their daily business. However, it also introduces significant risks that could impact their users and broader society, from ethical and safety perspectives. In this talk we will delve into various aspects to consider when building custom AI solutions to ensure they are not harmful in any way. We'll explain the types of risks to assess from both Responsible AI and Safety perspectives, and what mitigations can be implemented to address them. We'll discuss broad aspects that apply to all AI systems, such as fairness and inclusiveness, as well as risks specific to Large Language Models, like prompt injection attacks and hallucinations. By the end of this talk, participants will have a clear understanding of AI risks, and a practical framework for evaluating and implementing responsible AI practices when building AI-based applications. The talk is designed for anyone involved in the design and development of AI systems, from AI developers and data scientists to project managers. No technical knowledge is required, but a prior understanding of the fundamentals of AI and LLMs is assumed. false https://pretalx.com/juliacon2024/talk/7ZY9VD/ https://pretalx.com/juliacon2024/talk/7ZY9VD/feedback/ If (1.1) Talk 2024-07-11T12:00:00+02:00 12:00 00:30 Last year I attended PyData Eindhoven for the first time. I got inspired and now I’m back to present my first neural network, a network that was trained to predict the Spring Classics of cycling! With this neural network, I’m attempting to beat my friends, and myself, in a well-known fantasy cycling game. juliacon2024-52457-predicting-the-spring-classics-of-cycling-with-my-first-nn PyData en Last year I attended PyData Eindhoven for the first time. I got inspired and now I’m back to present my first neural network, a network that was trained to predict the Spring Classics of cycling! With this neural network, I’m attempting to beat my friends, and myself, in a well-known fantasy cycling game. In this talk, I will elaborate on the process of building a model from scratch. This will include data collection, model training and finetuning, and of course a discussion of the predicted results. The predictions will also be compared to an existing cycling prediction platform that I use as benchmark. Lastly, I’ll try to provide some insights into the model using SHAP values. false https://pretalx.com/juliacon2024/talk/B7NCK9/ https://pretalx.com/juliacon2024/talk/B7NCK9/feedback/ If (1.1) Talk 2024-07-11T14:00:00+02:00 14:00 00:30 Through single-camera tennis match footage, via a YOLO-driven computer vision system, and culminating in actionable insights for strength and conditioning coaches, the Dutch Tennis Federation offers a pathway for creating tennis data and insights. In our presentation, we will delve into technical specifications and algorithms of our system, navigate through the challenges of working with tennis video footage, and elaborate on our approach to actively engage coaches in our co-creation approach. juliacon2024-52464-computer-vision-at-the-dutch-tennis-federation PyData en Tennis is seen within the community more as a skill sport than a physical sport. In this way, tennis is an exception compared to other ball sports, in which there is a primary focus on physical data (e.g., distance covered or time in specific speed zones). The primary use of data by now is tactical analysis, scouting your opponent, and finding specific tendencies. Currently, this is done by manually annotating events in game videos for further analysis, which can take up to 5 hours per match. One of the bottlenecks of this process is finding the start of a rally; the effective playing time is actually just 20-30% on clay courts and 10-15% on fast courts. This means that a 5-hour match would have just 30 minutes of playing time that needs to be annotated. Hence, automatically finding the start point of a rally and cutting videos into shorter sequences would tremendously speed up the annotation process and would allow scouting of more players and matches. In turn, we had two goals in the project. First, to create a solution to optimize the annotation process by providing videos when the ball is in play. The second goal was to provide tennis coaches and players with physical data and to stimulate the use of this type of data (user buy-in). For both of these goals, we faced specific challenges we needed to overcome. Event recognition has been achieved in other sports as well as in tennis using computer vision approaches, especially video tracking (trajectories and coordinates of the players). In tennis, the Hawk-Eye system is used in big tournaments to provide this information. By using 10 synchronized cameras, the system provides player and ball trajectories that enable event recognition and the extraction of physical variables. However, due to the costs of using this system and the complexity of installing it, using it in less prestigious tournaments or for training monitoring is not an option. To overcome this challenge, we created a one-camera computer vision system that allows for player tracking and simple event recognition. As mentioned earlier, the second challenge of this project is the buy-in by coaches, athletes, and the medical team to physical parameters for athlete monitoring and training optimization. To overcome this problem, we opted for an educational and co-creation approach. This entails, in an initial step, a presentation on the usage of physical data in other sports and their benefits. In a second step, we performed semi-structured interviews with potential end-users (coaches, athletes, medical staff, and performance analysts). Based on these interactive interviews, important variables for the end-users were defined. In addition, potential forms of data presentation and visualizations were discussed in order to create a dashboard for the end-users. In doing so, we improved the understanding of the end-users as well as the commitment to the project. In this talk, we will provide a summary of the general approach of the conducted interviews and how this resulted in an interactive dashboard for coaches, athletes, and analysts. In addition, we provide an overview of the pipeline of the computer vision approach. While using an “off-the-shelf” YOLO approach, several processing steps are necessary. This includes several technical challenges like player and court recognition as well as data filtering. We will also provide an example of how we enriched our pipeline with audio data to facilitate event recognition. All in all, we hope to provide an exemplary approach on how to conduct a data science project in a sports environment in which the conceptual barriers between product designer and end-user are often hard to overcome. false https://pretalx.com/juliacon2024/talk/UFHLEP/ https://pretalx.com/juliacon2024/talk/UFHLEP/feedback/ If (1.1) Talk 2024-07-11T14:45:00+02:00 14:45 00:30 Learn how to automate the generation of contextual metrics from tracking data to enrich event analysis, handling the influx of games arriving daily in an efficient way by scaling-out the entire architecture. juliacon2024-52459-enhancing-event-analysis-at-scale-leveraging-tracking-data PyData en In the dynamic landscape of sports analytics, the integration of tracking data has opened new frontiers for in-depth event analysis. Yet, the use of this data remains a bottleneck, particularly when dealing with a large volume of games. Indeed, such computation is either too expensive or too long. The focus of the presentation will be on automating the generation of these contextual metrics at scale, and their usage by professionals and decision-makers. The presentation will showcase an architecture and an automated pipeline designed to handle the influx of games. Leveraging Python and cloud computing services such as message queues, we efficiently manage incoming game data by scaling the infrastructure based on the workload, ensuring optimal performance during peak period while minimizing costs during quieter times. The presentation will strike a balance between technical depth and practical application. Attendees will gain insights into the architecture required to efficiently process hundreds of games weekly, while accommodating the thousands already present in the database. The advantage granted by this method will be quantified in terms of time and resources to inform data scientists and data engineers the efficiency they could reach. false https://pretalx.com/juliacon2024/talk/SHWFR7/ https://pretalx.com/juliacon2024/talk/SHWFR7/feedback/ If (1.1) Talk 2024-07-11T15:45:00+02:00 15:45 00:30 People have been using machine learning for sports betting for decades. Logistic regression applied to horse racing made someone a multi-millionaire in the 80s. While fun, betting is a losing proposition for most. The house always wins, right? juliacon2024-52465-how-i-lost-1000-betting-on-cs-go-with-machine-learning PyData en With a friend, I thought we could beat the house in e-sports by leveraging modern ML tools like LightGBM. E-sports betting is less sophisticated than football or horse racing i.e. the market is less efficient. There is a lot of online data and unknown teams. It was a space ripe for money-making, or so we thought. First, I will explain the theory behind e-sports betting with ML: what is an edge, financial decision-making, the expected value and decision rule for one bet, multiple bets with the Kelly criterion, probability calibration and the winner's curse. Then, I will explain how we built a web scraper to extract features, developed a probabilistic classifier using LightGBM, defined betting rules using the Kelly criterion, backtested it with a positive ROI, and then lost actual money, with many priceless lessons coming out of it. This presentation goes in-depth on how to use ML for e-sports betting and the pitfalls one might fall in. More broadly, I try to connect ML with financial decision-making, which can be applied in other domains too (credit, fraud, marketing), targeting data scientists and ML practitioners who are interested in financial applications. Financial decision-making is not just about being right (predictive modelling) but also about acting rightly (betting/trading strategy). To act correctly, one must understand concepts such as an edge, expected value/profits, probability calibration, winner's curse (selection bias), and so on. More importantly, any trading or betting strategy needs to be thoroughly validated with backtests and paper-trades and the risk and profitability quantified. My aim is to cover some of those important foundational topics, while providing pointers for further studies. The presentation is divided into two parts: 1. Foundations of ML applied to betting (15 min) * What is your edge? * Financial decision-making with ML * One bet: Expected profits and decision rule * Multiple bets: The Kelly criterion * Probability calibration * Winner’s curse 2. CS:GO betting (10 min) * Data scraping * Feature engineering * TrueSkill (with a side note on inferential vs predictive models) * Modelling * Evaluation * Backtesting * Why I lost 1000 euros That is, I will present both the theory and practice, using my own failure as an illustrative example for the lessons shown. The presentation will have two companion blog posts with reproducible Python code. This presentation requires mid-level data science knowledge (e.g. how to train a gradient-boosted trees model) but only beginner Python and finance to follow. false https://pretalx.com/juliacon2024/talk/MEEMYT/ https://pretalx.com/juliacon2024/talk/MEEMYT/feedback/ If (1.1) Talk 2024-07-11T16:30:00+02:00 16:30 00:30 A case study of how we use Deep Learning based photogrammetry to calculate the height of trees from very high resolution satellite imagery. We show the substantial improvement achieved by switching from classical photogrammetric techniques to a deep learning based model (implemented in PyTorch), and the challenges we had to overcome to make this solution work. juliacon2024-52468-the-taller-the-tree-the-harder-the-fall PyData en The risk that a tree poses to line infrastructure (such as power lines) is determined by several factors, chief among them the height of the particular tree. The increasing availability of very high resolution satellite imagery makes it possible to use photogrammetric techniques to extract height information from a set of stereo satellite images. By using satellite imagery we can achieve a scale not possible by manual measurement. We found that classical techniques perform poorly on vegetation, and were handily outperformed by deep learning based techniques implemented in PyTorch. This improvement was not trivial to achieve however, as creating labelled data in sufficient quantity was quite challenging. By increasing the quality of our height predictions we were able to more accurately calculate risk for our customers. false https://pretalx.com/juliacon2024/talk/ZAQGTJ/ https://pretalx.com/juliacon2024/talk/ZAQGTJ/feedback/ Else (1.3) Talk 2024-07-11T10:00:00+02:00 10:00 00:30 By means of Topic Modeling, discussed topics can be subtracted from a set of documents. BERTopic is a way of Topic Modeling that uses Large Language Models. A high-level overview of how BERTopic works will be presented, together with its evaluation and the application of it on a use case of the Netherlands Red Cross. In this use case, BERTopic supports in getting insights into the needs of Ukrainian refugees as expressed through social media. juliacon2024-52466-bertopic-to-accelerate-ukrainian-aid-by-the-red-cross PyData en 510, the Data & Digital initiative of the Netherlands Red Cross, is performing Social Media Listening on Telegram channels of Ukrainian refugees, to obtain insights in their needs. As a result, the Red Cross can direct its aid more purposefully. Obtaining such insights can be a time-intensive task, while in case of an emergency, one would like to initialize aid as quickly as possible. BERTopic has shown to be a powerful tool in quickly obtaining an overview of the discussion on social media. In this presentation, a high-level explanation of BERTopic will be provided, which is a LLM-based method to obtain topics from a set of documents and categorize them accordingly. Other than basic machine learning knowledge, no further background knowledge is required. Rather than explaining how an LLM works, we will focus on what its task in BERTopic is. Next, we will discuss the evaluation of BERTopic, which is a challenging task, as it is an unsupervised method. Three different metrics are proposed, including an innovative approach that creates a test set with GPT. Finally, the application and results of BERTopic to the described use case will be discussed. This will show the practicality of BERTopic and hopefully inspire for other applications. Time breakdown: - Introduction to the Red Cross use case: 5 min - BERTopic: 10 min - Evaluation: 5 min - Application and results: 5 min - Q&A: 5 min false https://pretalx.com/juliacon2024/talk/TXH9RG/ https://pretalx.com/juliacon2024/talk/TXH9RG/feedback/ Else (1.3) Talk 2024-07-11T11:15:00+02:00 11:15 00:30 LLM's can be supercharged using a technique called RAG, allowing us to overcome dealbreaker problems like hallucinations or no access to internal data. RAG is gaining more industry momentum and is becoming rapidly more mature both in the open-source world and at major Cloud vendors. But what can we expect from RAG? What is the current state of the tech in the industry? What use-cases work well and which are more challenging? Let's find out together! juliacon2024-52460-the-levels-of-rag PyData en Retrieval Augmented Generation (RAG) is a popular technique to combine retrieval methods like vector search together with Large Language Models (LLM's). This gives us several advantages like retrieving extra information based on a user search query: allowing us to quote and cite LLM-generated answers. Because the underlying techniques are very broadly applicable, many types of data can be used to build up a RAG system, like textual data, tables, graphs or even images. In this talk, we will deep dive into this popular emerging technique. Together, we will learn about: what the current state of RAG is, what tech is available to support you and what you expect to work well and what is still very challenging. Join us if you 🫵: - Are interested in GenAI / LLM's and RAG - Want to know more about the current state of RAG - Would like to know when you can most successfully apply RAG ### Contents of the talk 📌 1. [2 min] Intro 2. [3 min] Why RAG? 1. The case for RAG 2. The RAG advantage 3. … so how-to RAG? 3. [10 min] Basic RAG: Which ingredients make up a successful RAG system? 1. Data ingestion (OCR, PDF reading) 2. Chunking 3. Vector search 4. Keyword search 5. Mapping these components to the tech landscape 6. 💥 Encountering difficulties 4. [10 min] Advanced RAG: Going multimodal 1. Tabular data 2. Graphs 3. Images 5. [4 min] Summing things up 1. The levels of RAG: from basic to advanced 2. GenAI community 🫂 3. Concluding remarks 6. [1 min] End [30 minutes total] ### ❤️ Open Source Software RAG and LLM’s are presented in a cloud-agnostic way. Many of the software libraries mentioned are open source. There is no agenda for representing any major cloud. false https://pretalx.com/juliacon2024/talk/CC9TZZ/ https://pretalx.com/juliacon2024/talk/CC9TZZ/feedback/ Else (1.3) Talk 2024-07-11T12:00:00+02:00 12:00 00:30 Many of us know scikit-learn for it's ability to construct pipelines that can do .fit().predict(). It's an amazing feature for sure. But once you dive into the codebase ... you realise that there is just so much more. This talk will be an attempt at demonstrating some extra features in scikit-learn, and it's ecosystem, that are less common but deserve to be in the spotlight. In particular I hope to discuss these things that scikit-learn can do: - sparse datasets and models - larger than mem juliacon2024-52456-scikit-learn-can-do-that PyData en There may be an opportunity to live code some of these examples, but if live coding is not possible it'd be preferable to know this ahead of time. false https://pretalx.com/juliacon2024/talk/B8ACUX/ https://pretalx.com/juliacon2024/talk/B8ACUX/feedback/ Else (1.3) Talk 2024-07-11T14:00:00+02:00 14:00 00:30 Large Language Models are everywhere these days. But how can you objectively evaluate whether a model or a prompt is performing properly? Let's dive into the world of LLM evaluation frameworks! juliacon2024-52454-evaluating-llm-frameworks PyData en At CM.com we have released a new GenAI product (in 2023, built in Python) which is currently used by over 50 clients in various countries. GenAI is a chatbot that leverages the power of LLMs, while protecting against their common pitfalls such as incorrectness & inappropriateness, by using a Retrieval Augmented Generation framework (RAG). As newer & better models rapidly arise, and our clients continue to provide feedback on the product, our own product development cannot lag behind. But how do we know whether changing from e.g. ChatGPT to Gemini or Llama improves the replies for all conversations? And how can you do prompt optimization if you don't know what you're optimizing against? To help us maintain our current chatbot quality while investigating other models/prompts, we have developed an evaluation framework in Python that can objectively evaluate several scenarios across a various of metrics. During these 30 minutes, I'll explain the principle behind RAG, highlight the huge development work being done in this field across the globe, give examples of several evaluation measures, and finally explain how we use these to move forward with our product. The talk is most interesting for Data Scientists and ML/AI/Prompt Engineers, but can be followed by anyone with some background knowledge on LLMs. false https://pretalx.com/juliacon2024/talk/TYBKXE/ https://pretalx.com/juliacon2024/talk/TYBKXE/feedback/ Else (1.3) Talk 2024-07-11T14:45:00+02:00 14:45 00:30 Conventional A/B testing often falls short in industries such as airlines, ride-sharing, and delivery services, where challenges like small samples and subtle effects complicate testing new features. Inspired by its significant impact in leading companies like Uber, Lyft, and Doordash, we introduce the switchback design as a practical alternative to conventional A/B testing. juliacon2024-52463-maximizing-marketplace-experimentation PyData en By addressing small sample size limitations and the need to detect subtle effects quickly, this approach boosts statistical power while reducing variability and interference. We guide the audience through the challenges of marketplace experimentation and implementing this approach, period length optimization and switch frequency using a case study from the airline industry. In this talk, we introduce switchback design, a method that addresses key challenges in marketplace experimentation faced by sectors like airlines and ride-sharing. It addresses traditional A/B testing's limitations on small samples and subtle effects, highlighted by successes in companies like Uber, Lyft, and Doordash. This approach, crucial for accurate effect measurement, aims to boost decision-making and operational optimization, supported by a practical case study. Talk outline: - Introduction (5 mins): Quick intro to our expertise and the topic's relevance. - Challenges (5 mins): Overview of marketplace experimentation challenges. - Switchback Design (5 mins): Basics of switchback design vs. traditional A/B testing. - Case Study (10 mins): Real-world application in the airline industry, showcasing benefits and drawbacks. - Key Takeaways (5 mins): Summary of our talk. - Q&A (10 mins): Open discussion for clarifications and further insights. The intended audience: Targeted at data scientists, data analysts, product managers, and anyone interested in data-driven decision-making. Ideal for those curious about experimentation and causal inference in sectors like tech and e-commerce. No background needed: Open to all levels, no prior knowledge needed. Concepts will be explained simply, focusing on practical insights without complex math. The takeaway for the audience: The audience will understand the effectiveness of switchback design in overcoming marketplace experimentation hurdles, such as dealing with small samples and subtle effects. They'll learn from the success stories of top firms, understand practical steps for executing switchback experiments, and recognize its advantages over conventional A/B testing for more informed decisions and improved results. false https://pretalx.com/juliacon2024/talk/LKTMNN/ https://pretalx.com/juliacon2024/talk/LKTMNN/feedback/ Else (1.3) Talk 2024-07-11T15:45:00+02:00 15:45 00:30 In this speech, we want to introduce an AI PC, a single machine that consists of a CPU, GPU, and NPU (Neural Processing Unit) and can run GenAI in seconds, not hours. Besides the hardware, we will also show the OpenVINO Toolkit, a software solution that helps squeeze as much as possible out of that PC. Join our talk and see for yourself the AI PC is good for both generative and conventional AI models. All presented demos are open source and available on our GitHub. juliacon2024-52462-cloud-no-thanks-i-m-gonna-run-genai-on-my-ai-pc PyData en In this speech, we want to introduce an AI PC, a single machine capable of hosting diverse AI applications that can run GenAI in seconds, not hours. Such an approach for local AI allows us to overcome the usual issues associated with Cloud AI, such as the risk of data privacy breaches, high latency, and dependency on a connection to the cloud. Besides the AI PC, we will also showcase the OpenVINO Toolkit, which is an open-source toolkit for optimizing and deploying deep learning models. It helps to maximize the AI performance of the PC. Join our talk and see for yourself how the AI PC is well-suited for both generative and conventional AI models. All the presented demos, such as background blurring and image generation using a latent consistency model, are open-source and available on our GitHub. false https://pretalx.com/juliacon2024/talk/NYZ8C8/ https://pretalx.com/juliacon2024/talk/NYZ8C8/feedback/ Else (1.3) Talk 2024-07-11T16:30:00+02:00 16:30 00:30 A lot of industry-available Machine Learning solutions for causal forecasting have a very particular blind spot: unobserved confounders. We will present an approach that allows you to combine state-of-the-art Machine Learning approaches with advanced Econometrics techniques to get the better of both worlds: accurate causal inference and good forecasting accuracy. juliacon2024-52458-causal-forecasting-how-to-disentangle-causal-effects PyData en Causal Forecasting is a very hot topic in the industry with many applications ranging from marketing spending to pricing. Disentangling causal effects from spurious correlations plays a key role when forecasts are used for decision making, such as in the case of pricing. Solutions available in the industry typically rely on Machine Learning methods that use techniques like DoubleML, Transformers, LSTM, and boosted tree algorithms. A common shortcoming of such solutions is that they do not account for the existence of unobserved confounders, such as world events, or other hard-to-measure effects that can bias the measurement of causal effects. We showcase a solution that was developed over the last 3 years that addresses these challenges by combining advanced Econometrics methods with ML techniques. The case-study will focus on the example of retail pricing, but the solution is broadly applicable and it has been tested in different settings, including airline pricing. false https://pretalx.com/juliacon2024/talk/QZZQLF/ https://pretalx.com/juliacon2024/talk/QZZQLF/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-11T10:00:00+02:00 10:00 01:00 What do you need? Come to this BoF to discuss how you are using SciML today, what issues you are running into, and what needs to be done for improving the future of Julia's SciML stack! juliacon2024-43881-needs-and-next-steps-for-julia-s-sciml SciML Chris Rackauckas en What are your biggest issues? Scaling in Optimization.jl? More tutorials in ModelingToolkitStandardLibrary.jl? It's always hard for the developers to know the general prioritization sentiment of the community, and thus this BoF is made to get a sample from users to better understand the needs of the community. false https://pretalx.com/juliacon2024/talk/8JTLHZ/ https://pretalx.com/juliacon2024/talk/8JTLHZ/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-11T14:00:00+02:00 14:00 01:00 Come to this BoF to discuss the recent massive changes in BinaryBuilder and to discuss further development of ecosystem-wide improvements. Applicable topics include: improvements to BinaryBuilder proper, improvements to Yggdrasil and surrounding infrastructure, improvements to JLLs, applications of the new modularized BinaryBuilder ecosystem to new projects, and more! juliacon2024-43910-binarybuilder-bof Julia Internals and Tooling Valentin ChuravyElliot SabaMosè Giordano en [BinaryBuilder](https://binarybuilder.org/) is a fundamental piece of the infrastructure underpinning Julia: it's used to compile most of the binary libraries used throughout the ecosystem, including those used by Julia itself. BinaryBuilder has undergone significant changes over the last year, see the talk "Binary Builder 2: Return of the Compilers" for a guided tour of many of the improvements and refactorings. In particular, the structure of BinaryBuilder has been split apart into multiple separate sub-packages that can each be used in isolation. This allows, for instance, a package that needs to compile C code to make use of the BB compiler toolchain without actually using all of BB itself, or a package that needs to inspect binaries for relocatability to do so in isolation. This BoF is intended to facilitate discussion between developers and users of the BinaryBuilder ecosystem to better understand these changes and how they can impact the ecosystem at large. Topics of discussion could include: - Improvements to BinaryBuilder proper - Improvements to Yggdrasil and surrounding infrastructure - Improvements to JLLs - Applications of the new modularized BB ecosystem to new projects false GitHub https://pretalx.com/juliacon2024/talk/BXJWED/ https://pretalx.com/juliacon2024/talk/BXJWED/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-11T15:00:00+02:00 15:00 01:00 Rust keeps gaining ground across the software world! How can we best learn and exchange algorithms and best practices? juliacon2024-44414-rust-and-julia-birds-of-a-feather General Miguel Raz Guzmán Macedo en Last year's Rust BoF was a smash success, with a full room and dozens of participants. We should step up and reach out to the burgeoning Rust audience in NL and across the globe by making decisions about what Julia can learn from Rust and vice versa. false https://pretalx.com/juliacon2024/talk/V99NUF/ https://pretalx.com/juliacon2024/talk/V99NUF/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-11T16:00:00+02:00 16:00 01:00 The JuliaGPU community welcomes both long-standing contributors and newcomers to a birth-of-the feather event on the state of the JuliaGPU ecosystem. juliacon2024-44434-juliagpu-bof Accelerated & large-scale computing Valentin ChuravyTim BesardKatharine Hyatt en The JuliaGPU ecosystem enables Julia to run on a wide variety of accelerators ranging from traditional GPUs like NVIDIA, Intel or AMD to more interesting ones like IPUs. The meeting gives users and developers alike the opportunity to exchange ideas. false https://pretalx.com/juliacon2024/talk/MWS3FD/ https://pretalx.com/juliacon2024/talk/MWS3FD/feedback/ Method (1.5) Lightning talk 2024-07-11T10:00:00+02:00 10:00 00:10 Wouldn’t it be great if Julia would program itself? You simply tell it what you want, Julia magic happens, and you have your program. While this is still a farfetched dream, in this talk we will introduce you to Herb.jl, a Julia library that gets us a step closer to our big goal. juliacon2024-44371-herb-jl-teaching-programs-how-to-program-with-program-synthesis General /media/juliacon2024/submissions/JDPTKN/herb_blue_white_background_TPRbo5W.png Tilman Hinnerichs en `Herb.jl` is a library for program synthesis: the task of automatically generating (not just) programs from a given specification. `Herb.jl`’s main goal is therefore two-fold. First, it aims to provide a missing toolbox for developing new program synthesizers, which is currently missing in the community. Second, it aims to unify many different flavours of program synthesis under a joint framework, making existing program synthesizers easy to use on new problems. In this talk we show how Julia facilitates the library development on one hand, but also algorithm speed and composability of the synthesis procedure. false Presentation slides https://pretalx.com/juliacon2024/talk/JDPTKN/ https://pretalx.com/juliacon2024/talk/JDPTKN/feedback/ Method (1.5) Lightning talk 2024-07-11T10:10:00+02:00 10:10 00:10 The Functional Mock-Up Interface is a tool-independent standard for implementing and describing models given by differential algebraic equations with events. FMIExchange.jl integrates such models with DifferentialEquations.jl, thereby retaining the full capabilities of that package. The resulting functionality forms a powerful extension to that of the existing FMI.jl package, allowing the user to simulate complex systems with multiple native and FMI-compliant components. juliacon2024-42841-fmiexchange-jl-foreign-models-through-a-familiar-interface General Lucas Bex en The Functional Mock-Up Interface (FMI) standard allows to exchange models between different software programs. To simulate FMI-compliant models (functional mock-up units, FMUs), Julia currently relies on the FMI.jl package and its subpackages, but these packages do not cover all use cases: FMI.jl does not allow to simulate multiple FMUs simultaneously, nor to cosimulate FMUs and native Julia differential equations. FMI.jl implements basic input/output functionality to interact with FMUs, but the interface is difficult to use when FMU inputs change at different timescales. More advanced functionality requires directly interacting with FMU objects, which is not user-friendly. FMIExchange.jl aims to solve these issues by leveraging the well-known interface of DifferentialEquations.jl and combining it with the functionality of the existing FMI simulation suite. FMIExchange.jl wraps FMUs in structs such that they can be used in a traditional differential equation (DE) solver as implemented in the SciML ecosystem. FMIExchange.jl automatically generates appropriate callbacks to detect and trigger events in the FMU, and mimics the traditional DifferentialEquations.jl interface for obtaining derivatives. FMU inputs and outputs are handled by using the parameter argument "p" as a memory buffer to store them. Manipulating this buffer using the callback library provided by the SciML ecosystem provides many ways to interact with the simulation. Typical examples are implementing digital controllers or defining interactions between different models. It is possible to combine multiple FMUs and native Julia DEs in one simulation by subdividing the memory buffer into sections. To simplify this process, FMIExchange.jl provides tools to automatically assign and keep track of addresses and to perform common operations such as connecting model inputs and outputs. All this functionality is available for both native DEs and FMUs, such that the user can interact with all simulation components in an implementation-agnostic way. The presentation will briefly introduce the FMI standard and then discuss the design of FMIExchange.jl. The package will be demonstrated on a case study involving model-predictive control of multiple flexible electrical loads in a residential building. The case study combines multiple FMUs and native ODEs in a single simulation, showing FMIExchange.jl in action in a realistic context. false Github Presentation (Pluto, html, pdf) https://pretalx.com/juliacon2024/talk/XBSX87/ https://pretalx.com/juliacon2024/talk/XBSX87/feedback/ Method (1.5) Lightning talk 2024-07-11T10:20:00+02:00 10:20 00:10 Amidst the surge in novel spectral indices for the increasing volume of remote sensing data with higher spatial, temporal, and spectral resolutions, this Julia package offers a comprehensive solution for their easy access and efficient computation. It features a user-friendly interface and robust processing capabilities. SpectralIndices.jl works with the most used data types (i.e. data frames), as well as with data types tailored for Earth system science (e.g. YAXArrays). juliacon2024-44412-enabling-spectral-indices-computation-with-spectralindices-jl General Francesco Martinuzzi en In this talk, we will showcase SpectralIndices.jl (https://github.com/awesome-spectral-indices/SpectralIndices.jl), a Julia package developed to simplify the access and computation of spectral indices in remote sensing data analysis. The presentation will offer a comprehensive overview of the package's capabilities, emphasizing its application in Earth system research. Key topics to be covered include: 1. Spectral Indices: Basic introduction. 2. Package Overview: Introduction to SpectralIndices.jl, its design philosophy, and the specific challenges it addresses in remote sensing data analysis. 3. Accessing Spectral Indices: Demonstrating how the package provides streamlined access to a wide range of spectral indices, including both well-established and newly developed indices. 4. Data Compatibility and Processing: Exploring the package's compatibility with various remote sensing data types and formats. We will demonstrate how SpectralIndices.jl can be applied to different datasets. 5. User Interface and Usability: Showcasing the user-friendly interface of SpectralIndices.jl. The presentation will include live coding examples to illustrate the ease of computing spectral indices with minimal coding effort, making the tool accessible to users with and without remote sensing expertise. 6. Future Directions: Outlining the ongoing development and future plans for SpectralIndices.jl. We will discuss potential enhancements, community collaboration opportunities, and the envisioned roadmap for the package. By the end of this talk, attendees will have a deep understanding of SpectralIndices.jl's technical features, its application in remote sensing research, and how it contributes to advancing Earth system science through efficient data analysis and community-driven development. This work is done in collaboration with Miguel D. Mahecha, David Montero and Karin Mora. false Slides https://pretalx.com/juliacon2024/talk/FMHLCX/ https://pretalx.com/juliacon2024/talk/FMHLCX/feedback/ Method (1.5) Talk 2024-07-11T10:30:00+02:00 10:30 00:30 ProbNumDiffEq.jl implements probabilistic numerical ODE solvers for the DifferentialEquations.jl ecosystem. These methods intepret "solving an ODE" as a probabilistic inference task, and they return a probabilistic estimate of the numerical solution and approximation error. Under the hood, this is done with extended Kalman filtering - but to the user, it looks like any other DifferentialEquations.jl solver. This talk presents ProbNumDiffEq.jl, its functionality, and some implementation details. juliacon2024-43492-fast-probabilistic-inference-for-odes-with-probnumdiffeq-jl Math(s) Nathanael Bosch en _Probabilistic numerical methods_ interpret numerical problems as problems of Bayesian inference, and then solve them accordingly. For ODEs, one popular class of such methods treats ODEs as Bayesian state estimation problems, and then essentially solves the ODE with a Bayesian filtering and smoothing method such as the extended Kalman filter. [ProbNumDiffEq.jl](https://github.com/nathanaelbosch/ProbNumDiffEq.jl) provides an efficient implementation of these methods and makes them availabe in the the DifferentialEquations.jl ecosystem. This talk starts with a brief introduction to probabilistic numerics and to probsbilistic ODE solvers, and then presents ProbNumDiffEq.jl. We will cover some example usages for different problem types, then dive into some implementation details that matter to make these solvers stable and fast, share some experiences on working with other Julia packages, and discuss the future prospects of probabilistic numerics within the Julia ecosystem. ### Features of ProbNumDiffEq.jl For a new user, ProbNumDiffEq.jl looks just like a standard ODE solver library and it covers many features that users often want from solvers: - Explicit and semi-implicit solvers of varying order - Specialized solvers: - for second-order ODEs - for Manifolds (using a specific callback) - Exponential integrators - Rosenbrock-type exponential integrators - Adaptive step-size selection (inherited from OrdinaryDiffEq.jl) - Dense output - Plotting - Callback support (inherited from OrdinaryDiffEq.jl) - All solvers are compatible with mass-matrix DAEs In addition, ProbNumDiffEq.jl also has many features that relate to the probabilistic formulation of the solves, and provides a range of _priors_, multiple _calibration_ approaches, and a _likelihood model_ for parameter estimation. ### Links - **Github repository:** https://github.com/nathanaelbosch/ProbNumDiffEq.jl - **Tutorial** Getting started with ProbNumDiffEq.jl: https://nathanaelbosch.github.io/ProbNumDiffEq.jl/dev/tutorials/getting_started/ - **References:** https://nathanaelbosch.github.io/ProbNumDiffEq.jl/dev/references/ false GitHub Slides https://pretalx.com/juliacon2024/talk/XQEBNS/ https://pretalx.com/juliacon2024/talk/XQEBNS/feedback/ Method (1.5) Lightning talk 2024-07-11T11:00:00+02:00 11:00 00:10 GeoInterface.jl aims to streamline working with geospatial vector data for users and developers of Julia packages. The package describes a set of traits based on the Simple Features standard. Using these traits it is easy to parse, serialize and use different geometries in the Julia ecosystem, without knowing the specifics of each package. GeoInterface is like Tables.jl, but for geometries. Lately, we have made improvements to conversion, plotting, and plan support for projections, among others. juliacon2024-44417-what-s-new-with-geointerface-jl-traits-for-interoperability General Rafael SchoutenMaarten Pronk en The GeoInterface.jl package defines a set of traits for geospatial vector data, based on the Simple Features standard. This includes standards objects. Points, LineStrings, Polygons, MultiPolygons, Features, etc. and support for operations, such as buffer and intersects. Packages across the ecosystem implement these traits to ensure inter-compatibility of their objects: Shapefile.jl GeoJSON.jl ArchGDAL.jl GeometryBasics.jl WellKnownGeometry.jl LibGEOS.jl KML.jl LazIO.jl Other packages like AlgebraOfGraphics.jl, Rasters.jl, GeoDataframes.jl, Leaflet.jl and Tyler.jl, can consume these objects without having to know from which package the object comes from. This increases the user-friendliness of the geospatial ecosystem by allowing geometries from different sources in packages that implement analyses without having to explicitly convert the data. In the last year we have made improvements to the (automatic) conversion of geometries, the plotting (using Makie) of geometries, and we improved the performance of some implementations. We also improved GeoFormatTypes and Extents, packages used in tandem with GeoInterface. Inspired by the mature R spatial ecosystem, we plan on implementing support for automatically distinguishing geographic and projected geometries. We also consider implementing some form of raster support, to enable more geospatial operations. false Github presentation https://pretalx.com/juliacon2024/talk/JXA7YR/ https://pretalx.com/juliacon2024/talk/JXA7YR/feedback/ Method (1.5) Lightning talk 2024-07-11T11:10:00+02:00 11:10 00:10 Avoiding allocations is crucial when writing performant Julia, so we developed AllocCheck.jl, a package that provides tools for developing and statically enforcing allocation-free code. juliacon2024-43375-writing-allocation-free-julia-code-with-alloccheck-jl Julia Internals and Tooling Gabriel BaraldiCody Tapscott en In this talk we will present AllocCheck.jl and give a quick example of how to use it, touring it's functionality and possible applications. Specifically around it's main entry point `@check_allocs, which is used to check whether a function allocates or not. We'll dive into the three major sources of allocations in Julia code (object creation, dynamic dispatch, allocations by the runtime) and show how AllocCheck.jl can help you identify where in your code these problems arose. You'll see some of the common challenges and solutions when writing allocation-free code, and how to dive further with other tools in the ecosystem (such as Cthulhu.jl). This tool also makes it possible to deploy Julia safely for specialized applications, such as running long simulation loops on embedded hardware where allocation-free code is vital for safe operation of your hardware. In this talk, we'll break apart what's needed to safely write code for these stringent applications and what extra requirements this implies for your code. AllocCheck.jl works by inspecting the optimized LLVM IR and doing static analysis over it, figuring out if and where allocations happen, what is type of the objects being allocated, and if the allocation site is in an error path. false slides slides pdf https://pretalx.com/juliacon2024/talk/EJXYNM/ https://pretalx.com/juliacon2024/talk/EJXYNM/feedback/ Method (1.5) Lightning talk 2024-07-11T14:00:00+02:00 14:00 00:10 We present a package for [Recursive Causal Discovery](https://arxiv.org/abs/2403.09300) for learning the causal relationships between variables. The package, called RecursiveCausalDiscovery.jl, contains, so far, the implementation of one algorithm called Recursive Structural Learning (RSL), which efficiently utilizes underlying side-information about the structure of the graph that relates the variables to one another. juliacon2024-44164-recursive-causal-discovery-with-julia General Sepehr Elahi en The problem of causal discovery seeks to determine causal relationships between variables. Unlike traditional statistical methods which often focus on identifying correlations, causal discovery aims to understand how changes in one variable can directly influence or cause changes in another. Algorithms for causal discovery use data, alongside with statistical methods, to determine such causal relationships. The Julia package for causal discovery, [CausalInference.jl](https://mschauer.github.io/CausalInference.jl/latest/), implements some score-based and constraint-based algorithms for causal discovery, such as the parent-child (PC) algorithm. However, such algorithms often require conditional independence (CI) tests with large conditioning sets or a large number of CI tests which grows exponentially as the number of variables increases. Moreover, we often have side-information about the structure of the underlying graph that relates the variables to one another, knowing which can drastically reduce the learning complexity. To this end, [Mokhtarian et al., 2022](https://ojs.aaai.org/index.php/AAAI/article/view/20750) present an algorithm called Recursive Structural Learning (RSL) algorithm, which incorporates side-information about the underlying graph and performs a polynomial number of CI tests. Further, [Recursive Causal Discovery](https://arxiv.org/abs/2403.09300) is a class of efficient algorithms for efficiently learning causal graphs using side-information. In our package, called [RecursiveCausalDiscovery.jl](https://github.com/sepehr78/RecursiveCausalDiscovery.jl), we implement RSL and in doing so we create a framework that would allow for implementing other recursive causal discovery algorithms, such as [L-MARVEL](https://proceedings.neurips.cc/paper/2021/hash/53edebc543333dfbf7c5933af792c9c4-Abstract.html) and [MARVEL](https://proceedings.mlr.press/v150/mokhtarian21a), in the future. The lightning talk will be structured as follows: Basic background on causality: 2 min Brief overview of causal discovery and the PC algorithm: 2 min Recursive causal discovery (RCD): 2 min Our implementation of RCD and our package, [RecursiveCausalDiscovery.jl](https://github.com/sepehr78/RecursiveCausalDiscovery.jl): 3 min Q&A: 1 mins false Presentation files GitHub https://pretalx.com/juliacon2024/talk/FYFNAR/ https://pretalx.com/juliacon2024/talk/FYFNAR/feedback/ Method (1.5) Lightning talk 2024-07-11T14:20:00+02:00 14:20 00:10 [TrillionDollarWorlds.jl](https://github.com/pat-alt/TrillionDollarWords.jl) provides access to a novel financial dataset and large language model fine-tuned for classifying central bank communications as either 'hawkish', 'dovish' or 'neutral'. It ships with essential functionality for model probing, an important aspect of mechanistic interpretability. juliacon2024-44128-trillion-dollar-words-in-julia Economics /media/juliacon2024/submissions/PTQLR9/rmse_pca_128_3oi0PQb.png Patrick Altmeyer en In the age of forward guidance, central bankers spend a great deal of time thinking about how their communications are perceived by markets. What if there was a way to predict the impact of communications on financial markets directly from text? Shah, Paturi, and Chava (2023) attempt to do just that in their [ACL 2023 paper](https://arxiv.org/abs/2305.07972) (which the author of this package is not affiliated with). ### Background The authors of the paper have collected and preprocessed a corpus of around 40,000 time-stamped sentences from meeting minutes, press conferences and speeches by members of the Federal Open Market Committee (FOMC). The total sample period spans from January, 1996, to October, 2022. In order to train various rule-based models and large language models (LLM) to classify sentences as either ‘hawkish’, ‘dovish’ or ‘neutral’, they have manually annotated a subset of around 2,500 sentences. The best performing model, a large RoBERTa model with around 355 million parameters, was open-sourced on [HuggingFace](https://huggingface.co/gtfintechlab/FOMC-RoBERTa?text=A+very+hawkish+stance+excerted+by+the+doves). ### Data While the authors of the paper did publish their data, much of it is unfortunately scattered across CSV and Excel files stored in a public GitHub repo. We have collected and merged that data, yielding a combined dataset with indexed sentences and additional metadata that may be useful for downstream tasks. ``` julia julia> using TrillionDollarWords julia> load_all_sentences() |> names 8-element Vector{String}: "sentence_id" "doc_id" "date" "event_type" "label" "sentence" "score" "speaker" ``` In addition to the sentences, market data about price inflation and the US Treasury yield curve can also be loaded. All datasets are loaded as `DataFrame`s and share common keys that make it possible to join them. Alternatively, a complete dataset combining the corpus of sentences with market data can also be loaded with `load_all_data()`. ### Loading the Model The model can be loaded with or without the classifier head. Under the hood, we use [Transformers.jl](https://github.com/chengchingwen/Transformers.jl) to retrieve the model from HuggingFace. Any keyword arguments accepted by `Transformers.HuggingFace.HGFConfig` can also be passed. For example, to load the model without the classifier head and enable access to layer-wise activations, the following command can be used: `load_model(; load_head=false, output_hidden_states=true)`. ### Model Inference For our own research, we have been interested in probing the model. This involves using linear models to estimate the relationship between layer-wise transformer embeddings and some outcome variable of interest (Alain and Bengio 2018). To do this, we first had to run a single forward pass for each sentence through the RoBERTa model and store the layerwise emeddings. The package ships with functionality for doing just that, but to save others valuable GPU hours we have archived activations of the hidden state on the first entity token for each layer as [artifacts](https://github.com/pat-alt/TrillionDollarWords.jl/releases/tag/activations_2024-01-17). To download the last-layer activations in an interactive Julia session, for example, users can proceed as follows: ``` julia julia> using LazyArtifacts julia> artifact"activations_layer_24" ``` We have found that despite the small sample size, the RoBERTa model appears to have distilled useful representations for downstream tasks that it was not explicitly trained for. The chart below shows the average out-of-sample root mean squared error for predicting various market indicators from layer activations. Consistent with findings in related work (Alain and Bengio 2018), we find that performance typically improves for layers closer to the final output layer of the transformer model. The measured performance is at least on par with baseline autoregressive models.  ### Intended Purpose We hope that this small package may be useful to members of the Julia community who are interested in the interplay between Economics, Finance and Artificial Intelligence. It should, for example, be straight-forward to use this package in combination with Transformers.jl to fine-tune additional models on the classification task or other tasks of interest. Any contributions are very much welcome. ## References Alain, Guillaume, and Yoshua Bengio. 2018. “Understanding Intermediate Layers Using Linear Classifier Probes.” Shah, Agam, Suvan Paturi, and Sudheer Chava. 2023. “Trillion Dollar Words: A New Financial Dataset, Task & Market Analysis.” false Github Link to slides (Revealjs) Link to slides (PDF) Slides (PDF) https://pretalx.com/juliacon2024/talk/PTQLR9/ https://pretalx.com/juliacon2024/talk/PTQLR9/feedback/ Method (1.5) Talk 2024-07-11T15:00:00+02:00 15:00 00:30 Julia is a great multi-purpose language, but it also fits in as a component in a larger multi-language ecosystem. At Akamai, we use Julia as part of our data pipeline to do Anomaly Detection and Alerting on web performance data. In this talk, I'll cover the tasks delegated to Julia as well as how it fits into the rest of our development and operations stack. juliacon2024-44109-using-julia-as-part-of-an-anomaly-detection-pipeline Data Science and Dynamics Philip Tellis en Julia is very good at running data analysis on columnar data and temporal data, ie, the kind of data we have a lot of where I work. We have packages to do regression analysis, hypothesis testing, signal processing, and more, allowing our development team to focus on business logic and data pipelines. In this talk, we'll cover how our Data Scientists use Julia to analyze data, and develop algorithms that can then be operationalized into a real time data pipeline and we'll see how Julia complements a Java based web application that handles data collection and alerting. false Online Presentation Downloadable Presentation https://pretalx.com/juliacon2024/talk/GKJYBE/ https://pretalx.com/juliacon2024/talk/GKJYBE/feedback/ Method (1.5) Lightning talk 2024-07-11T15:40:00+02:00 15:40 00:10 OpenStreetMap provides freely available data about transportation networks as well as parking spaces, schools, businesses, shops, restaurants, cafes, parking spaces, hospitals. In this talk a set of Julia packages for the manipulation of map data will be presenting, allowing processing road system information, vehicle routing as well as data scraping from maps for understanding the urban space. Presented Julia packages include OpenStreetMapX and OSMToolset. juliacon2024-42990-working-with-open-street-map-spatial-data-in-julia Data Science and Dynamics /media/juliacon2024/submissions/WXTMWP/Boston_restaurant_sGcTKL2_IjoChvf.png Przemysław Szufel en During the talk tools and frameworks in Julia for working with spatial data will be presented. The presented Julia packages include OpenStreetMapX.jl for parsing of OSM and PBF formatted Open Street Map data, along with OpenStreetMapXPlot for plotting maps and OSMToolset for extraction of point-of-interest data from maps. Special attention will be given to the new package, OSMToolset, a pure Julia library that facilitates efficient scraping of various metadata from maps, including amenities, schools, cafes, restaurants, and parking spaces. The talk will emphasize practical examples and code snippets for processing spatial data, simulating vehicle routing, and building spatial walkability indexes. This presentation will also feature a Jupyter Notebook with a live demonstration of various processing patterns for spatial data. Acknowledgments: This presentation was funded in whole by National Science Centre, Poland grant number 2021/41/B/HS4/03349. false https://pretalx.com/juliacon2024/talk/WXTMWP/ https://pretalx.com/juliacon2024/talk/WXTMWP/feedback/ Method (1.5) Lightning talk 2024-07-11T15:50:00+02:00 15:50 00:10 Strategic Data Handling in Julia: Embracing Base Types for Business Impact This talk caters to data analysts and scientists transitioning to Julia who are used to Pandas-centered workflows. We dissect the pros and cons of employing DataFrames versus Julia’s base types within a business setting, providing use case insights from our industry applications. juliacon2024-44484-strategic-data-handling-in-julia Data Science and Dynamics Christian Hower en The talk targets Julia coders, who may not fully exploit its performance capabilities due to a reliance on DataFrames. We will discuss the balance between development time, robustness, and performance, emphasizing time-to-value. Our aim is to provide attendees with strategies to maximize business outcomes when resources are constrained. Attendees will learn to craft performant Julia code by employing arrays, structs, matrices, and dictionaries, which not only boost performance but also simplify logic testing. We’ll offer practical examples and refactoring tactics to transition from DataFrames to Julia’s more potent base types. Furthermore, we'll provide insight into the decision-making process for choosing the right data structure in varied business scenarios. Participants will leave with a solid grasp of when to opt for DataFrames or Julia’s base types, grounded in practicality for business use. They will appreciate Julia's prowess in type stability and memory management for superior data handling. Resources for continued education and best practices will be shared to aid attendees in becoming adept Julia programmers for commercial applications. false https://pretalx.com/juliacon2024/talk/PGQWSM/ https://pretalx.com/juliacon2024/talk/PGQWSM/feedback/ Method (1.5) Talk 2024-07-11T16:00:00+02:00 16:00 00:30 We are Forecasting Mental Wellness of Students using Julia The purpose of this study was to understand the student’s mental health as a function of self, the social and the school and the interrelation using Julia Packages. We had collected data from various sources and implemented using Julia Packages such as DataFrames.jl which will tabulate the data, MLJ.jl to make predictions on the data and PyPlot.jl to plot the results and other metrics. juliacon2024-44154-forecasting-mental-wellness-of-students-using-julia Data Science and Dynamics Aditi Raviraj BurseRadhika Shidling Bhangi en Mental health includes our emotional, psychological and social well-being. It affects how we think, feel and act. It also helps determine how we handle stress and make healthy choice for being mentally stable. It can affect us through any sort of being like object, person/group of people and any kind of field. As it is important, many university students are not able to complete their degrees because they go through a certain sort of stress, anxiety, depression and other mental health problems during course of their higher education. The purpose of this study was to understand the student’s mental health as a function of self (individual factors), the social (interpersonal factors) and the school (environmental factors) and the interrelation using Julia Packages. For the above study we need data from various sources. This data includes student academic performance data, student attendance data, a mentor counseling dataset, other activities of student data, their social media posts data etc. We had collected data from various sources and implemented using Julia Packages such as DataFrames.jl which will tabulate the data, MLJ.jl to make predictions on the data and PyPlot.jl to plot the results and other metrics. OUTLINE: Introduction to Mental Health (2 minutes) Importance of Mental Health in students (2 minutes) Julia for mental health analytics (2 minutes) Approaches and models for mental wellness (7 minutes) Demonstrating a basic forecasting model (5 minutes) Results and Discussions (5 minutes) Conclusion (2 minutes) Question and Answer (5 minutes) false https://pretalx.com/juliacon2024/talk/8HM3F8/ https://pretalx.com/juliacon2024/talk/8HM3F8/feedback/ Method (1.5) Talk 2024-07-11T16:30:00+02:00 16:30 00:30 CEEDesigns.jl is a decision-making framework for the cost-efficient design of experiments, with direct applications in drug research, healthcare, and various other fields. Typically, a design consists of multiple experiments. Each experiment is regarded as an option to acquire additional experimental evidence and is associated with a monetary cost and an execution time. The framework, then, aims to select experiments that balance the value of acquired information and the incurred costs. juliacon2024-42459-cost-efficient-experimental-designs-aka-ceedesigns-jl General J BOtto RitterSean L WuTianchi Chen en In our talk, we will illustrate the decision-making framework, CEEDesigns.jl, through the following two examples. First, we will discuss a task from the histopathology domain, where the goal is to predict glioma grades, as gliomas are the most common primary brain tumors. This prediction is based on a set of clinical features and mutation factors. In this context, observing mutation factors necessitates conducting physical experiments, which are associated with costs. To solve this problem, our framework estimates the information value of each subset of features (experiments). For example, through a built-in integration with MLJ.jl, we can evaluate the predictive accuracy of a machine learning model predicting glioma grades from the subsets of experimental features. By considering both the estimated information values and experimental costs, we can generate Pareto-efficient designs that maximize the information value at the lowest cost. In addition to minimizing the monetary cost, the framework also proposes an optimal order for conducting experiments within a chosen design on the Pareto front, thus reducing the execution time. In general, this allows economical decisions to be made, for example, regarding how to allocate scarce resources to a set of experiments that attain some acceptable level of information (or, conversely, reduce uncertainty below some level). Second, we consider "personalized" experimental designs that dynamically adjust based on the evidence gathered from the experiments. This approach is motivated by the fact that the value of information collected from an experiment generally differs across subpopulations of the entities involved in the triage process. Internally, we conceptualized the decision-making process as a Markov decision process, in which we iteratively choose to conduct a subset of experiments and then, based on the experimental evidence, update our belief about the distribution of outcomes for the experiments that have not yet been conducted. The information value associated with the state, derived from experimental evidence, can be modeled through any statistical or information-theoretic measure such as the variance or uncertainty associated with the target variable posterior. In this process, our goal is to minimize the expected experimental cost that is required to reduce the uncertainty about the grade below a specified threshold. Importantly, while constructing the experimental designs, we incorporate predictive multiple-step-ahead lookups to model experimental outcomes and we consider the subsequent decisions for each outcome. To solve the Markov decision process, the framework uses the POMDPs.jl package to define the underlying process and the MCTS.jl package, which implements the Monte Carlo Tree Search algorithm, to provide an actual solution to the process. false https://pretalx.com/juliacon2024/talk/PJLF73/ https://pretalx.com/juliacon2024/talk/PJLF73/feedback/ For Loop (3.2) Lightning talk 2024-07-11T10:00:00+02:00 10:00 00:10 A Desktop application is an ideal way to ship a Julia app to your target audience, especially when you're dealing with air-gapped (No Internet) environments & have concerns over privacy & cost-effectiveness. In this talk, we will discuss on how bundle your Julia app on all 3 major operating systems (Mac, Windows & Linux) and how to overcome challenges (Such as Regulatory compliance, portability, certifications, licensing, etc) that your Julia application would face in an enterprise environment. juliacon2024-43405-creating-enterprise-grade-desktop-applications-with-julia Julia Internals and Tooling Harsha Byadarahalli Mahesh en Your app can be enterprise ready regardless of whether there is a commercial aspect to it or not. Being enterprise ready will increase the usability of your app by making it usable by a wide variety of audience. Unlike other Desktop apps, Julia apps have a unique trait to them; which needs to be addressed while shipping your app to the target audience. Following topics will be discussed in this talk. All the aspects discussed in this talk will be backed by more than 8 years of practical experience gained by developing and maintaining Julia based desktop products such as JuliaPro and Pumas (https://pumas.ai/pumas). * Your Julia app has to go through cybersecurity compliance frameworks inorder to be accepted by many enterprises, we will discuss on how to make sure your Julia app meets these Regulatory compliance's. * Certifying your Julia app is not only a requirement for enterprises, it has become a basic necessity for non-commercial users as well, because modern operating systems are making it difficult to bypass these certifications, we will discuss on how to certify your Julia app on each operating system. * We will also discuss on challenges faced while deploying your Julia app in an air-gapped (No Internet) environment and how to overcome them. * We will touch base on how to automate your Desktop binary builds using Julia scripts. * Upon installation of your app, the Julia dependencies (Artifacts, registries, package source code, environments, etc) that's being shipped by your binary; might be deployed on distributed user environments (Roaming profiles) and multi-user environments, we will discuss on how your Julia app should handle these kind of environments. * Support for a License Manager in your Julia app. * Code obfuscation for your private Julia code that's being shipped in your Desktop binary. false Presentation https://pretalx.com/juliacon2024/talk/YNVEVA/ https://pretalx.com/juliacon2024/talk/YNVEVA/feedback/ For Loop (3.2) Lightning talk 2024-07-11T10:10:00+02:00 10:10 00:10 A lot of knowledge about algorithms is hidden in old academic texts and may only have been implemented in now-defunct CAS systems. Here I share my experience writing ParametricGrobnerBases.jl for computing parametric Gröbner bases in Julia, and why I think Julia could be a secret weapon for researchers in computational algebra. juliacon2024-43524-julia-for-the-working-mathematician-parametric-grobner-bases Math(s) Andreas Bøgh Poulsen en This talk is about implementing an algorithm for computing parametric/comprehensive Gröbner bases, which are Gröbner bases over a parameterized family of ideals. Gröbner bases are a crucial tool for almost every computation involving multivariate polynomials. This algorithm doesn't seem to be very well-known, but in this talk I outline why Julia is uniquely well-suited to implementing such algorithms, as well as give some examples of problems, that can be efficiently solved using this algorithm. All of this will be available in the package ParamtetricGrobnerBases.jl. This talk can be seen both by computer scientists for its mathematical content and by mathematicians as an inspiration to use Julia in their research. false Slides https://pretalx.com/juliacon2024/talk/7MSS7S/ https://pretalx.com/juliacon2024/talk/7MSS7S/feedback/ For Loop (3.2) Lightning talk 2024-07-11T10:20:00+02:00 10:20 00:10 The [Computational Thinking in Julia](https://computationalthinking.mit.edu/) class taught at MIT was a huge success, doing a great job in showcasing both Julia and Pluto potential in education. Such power is done to be shared should be harnessed by everyone. In this talk, we introduce the [computational thinking template](https://github.com/juliapluto/computational-thinking-template), showing step by step how everyone can build a website like the computational thinking in a few easy steps. juliacon2024-44485-build-a-computational-thinking-like-class-for-the-greater-good Community Luca Ferranti en This talk will present the [computational thinking template](https://github.com/juliapluto/computational-thinking-template) and give a hands-on overview of how it can be used to easily build a website like the [Computational thinking in Julia](https://computationalthinking.mit.edu/). The talk will focus on the following steps: 1. Setting up the website with the template 2. Adding lecture materials 3. Deploying the website After the talk, the audience is ready to build a class like the Computational thinking in a few easy steps and harness the power of Pluto and Julia in their teaching 🎈 false https://pretalx.com/juliacon2024/talk/3T9TE3/ https://pretalx.com/juliacon2024/talk/3T9TE3/feedback/ For Loop (3.2) Talk 2024-07-11T10:30:00+02:00 10:30 00:30 [Taija](https://github.com/JuliaTrustworthyAI) is a growing ecosystem of packages geared towards *T*rustworthy *A*rtificial *I*ntelligence in *J*uli*a*. This talk will provide an update on recent developments of some of our core packages. In particular, the focus will be on contributions made by two groups of students from TU Delft, as well as ongoing JSoC work. juliacon2024-43515-what-s-new-in-trustworthy-ai-in-julia-taija AI/ML/AD /media/juliacon2024/submissions/TJQJGZ/wide_logo_0TuIycG.png Patrick Altmeyer en Julia’s ecosystem for Artificial Intelligence (AI) and Machine Learning (ML) has been growing at a relatively rapid pace, perhaps most notably so in the [SciML](https://sciml.ai/) domain but also more broadly (e.g. [Flux](https://fluxml.ai/), [MLJ](https://juliaai.github.io/MLJ.jl/stable/), [JuliaGenAI](https://github.com/JuliaGenAI/juliagenai.org), …). The goal of Taija is to make AI models more trustworthy, where we have so far focused primarily on the interplay with packages in the latter category. **Please note**: This talk will *not* introduce various packages in great detail but instead focus on highlighting recent developments and research. If Taija is entirely new to you, I recommend you to check out these [slides](https://www.patalt.org/content/talks/posts/2024-turing/) that I recently presented at the Alan Turing Institute. They provide an accessible and relatively high-level overview of our core packages. ## 🏠 About Taija currently covers a range of approaches towards making AI systems more trustworthy: - Model Explainability ([CounterfactualExplanations.jl](https://github.com/JuliaTrustworthyAI/CounterfactualExplanations.jl)) - Algorithmic Recourse ([CounterfactualExplanations.jl](https://github.com/JuliaTrustworthyAI/CounterfactualExplanations.jl), [AlgorithmicRecourseDynamics.jl](https://github.com/JuliaTrustworthyAI/AlgorithmicRecourseDynamics.jl)) - Predictive Uncertainty Quantification ([ConformalPrediction.jl](https://github.com/JuliaTrustworthyAI/ConformalPrediction.jl), [LaplaceRedux.jl](https://github.com/JuliaTrustworthyAI/LaplaceRedux.jl)) - Effortless Bayesian Deep Learning ([LaplaceRedux.jl](https://github.com/JuliaTrustworthyAI/LaplaceRedux.jl)) - Hybrid Learning ([JointEnergyModels.jl](https://github.com/JuliaTrustworthyAI/JointEnergyModels.jl)) Various meta packages can be used to extend the core functionality: - Plotting ([TaijaPlotting.jl](https://github.com/JuliaTrustworthyAI/TaijaPlotting.jl)) - Datasets for testing and benchmarking ([TaijaData.jl](https://github.com/JuliaTrustworthyAI/TaijaData.jl)) - Parallelization ([TaijaParallel.jl](https://github.com/JuliaTrustworthyAI/TaijaParallel.jl)) - Interoperability with other programming languages ([TaijaInteroperability.jl](https://github.com/JuliaTrustworthyAI/TaijaInteroperability.jl)) The [TaijaBase.jl](https://github.com/JuliaTrustworthyAI/TaijaBase.jl) package provides common symbols, types and functions that are used across all or multiple Taija packages. ## 🛠️ Recent Developments A lot has happened since we presented some of our core packages at JuliaCon in 2022 and 2023. During the past year, the focus has been on extending and improving these existing packages. Various groups of undergraduate students at TU Delft as well as a few external collaborates have contributed to these efforts. ### CounterfactualExplanations.jl `CounterfactualExplanations.jl` is a package for Counterfactual Explanations and Algorithmic Recourse in Julia. - The code base has been streamlined to make it more accessible to new contributors. (students) - Part of this involved moving functionality out of the package into new meta-packages. (students) - Multiple new counterfactual generators including FeatureTweak for decision trees and random forests. (students) - Improved interoperability with Python and R through `TaijaInteroperability.jl`. (students) - Integration of ECCCo generator for faithful model explanations (Altmeyer et al. 2024). - Huge improvements to computational speed and native support for multi-threading and multi-processing. ### LaplaceRedux.jl `LaplaceRedux.jl` is a package for effortless Bayesian Deep Learning through Laplace Approximation for `Flux.jl` neural networks. - Support for multi-class problems. (students) - Support for more sophisticated and scalable Hessian approximations. (students) - Interface to MLJ for easy model training and evaluation. (students) ### Students’ Experience I will also briefly report back on the students’ experience working on these projects. This includes the challenges they faced, the skills they acquired, and the impact they had on the Taija ecosystem. ## 🎯 Ongoing and Future Projects Taija has been running two Julia Season of Code projects this summer. 1. (*Conformal Bayes*) Bridging the gap between Bayesian and frequentist approaches to Predictive Uncertainty Quantification. 2. (*Causal Recourse*) From minimal perturbations to minimal interventions for Algorithmic Recourse. Finally, we are also working with a group of students on [TaijaInteractive.jl](https://github.com/JuliaTrustworthyAI/TaijaInteractive.jl): a Genie-based web application for interactive model explanations. ## 📚 References Altmeyer, Patrick, Mojtaba Farmanbar, Arie van Deursen, and Cynthia CS Liem. 2024. “Faithful Model Explanations Through Energy-Constrained Conformal Counterfactuals.” In *Proceedings of the AAAI Conference on Artificial Intelligence*, 38:10829–37. 10. false Github Link to slides (Revealjs) Link to slides (PDF) Slides (PDF) https://pretalx.com/juliacon2024/talk/TJQJGZ/ https://pretalx.com/juliacon2024/talk/TJQJGZ/feedback/ For Loop (3.2) Lightning talk 2024-07-11T11:00:00+02:00 11:00 00:10 **SequentialSamplingModels.jl** is a package for simulating and evaluating a large class of human decision-making models called sequential sampling models (SSMs). We will briefly introduce SSMs and their utilization throughout cognitive science, illustrate some of the main features of the current package version, and discuss future developments. juliacon2024-44316-simulating-cognitive-models-of-human-decision-making-in-julia General Kianté Fernandez en **SequentialSamplingModels.jl** provides a unified interface for simulating and evaluating sequential sampling models (SSMs) in Julia. SSMs describe human decision making as a stochastic and dynamic evidence accumulation process. The models assume that evidence accumulates over time, starting from a certain position, until it crosses a boundary, triggering a corresponding response (Ratcliff & McKoon, 2008; Ratcliff, 1978). SSMs have seen wide-ranging applications in cognitive psychology & neuroscience due to the interpretability of parameters as representative of multiple components of information processing and their ability to form a generative model for reaction time distributions for responses. SequentialSamplingModels.jl has been integrated with the probabilistic programming ecosystem through: • Distributions.jl: functions for describing probability distributions • Plots.jl: extended plotting tools for SSMs • Turing.jl: Bayesian parameter estimation In our talk, we will briefly introduce the theory and applications of SSMs and showcase some of the main features of the current version of the package through a quick tutorial including how to: • install the package • define an SSM • simulate data from the constructed SSM • conduct parameter estimation with Turing Lastly, with many SSMs having likelihoods that cannot be computed efficiently, simulation-based inference has recently been proposed as a solution. We highlight areas for future development, aiming to incorporate likelihood approximation networks (which use neural networks to predict log-likelihoods from data and parameters) using packages like Flux.jl, and invite suggestions for other machine learning-based approaches to parameter estimation. For a more comprehensive exploration of the package functionalities and further details on future developments, the user is invited to consult the package [README](https://github.com/itsdfish/SequentialSamplingModels.jl), [documentation](https://itsdfish.github.io/SequentialSamplingModels.jl/dev/), and [issues](https://github.com/itsdfish/SequentialSamplingModels.jl/issues). false GitHub https://pretalx.com/juliacon2024/talk/8NH3NM/ https://pretalx.com/juliacon2024/talk/8NH3NM/feedback/ For Loop (3.2) Lightning talk 2024-07-11T11:10:00+02:00 11:10 00:10 VimBindings.jl is a Julia package which brings vim emulation to the Julia REPL, but covers only a fraction of the large feature-set of vim. Neovim, a vim fork, offers a robust API that can be used to add vim-like functionality to other software, an approach employed by the likes of the VSCode Neovim plugin. This talk demonstrates the progress made in adopting a similar neovim-based solution in VimBindings.jl. juliacon2024-44424-jurassic-repl-vi-finds-a-way Julia Internals and Tooling Caleb Allen en vi is a text editor from 1976. Today, in 2024, users of vi and its descendants can be found furiously editing text in almost every computing environment imaginable. Unfortunately, a vi user may occasionally find themselves in the difficult situation of using a program that isn’t vi, one that isn’t even a vi descendant. Julia is one such example: a powerful, dynamic programming language used in many scientific and numerical applications. VimBindings.jl is a Julia package which brings a subset of vim features to the Julia REPL, alleviating some of these difficulties; still, its features emulate just a fraction of vim’s feature set, and it falls short of being truly called a full vi or vim implementation. Now, VimBindings.jl is on the path bringing the full power of vim to the REPL by integrating with neovim, a recent fork of vim, under the hood. This talk presents the technical progress made in the VimBindings.jl package in integrating with neovim. It will also discuss design challenges that emerge at the intersection of paradigms, and the opinionated design decisions made to resolve them. Soon, us vim users will be able to answer “yes” to the question of whether we can transform Julia into vim; whether we should will be left as an exercise for the viewer. false Presentation Slides github https://pretalx.com/juliacon2024/talk/N9SAX7/ https://pretalx.com/juliacon2024/talk/N9SAX7/feedback/ For Loop (3.2) Talk 2024-07-11T14:00:00+02:00 14:00 00:30 Julia's SciML ecosystem is burgeoning in applying machine learning to scientific computing. Moreover, a key emphasis is the performance paradigm, accelerating scientific discovery. This is possible because at the core of the SciML are the numerical methods that automatically support hardware accelerators like GPUs, making the simulations tractable. This talk will provide a state of GPU acceleration in the SciML ecosystem and its applications, ranging from ODE solvers to Optimization methods. juliacon2024-43182-gpu-acceleration-of-julia-s-sciml-odes-optimization-and-more SciML Oscar SmithOscar Smith en Julia's SciML is an ecosystem similar to SciPy or MATLAB's built-in numerical solver libraries in that it provides the standard numerical solvers for the Julia ecosystem. Everything from ODE solvers, nonlinear solvers, optimization routines, and more are provided with one common interface. Something that makes the Julia ecosystem stand out is its direct compatibility with machine learning and its deep integration with GPUs. In this talk, we will focus on the latter, showcasing how the SciML stack employs various GPU toolsets in order to automate the process of translating a complex CPU-based model to a GPU-based model. We will discuss the way that this differs from standard machine learning frameworks, why it achieves 20x-100x acceleration over PyTorch and Jax for ODE solvers and some of the steps being taken to accelerate small optimization problems which traditionally have not been able to use parallelism. false https://pretalx.com/juliacon2024/talk/EFVEKH/ https://pretalx.com/juliacon2024/talk/EFVEKH/feedback/ For Loop (3.2) Talk 2024-07-11T14:30:00+02:00 14:30 00:30 Automatic Differentiation (AD) is the art of letting your computer work out derivatives for you. The Julia ecosystem provides many different AD tools, which can be overwhelming. This talk will give everyone the necessary information to answer two simple questions: - As a developer, how do I make my functions differentiable? - As a user, how do I differentiate through other people's functions? Video: <https://www.youtube.com/live/ZKt0tiG5ajw?t=19747s> juliacon2024-43429-gradients-for-everyone-a-quick-guide-to-autodiff-in-julia AI/ML/AD Guillaume DalleAdrian Hill en The ability to take gradients of arbitrary computer programs is at the core of many breakthroughs in science and machine learning. In Python, AD is fragmented into separate frameworks like TensorFlow, PyTorch or JAX. Each one of these has its own package ecosystem, and interoperability is limited. You first pick your AD framework, and then you write all your code in it. Meanwhile on the Julia side, the dream is to make the whole language differentiable. Ideally, you should be able to write the code you want, and get gradients for free. In practice, there are multiple AD packages (ForwardDiff, ReverseDiff, Zygote, Enzyme, etc.) with distinct sets of tradeoffs. Should you use generic types? Can you perform mutating operations? Newcomers may not understand where these constraints come from, or whether they are inevitable. The present talk is an introduction to AD in Julia, from two complementary point of views. - package developers want to make their functions differentiable with as many backends as possible. - package users want easy ways to compute derivatives with the best possible performance. We will give both of these groups the right tools to make informed decisions. Here is a rough summary of our presentation: 1. Classification of AD systems - forward and reverse mode 2. Python versus Julia - two different approaches 3. Making code differentiable - quick fixes or custom rules 4. Using differentiable code - switching backends if needed Presentation slides: <https://gdalle.github.io/JuliaCon2024-AutoDiff/> false GitHub https://pretalx.com/juliacon2024/talk/YGZYWK/ https://pretalx.com/juliacon2024/talk/YGZYWK/feedback/ For Loop (3.2) Talk 2024-07-11T15:00:00+02:00 15:00 00:30 Large Language Models (LLMs) have become ubiquitous in several areas. But so far, the Julia ecosystem has lacked an efficient way to train these models, hindering the adoption of Julia by ML practitioners and users. In this talk we demonstrate parallel training of LLMs using Dagger.jl and Flux.jl. We discuss the various components required to write an efficient parallel training routine. Further, we present the scaling performance achievable with this method, and discuss the future developments. juliacon2024-44254-train-a-llama-2-in-julia AI/ML/AD Dhairya GandhiJulian P Samaroo en Training large neural networks has been a hard challenge in the Julia ecosystem. It requires the infrastructure to scale training to many GPUs simultaneously. In this talk we demonstrate several pieces required to train LLMs such as Llama2 in Julia. Using [Dagger.jl](https://github.com/JuliaParallel/Dagger.jl), we demonstrate scaling to multiple GPUs during the training of a Flux.jl model. This approach has several applications; since the underlying implementation is agnostic of the model being trained, it can thus be reused to parallelize training across a wide variety of models to solve current and emerging problems faster than before. In practice, LLMs aren't trained from scratch. Pre-trained models are typically loaded and then fine tuned on specialised tasks with techniques such as Low Rank Adaptation of LLMs (LoRA). This greatly reduces the training time required to fit a model to become suitable for a specific task. We will present the various components of the pipeline - from the model and data description to setting up the parallel training job. We will present the scaling in training time achieved, and the size of models we could accommodate with this approach. We will walk through the various challenges encountered during the process, and how we envision scaling of large GPU workloads using the Julia ecosystem in the future. false https://pretalx.com/juliacon2024/talk/ZSHGHJ/ https://pretalx.com/juliacon2024/talk/ZSHGHJ/feedback/ For Loop (3.2) Lightning talk 2024-07-11T15:40:00+02:00 15:40 00:10 This talk will demonstrate an End-to-End AI (E2EAI) implementation by leveraging on Julia’s AutoMLPipeline package for developing AI solution together with K0s and Argo Workflow frameworks to automate the provisioning of the K8s cluster and the deployment and monitoring of AI solutions. juliacon2024-41486-end-to-end-ai-e2eai-with-julia-k0s-and-argo-workflow AI/ML/AD Paulito Palmes en Current implementations in cloud computing treat MLOps and IaC (infrastructure as a code) as separate activities. Without a unified view of both the needed infrastructure and the data processing and modelling tasks involved, current approaches put the burden of integrating the automation of both AI solutions and infrastructure to majority of stakeholders that typically lack the specialization of both technologies at the same time. E2EAI (End-to-End AI) aims to create a unified framework by tightly integrating MLOps and IaC workflows using high-level yaml description and APIs for zero to minimal coding leveraging on Julia’s performance and efficiency together with K0s high-level abstractions of k8s infrastructure and Argo Workflow’s ML pipeline stages of deploying micro-services. false Github JuliaCon2024 Presentation https://pretalx.com/juliacon2024/talk/HHLKRR/ https://pretalx.com/juliacon2024/talk/HHLKRR/feedback/ For Loop (3.2) Lightning talk 2024-07-11T15:50:00+02:00 15:50 00:10 **ExplainableAI.jl**, a comprehensive set of XAI tools for Julia, has undergone significant development since our initial presentation at JuliaCon 2022, and has since been expanded into the **Julia-XAI ecosystem**. This lightning talk will highlight the latest developments, including new methods, the new XAIBase.jl core interface, and new utilities for visualizing explanations of vision and language models. juliacon2024-44308-what-s-new-with-explainable-ai-in-julia AI/ML/AD Adrian Hill en In machine learning, understanding the inner workings of black-box models is critical to ensuring their safety and trustworthiness. The field of Explainable AI (XAI) aims to provide practitioners with methods to gain insight into the decision-making processes of their models. The Julia-XAI ecosystem provides such methods, with a focus on post-hoc, local input space explanations. Simply put, methods that try to answer the question *"What part of the input is responsible for the model's output?"*. Since our first presentation of **ExplainableAI.jl** at JuliaCon 2022, the package has been expanded into the **Julia-XAI ecosystem**. This lightning talk will cover the latest additions and present new features: - **XAIBase.jl:** Core package that defines the Julia-XAI interface, allowing developers to quickly implement or prototype new methods without writing boilerplate code. - **VisionHeatmaps.jl and TextHeatmaps.jl:** Lightweight dependencies for visualizing explanations of vision and language models. - **RelevancePropagation.jl:** A new package for Layer-wise Relevance Propagation (LRP) and Concept Relevance Propagation (CRP) for use with Flux.jl models, supporting ResNets and Transformer architectures. - **New XAI methods in ExplainableAI.jl** false GitHub https://pretalx.com/juliacon2024/talk/JDWKAC/ https://pretalx.com/juliacon2024/talk/JDWKAC/feedback/ For Loop (3.2) Talk 2024-07-11T16:00:00+02:00 16:00 00:30 Large Language models(LLMs) such as ChatGPT, Bard, Midjourney, Gemini, and many others are buzzwords in the present era of Artificial Intelligence. In this talk, I will address the impact of large language models on the environment and present small language models as the solution. juliacon2024-44452-large-language-models-to-be-or-not-to-be AI/ML/AD Gajendra Deshpande en Large Language models(LLMs) such as ChatGPT, Bard, Midjourney, Gemini, and many others are buzzwords in the present era of Artificial Intelligence. The technologies such as Large Language Models are like a double-edged sword. On one hand, they offer lots of benefits and create new opportunities and on the other hand, they raise many concerns. One of the concerns, that is least discussed is the impact of large language models on the environment. The large language models are trained on billions and trillions of parameters and they require huge compute resources that contribute to carbon footprint. One of the possible solutions to reduce the carbon footprint and environmental impact of LLMs is to consider using Small Language Models and Modular Language Models. In many cases, small language models offer better solutions than large language models. This talk begins with an introduction to Large Language models and their impact on the environment and how they contribute to carbon footprint. Next, I will introduce Small Language models and how they will help in reducing the carbon footprint while offering a better solution. I will demonstrate a sample small language model application using Julia packages i.e., Transformers.jl, PromptingTools.jl and ConformalPrediction.jl. Finally, I will conclude the talk by comparing the impact of large language models and small language models on the environment. Outline: 1. Introduction to Large Language models and their impact on the environment(05 Minutes) 2. Overview of Small Language models as a solution to reduce the carbon footprint(05 Minutes) 3. Introduction to Transformers.jl, PromptingTools.jl and ConformalPrediction.jl (08 Minutes) 4. Building an example small language model application in Julia(08 Minutes) 5. Comparison of the environmental impact of large language models and small language models(02 Minutes) 6. Conclusion and Questions (02 Minutes) false https://pretalx.com/juliacon2024/talk/FSMGKN/ https://pretalx.com/juliacon2024/talk/FSMGKN/feedback/ For Loop (3.2) Talk 2024-07-11T16:30:00+02:00 16:30 00:30 What do computer algebra and Standard ML-style module systems have in common? In this talk, we will answer this question via exploration of GATlab.jl, a new package spun off of the GAT (generalized algebraic theories) system from Catlab. Rather than focusing on the mathematics of GATs, we will give a practical introduction on how to use GATlab as both a computer algebra system and a Standard ML-style module system, and how each use complements the other. juliacon2024-43382-gatlab-computer-algebra-and-standard-ml-modules-combined General Owen Lynch en The core idea of [GATlab](https://github.com/AlgebraicJulia/GATlab.jl) is the following. Consider the following module signature in OCaml. ```ocaml module type MONOID = sig type t val zero : t val add : (t, t) -> t end ``` A module can be said to "implement" this signature if the module contains a type `t` along with a "zero value" for `t` and a function which adds two elements of `t`. ```ocaml module INTMONOID : MONOID = struct type t = int let zero = 0 let add (x, y) = x + y end ``` However, we could also interpret that signature in a different way: we could interpret it as a *specification for syntax trees*. Specifically, we could make a data structure which looks like the following (we now switch back to Julia) ```julia abstract type MonoidTerm{T} end eltype(t::MonoidTerm{T}) where {T} = T struct Zero{T} <: MonoidTerm{T} end struct Add{T} <: MonoidTerm{T} lhs::MonoidTerm rhs::MonoidTerm end struct Val{T} <: MonoidTerm{T} value::T end ``` We can then make implementations using multiple dispatch ```julia abstract type Monoid{T} end struct IntMonoid <: Monoid{Int} end zero(::IntMonoid) = 0 add(::IntMonoid, x::Int, y::Int) = x + y ``` Using such a "module" of type `Monoid{T}`, we can *interpret* any `MonoidTerm{T}` to produce a `T`! That is, we can write a function ```julia function interpret(M::Monoid{T}, t::MonoidTerm{T}) where {T} if t isa Zero zero(M) elseif t isa Add add(M, interpret(M, t.lhs), interpret(M, t.rhs)) elseif t isa Val t.value end end ``` If we build a signature+module system from the ground up using macros and multiple dispatch, we can also build in these syntax trees and corresponding interpreters. It is also possible to compile a syntax tree to a Julia function. GATlab is an implementation of this... and significantly more. First of all, one can add *laws* to a signature to produce a *theory* (theory = signature + laws). ```julia @theory ThMonoid begin T::TYPE zero::T add(x::T, y::T)::T add(x, zero) == x ⊣ [x::T] add(zero, x) == x ⊣ [x::T] add(add(x, y), z) == add(x, add(y, z)) ⊣ [x::T, y::T, z::T] end ``` We call a law-abiding implementation of the signature of a theory a *model* of that theory. Now, we cannot statically check that a model of a theory satisfies the laws, but the laws do provide a principled way of doing *rewriting* on the syntax trees associated to a signature. We use e-graphs to perform this rewriting, with a custom type-aware implementation. The mathematics behind all of this is studied within [universal algebra](https://en.wikipedia.org/wiki/Universal_algebra). Many of the features of ML-style module systems have analogues within universal algebra. For instance, one can build up complex theories via inheriting simpler theories, or create maps between theories (analogous to ML-style functors), and these operations on theories can be used to generate new models from old ones. However, universal algebra cannot capture certain structures important for our work in Catlab, first and foremost categories. To support categories, we upgrade from algebraic theories to generalized algebraic theories (or *GATs*, which is where the name of GATlab comes from), as introduced by [Cartmell](https://www.researchgate.net/publication/314154820_Generalised_Algebraic_Theories_and_Contextual_Categories). These support theories with *dependent types*, which looks like the following ```julia @theory ThCategory begin Ob::TYPE Hom(dom, codom)::TYPE ⊣ [dom::Ob, codom::Ob] id(a::Ob)::Hom(a, a) compose(f::Hom(a, b), g::Hom(b, c))::Hom(a, c) ⊣ [a::Ob, b::Ob, c::Ob] compose(f, id(b)) == g ⊣ [a::Ob, b::Ob, f::Hom(a, b)] ... end ``` Just like with algebraic theories, we can work with syntax trees, we can write interpreters, and we can programmatically manipulate models. GATlab can be compared to frameworks like [MMT](https://uniformal.github.io/doc/), but with the ability to have models compute fast. Another comparison would be to Julia libraries like Symbolics.jl. Symbolics.jl is far more advanced for traditional computer algebra, but the underlying assumption is that variables are some sort of number, while GATlab does not assume this. Finally, we might compare with Julia libraries like [WhereTraits.jl](https://github.com/jolin-io/WhereTraits.jl) which add traits/typeclasses to Julia. GATlab differs from these in being more similar to Standard ML modules rather than Haskell typeclasses or Rust traits, and in its CAS aspects. We hope to learn from these other projects and integrate their strengths as GATlab evolves. In this talk, we will give an introduction to GATlab from a practical perspective, showing how to work with simple theories and modules, and emphasizing the connection (as described above) between computer algebra and module systems. false https://pretalx.com/juliacon2024/talk/H8AWEY/ https://pretalx.com/juliacon2024/talk/H8AWEY/feedback/ For Loop (3.2) Workshop 2024-07-11T18:30:00+02:00 18:30 03:00 Join us to learn how to get involved with diversity initiatives within the Julia community! This is a great opportunity to meet new people and work on a meaningful project. juliacon2024-49627-diversity-dinner-and-discussion Community Jacob ZelkoLetícia MadureiraSkylar GeringKim Louisa Auth en We invite you to attend the Diversity Dinner and Discussion, an evening event focused on Diversity, Equity, and Inclusion (DEI) initiatives within the Julia Language community. At this event, various community DEI organizations will discuss their efforts to make the Julia community more welcoming and increase user diversity. We will have a hands-on activity where attendees will design a mentoring platform to help new members break into the Julia community and contribute to projects they care about. We hope to have a fun discussion-based event focused on empowering attendees to make an impact on diversity within the Julia community while creating networking opportunities between people from different backgrounds. false https://pretalx.com/juliacon2024/talk/TZAVVB/ https://pretalx.com/juliacon2024/talk/TZAVVB/feedback/ Function (4.1) Lightning talk 2024-07-11T10:00:00+02:00 10:00 00:10 We present CoupledElectricMagneticDipoles.jl, a Julia package implementing the coupled electric and magnetic dipole (CEMD) or discrete dipole approximation (DDA) method for electromagnetic multiple scattering calculations, as well as a plethora of side functionalities that might be useful for preparing such calculations or analyzing the obtained results. juliacon2024-44459-coupledelectricmagneticdipoles-jl Physics & Quantum Chemistry /media/juliacon2024/submissions/7NF3SV/logo_light_jRBNiTq.svg Augustin Muster en Authors: Augustin Muster, Diego R. Abujetas, Frank Scheffold, Luis S. Froufe-Pérez Affiliation: Department of Physics, University of Fribourg, 1700 Fribourg, Switzerland The coupled electric and magnetic dipole (CEMD) and the discrete dipole approximation (DDA) methods are used extensively in nano-photonics or nano-optics, addressing problems of electromagnetic scattering in complex systems or on single discretized targets [1]. Nowadays, implementations of both CEMD and DDA methods can be found in almost all common programming languages [2], but not in the Julia language, renowned for its performance, simplicity and dynamism. In order to remedy this, we introduce CoupledElectricMagneticDipoles.jl, a Julia Package implementing the CEMD and DDA methods, as well as all the side functionalities that are needed to do simulations using these two methods. The package is organized in 8 modules organized around the main one, DDACore. This module allows to define and solve CEMD (DDA) problems using either CPU or GPU. The other modules can be used to give input to the functions of the DDACore module (with the Alphas, Geometries and InputFields modules), or for analyzing the obtained results (with the PostProcessing and Forces modules). Moreover, two modules are implemented as utilities, GreenTensors and MieCoeff. We shall discuss the performances of CoupledElectricMagneticDipoles.jl, as well as its simplicity of use, showing typical examples from nano-photonics and nano-optics. [1] Bruce T. Draine and Piotr J. Flatau, "Discrete-Dipole Approximation For Scattering Calculations". J. Opt. Soc. Am. A 11, 1491-1499 (1994) [2] P.C. Chaumet, “The Discrete Dipole Approximation: A Review”. Mathematics, 10, 3049 (2022) false https://pretalx.com/juliacon2024/talk/7NF3SV/ https://pretalx.com/juliacon2024/talk/7NF3SV/feedback/ Function (4.1) Lightning talk 2024-07-11T10:10:00+02:00 10:10 00:10 In this talk, we will introduce our new package, [MuJoCo.jl](https://github.com/JamieMair/MuJoCo.jl), bringing the advanced physics simulator **[MuJoCo](https://github.com/google-deepmind/mujoco)** to fellow Julia users. We will highlight the features that this package gives to users and give an example of how to make best use of the package and its visualiser. juliacon2024-44350-introducing-mujoco-jl-julia-bindings-for-the-mujoco-simulator Physics & Quantum Chemistry Jamie Mair en Link to the slides - [https://mujoco-jc2024.netlify.app/](https://mujoco-jc2024.netlify.app/) **[MuJoCo](https://github.com/google-deepmind/mujoco)** is an advanced, high-performance physics engine designed for accurate and fast simulation of robotic applications. The engine, provided by Google DeepMind, can be used by robotics researchers and practitioners to design, calibrate and test control software for robotic systems in a simulated environment. MuJoCo is also utilised by the machine learning community, enabling state-of-the-art Reinforcement Learning techniques to be applied to robotics, as such techniques require millions of hours of high quality training data to be effective. By creating [MuJoCo.jl](https://github.com/JamieMair/MuJoCo.jl). we aim to provide the Julia community with modern bindings to the MuJoCo physics engine, integrated with a visualisation tool to allow simulations to be rendered in real-time, without users ever having to leave the Julia ecosystem. Our design was guided by several goals, ensuring that the package: 1) Offers a high-performance thin wrapper around the existing C library, enabling users to exert fine-grained control over performance, including support for multi-threading. 2) Provides a user-friendly experience, complete with comprehensive documentation of structs and functions, as well as bounds checking on inputs. 3) Presents native Julia interfaces to directly access array/matrix data from the engine, facilitating interoperability with other packages. This talk will start by showcasing some of the main features of [MuJoCo.jl](https://github.com/JamieMair/MuJoCo.jl), followed by a detailed example, along with usage tips, of how to use the package and its visualiser. This work builds on some amazing previous work by [Lyceum](https://github.com/Lyceum), whose visualisation tools have been integrated directly into [MuJoCo.jl](https://github.com/JamieMair/MuJoCo.jl) via Julia's package extension framework. false GitHub Slides https://pretalx.com/juliacon2024/talk/DK8EMZ/ https://pretalx.com/juliacon2024/talk/DK8EMZ/feedback/ Function (4.1) Lightning talk 2024-07-11T10:20:00+02:00 10:20 00:10 VoronoiFVM.jl solves nonlinear coupled multiphysics diffusion-reaction-convection partial differential equation systems in one, two an three space dimensions using the the Voronoi finite volume method, leveraging ForwardDifff.jl for the construction of the Jacobi matrices used by the nonlinear solver. The talk will explain the basic ideas of the package API and give an overview on the developments since the first presentation at JuliaCon 2020, and highlight the integrative potential of Julia. juliacon2024-44293-what-s-new-with-voronoifvm-jl Physics & Quantum Chemistry Jürgen Fuhrmann en After the first presentation at JuliaCon 2020, the package has undergone a number of improvements. These include - Integration with DifferentialEquations.jl ODE solvers - Integration with LinearSolve.jl providing easy access to different linear solvers - New preconditioners for linear systems inlcuding AMGCLWrap.jl - Differentiability through Sparspak.jl - Mesh generation capabilities in accompanying packages. - Visualization capabilities in accompanying packages based on Makie.jl and PlutoVista.jl, among others - Multithreading (work in progress) The package is used as the core solver in several research projects in fields like electrochemistry and semiconductor modeling. As the contribution is planned as a lightning talk, presentation time will be short. I however intend to present with the help of a Pluto notebook, which (or an extended version thereof) will be made available online at the time of the talk, giving interested participants the possibility to try out computational examples showcasing the package's capabilities. false Video Pluto notebook (HTML) https://pretalx.com/juliacon2024/talk/F9FBWD/ https://pretalx.com/juliacon2024/talk/F9FBWD/feedback/ Function (4.1) Talk 2024-07-11T10:30:00+02:00 10:30 00:30 In this talk I’ll provide an overview of recent activities for the growth of an open-source ecosystem in quantum technology by Unitary Fund, a 501(c)3 non-profit, whose activities can be broadly divided into three groups: (1) Microgrants; (2) community activities; (3) research. I will provide an overview of 89+ microgrants awarded to date with some spotlights (Julia projects) and stats. Community activities include a lively Discord server (with many community calls and "Quantum Wednesdays" jour juliacon2024-47673-nurturing-a-quantum-open-source-ecosystem Quantum Minisymposia Nathan Shammah en In this talk I’ll provide an overview of recent activities for the growth of an open-source ecosystem in quantum technology by Unitary Fund, a 501(c)3 non-profit, whose activities can be broadly divided into three groups: (1) Microgrants; (2) community activities; (3) research. I will provide an overview of 89+ microgrants awarded to date with some spotlights (Julia projects) and stats. Community activities include a lively Discord server (with many community calls and "Quantum Wednesdays" journal clubs), the Quantum Open Source Survey (featuring Julia), unitaryHACK (a special hackathon) and more. The Unitary Fund tech staff is performing research enabling open source projects in error mitigation (Mitiq) and benchmarks of quantum computer metrics (Metriq.info). false https://pretalx.com/juliacon2024/talk/DKSM7H/ https://pretalx.com/juliacon2024/talk/DKSM7H/feedback/ Function (4.1) Lightning talk 2024-07-11T11:00:00+02:00 11:00 00:10 In this work, we present the progress of our MolKet's Julia package that can be used to implement quantum molecular simulations with the aid of physics-informed AI. We will show the performance of our package and how it can be used to implement quantum molecular simulations for several applications. juliacon2024-43603-simulating-quantum-molecular-dynamics-with-julia Physics & Quantum Chemistry Taha SelimAlain Chancé en Quantum molecular simulations are computationally expensive and require a large amount of memory. Moreover, accurate simulations may require the use of machine learning algorithms, physics-informed neural networks, and other types of algorithms such as quantum computing and quantum-inspired algorithms. Such algorithms require different types of hardware like CPUs, GPUs, TPUs, NPUs, and quantum computers. Therefore Julia is of much interest to implement quantum molecular simulations. In this work, we present the progress of our MolKet's Julia package that can be used to implement quantum molecular simulations with the aid of physics-informed AI. We will show the performance of our package and how it can be used to implement quantum molecular simulations for several applications. Keywords: Julia, quantum molecular dynamics, physics-informed neural networks, machine learning, quantum computing, quantum-inspired algorithms, high-performance computing, GPUs, TPUs, quantum computers. false https://pretalx.com/juliacon2024/talk/U9NF3A/ https://pretalx.com/juliacon2024/talk/U9NF3A/feedback/ Function (4.1) Lightning talk 2024-07-11T11:10:00+02:00 11:10 00:10 We present Layout.jl, a package for computer-aided design (CAD) of superconducting quantum integrated circuits. The package supports schematic-driven layout, 2D geometry rendering, and the construction and meshing of 3D models. It also provides an interface to Palace, an open-source 3D finite element solver for computational electromagnetics. juliacon2024-43574-computer-aided-design-of-quantum-integrated-circuits Physics & Quantum Chemistry Greg Peairs en Layout.jl is a package developed at the AWS Center for Quantum Computing for computer-aided design (CAD) of quantum hardware—specifically, for superconducting integrated circuits operating at microwave frequency. The package supports the generation of 2D layouts and 3D models of complex devices using a low-level geometry interface together with a high-level schematic-driven workflow. At the geometry level, the user writes code to draw 2D geometric entities like polygons and paths, optionally using units with Unitful.jl; position and orient these entities with coordinate transformations; organize them into a hierarchy of local coordinate systems and references; apply operations like rounding, offsetting, or geometric Booleans; and assign each entity metadata that can be used in different ways by different backends. In the schematic-driven workflow, the user defines components and the connectivity between them, followed by automated placement and routing with the schematic API to construct a layout. The results can be rendered with various backends, including for output in the GDSII format; used to construct and mesh a 3D model; and interfaced with other tools like the open-source electromagnetics solver Palace. Finally, we leverage the Julia package manager for process design kit (PDK) management, allowing users to maintain a library of versioned process technologies and components for portable, reproducible layout scripts. false https://pretalx.com/juliacon2024/talk/98REDT/ https://pretalx.com/juliacon2024/talk/98REDT/feedback/ Function (4.1) Talk 2024-07-11T14:00:00+02:00 14:00 00:30 Unlike classical computers, quantum computers are inherently error-prone. Quantum error correction (QEC) is a method to protect quantum information from errors. In this talk, I will introduce the basic concepts of QEC and the recent development of tensor network based QEC. I will also present the software tools: TensorQEC.jl, a Julia package for tensor network based QEC. This package will be open-sourced before the conference. juliacon2024-47669-tensor-network-for-quantum-error-correction Quantum Minisymposia JinGuo LiuZhongyi Ni en Unlike classical computers, quantum computers are inherently error-prone. Quantum error correction (QEC) is a method to protect quantum information from errors. In this talk, I will introduce the basic concepts of QEC and the recent development of tensor network based QEC. I will also present the software tools: TensorQEC.jl, a Julia package for tensor network based QEC. This package will be open-sourced before the conference. false GitHub Slides https://pretalx.com/juliacon2024/talk/WVWTEB/ https://pretalx.com/juliacon2024/talk/WVWTEB/feedback/ Function (4.1) Talk 2024-07-11T14:30:00+02:00 14:30 00:30 We are presenting updates to the Piccolo.jl family of Julia packages, including NamedTrajectories.jl and QuantumCollocation.jl. New features include robust control, leakage suppression, subspace gate optimization, improved unitary geodesic initialization, easy-to-use and powerful plotting tools, expanded documentation, and new examples. We will also present some of our results on hardware and the future roadmap for Piccolo.jl. juliacon2024-44208-piccolo-jl-an-integrated-stack-for-quantum-optimal-control Quantum Minisymposia /media/juliacon2024/submissions/3UP39Z/piccolo-logo_MpP8xGK.jpg Aaron TrowbridgeAndy Goldschmidt en [Piccolo.jl](https://github.com/aarontrowbridge/Piccolo.jl) is a meta-package for setting up, solving, and analyzing quantum optimal control problems using Padé Integrator Collocation (PICO) method, detailed in our award-winning, peer-reviewed paper [Direct Collocation for Quantum Optimal Control](https://arxiv.org/abs/2305.03261) (submitted and received best paper award at IEEE QCE23). Software development is supported by [the Unitary Fund](https://unitary.fund/) where we host weekly live-coding sessions in the discord channel! --- _AG was supported by an appointment to the Intelligence Community Postdoctoral Research Fellowship Program at University of Chicago administered by Oak Ridge Institute for Science and Education (ORISE) through an interagency agreement between the U.S. Department of Energy and the Office of the Director of National Intelligence (ODNI)._ false Piccolo.jl https://pretalx.com/juliacon2024/talk/3UP39Z/ https://pretalx.com/juliacon2024/talk/3UP39Z/feedback/ Function (4.1) Talk 2024-07-11T15:00:00+02:00 15:00 00:30 The lack of composable APIs for the design and development of networking protocols in most available modeling tools is a severe drain on developer productivity. We present a family of abstractions and APIs, together with their implementation in the QuantumSavory.jl package, which make it possible to design large-scale quantum networking simulations in a scalable and manageable way. juliacon2024-44450-composable-api-for-quantum-networking-protocols Quantum Minisymposia Stefan Krastanov en A number of popular simulation frameworks exist for modeling quantum networks, aiming at both research questions and at informing future designs and hardware deployments. Developing and testing network protocols is a core capability for such tools, however good abstractions in that domain are sorely missing: it is hard to create a stack of protocols that do not depend on each-other's internals, a recipe for bugs, slow progress, and developer pain. In this talk we present a family of abstractions and an API which make protocol development much easier. Behind the scenes we build on the QuantumSavory package we are developing at the the NSF's Center for Quantum Networks. The tool includes a symbolic algebra system for describing quantum states, multiple backend simulators that can seamlessly interoperate, and strong debugging and visualization capabilities, which are presented throughout the talk. false https://pretalx.com/juliacon2024/talk/KUUH8B/ https://pretalx.com/juliacon2024/talk/KUUH8B/feedback/ Function (4.1) Lightning talk 2024-07-11T15:40:00+02:00 15:40 00:10 The growing availability of automatic differentiation (AD) tools promises numerous applications for enhancing large-scale scientific simulations, from sensitivity analysis to machine learning. However, the interplay of AD ("the gradient you get") and numerical analysis, implicit differentiation and physical symmetries ("the gradient you want") is nontrivial. I will briefly present such considerations on examples from materials science (density-functional theory) in DFTK.jl. juliacon2024-46579-on-physics-informed-automatic-differentiation Quantum Minisymposia Niklas Schmitz en The growing availability of automatic differentiation (AD) tools promises numerous applications for enhancing large-scale scientific simulations, from sensitivity analysis to machine learning. However, the interplay of AD ("the gradient you get") and numerical analysis, implicit differentiation and physical symmetries ("the gradient you want") is nontrivial. I will briefly present such considerations on examples from materials science (density-functional theory) in DFTK.jl. false https://pretalx.com/juliacon2024/talk/8AJJ9U/ https://pretalx.com/juliacon2024/talk/8AJJ9U/feedback/ Function (4.1) Lightning talk 2024-07-11T15:50:00+02:00 15:50 00:10 Given two quantum circuits, that differ in their number of qubits, how can we determine they behave in the same way? This talk discusses how equivalence checking has been implemented in ZXCalculus.jl using OpenQASM.jl, YaoHIR.jl and QuantumEquivalence.jl juliacon2024-44549-equivalence-checking-of-dynamic-quantum-circuits Quantum Minisymposia Liam en In order to overcome platform limitations of NISQ, namely the limit amount of qubits and high noise ration, IBM introduced a new type of quantum circuits named Dynamic Quantum Circuits (DQCs). They contain non-unitary operations such as mid-circuit measurements, active-reset and classically controlled logic. Yet most state-of-the-art equivalence checkers are not efficient and effective for verification of DQCs. Previously ZXCalculus.jl did not support importing circuits from OpenQASM or checking the equivalence of two quantum circuits. This talk presents how dynamic quantum circuits can be converted into quantum circuits, that only contain unitary operations, which can be proven equivalent using ZXCalculus.jl. Furthermore this approach is scalable in regard to the number qubits, allowing us to verify the equivalence of quantum circuits with more than 1000 Qubits. false DynamicQuantumCircuits.jl Pluto Notebooks ZXCalculus.jl Pluto Notebooks Slides https://pretalx.com/juliacon2024/talk/EML8NG/ https://pretalx.com/juliacon2024/talk/EML8NG/feedback/ Function (4.1) Talk 2024-07-11T16:00:00+02:00 16:00 00:30 ITensorNetworks.jl is a Julia package for constructing, optimizing and contracting tensor networks of arbitrary structure. The library combines the unique indexing system from ITensors.jl with code for generic graphs which can host meta-data on the vertices and edges. The result is a highly flexible, generic codebase which can be leveraged to perform state-of-the-art research with tensor networks. juliacon2024-43450-itensornetworks-jl Quantum Minisymposia /media/juliacon2024/submissions/YTXKB7/JuliaConImage_mLY5eB5.png Joseph Tindall en Tensor networks are a representation of high dimensional tensors as a connected network of lower dimensional tensors. This means they can be used to solve problems, such as those involving many-body quantum systems, which are beyond the reach of conventional brute-force methods. Existing codes and algorithms for manipulating tensor networks, however, are often hard-coded to specific network structures – most prominently the one-dimensional chain. ITensorNetworks.jl moves beyond this by being built upon code which makes no explicit assumption about the geometry of the tensor network, providing an unprecedented degree of freedom to the user when tackling high-dimensional problems. In this talk I will detail the structure and features of the ITensorNetworks.jl package. I will present examples of code written using the library and discuss its ongoing application in quantum simulation. Finally, I will discuss future plans for the library. false https://pretalx.com/juliacon2024/talk/YTXKB7/ https://pretalx.com/juliacon2024/talk/YTXKB7/feedback/ Function (4.1) Talk 2024-07-11T16:30:00+02:00 16:30 00:30 Rimu.jl aims to be an extensible platform for quantum many-body calculations. We have implemented the full configuration interaction quantum Monte Carlo (FCIQMC) algorithm and exact diagonalisation for quantum many-body models defined through a universal interface. The pure Julia implementation relies on native threading and uses MPI.jl for inter-node parallelism on the HPC. We will showcase solving an impurity problem in the Bose-Hubbard model where the linear matrix dimension exceeds `10^60`. juliacon2024-43505-projector-monte-carlo-and-exact-diagonalisation-with-rimu-jl Quantum Minisymposia Joachim Brand en Quantum many-body physics problems map into linear-algebra problems of a size that grows exponentially with the number of constituent particles. While exact diagonalisation is useful for small toy problems, it quickly becomes infeasible. Projector quantum Monte Carlo aims at providing a stochastic sample of the ground state wave function (or extremal eigenpair) for larger quantum Hamiltonians. In this talk we will discuss how we implemented a flavour of projector quantum Monte Carlo (FCIQMC), which can be seen as a simple stochastic extension of exact diagonalisation, in native Julia. The package is designed to be fully extensible with interfaces. This allows for the easy implementation of custom many-body models or modification of the stochastic algorithms. Besides the option to convert small-enough models into sparse matrices for use with standard linear algebra solvers, Rimu.jl also allows for the matrix-free exact diagonalisation of model Hamiltonians with the external package Krylovkit.jl. The choice of Julia as a language was ideal for this software project where speed and performance-tuning of hot-loop code is critical, while the flexibility of experimenting with models and algorithms as well as the ease of data analysis (all in the same language) enhances productivity greatly. After giving a quick tour of what you can do with Rimu.jl, we will discuss the structure of the package and some of the design choices around parallelisation by threading and message passing (mpi). FCIQMC is already popular in quantum chemistry (targeted by existing Fortran codes) and could be useful in a number of different domains. We are looking for new users, collaborators and contributors who may be interested in exploring new use cases or extensions for Rimu.jl. false GitHub talk repo with slides https://pretalx.com/juliacon2024/talk/TTSXAN/ https://pretalx.com/juliacon2024/talk/TTSXAN/feedback/ While Loop (4.2) Talk 2024-07-11T10:00:00+02:00 10:00 00:30 In this talk I will walk through 4 different practical examples of using Julia and share some of the things that caught my attention coming from MATLAB. The talk will go through the 4 projects I used to get my hands dirty with Julia. It is a representation of the things I stumbled across in my first 10h of Julia. juliacon2024-39850-matlab-julia General /media/juliacon2024/submissions/NCVSZ3/1550068462547_wNEYAT1.jpeg Gareth Thomas en In this talk I will walk through 4 different practical examples of using Julia and share some of the things that caught my attention coming from MATLAB, as an experienced MATLAB developer. The talk will go through the 4 projects I used to get my hands dirty with Julia. The 4 examples are: - 2D and 3D plotting - Reading external files and working with tables - Step Response of a Control System - Testing and developing a Julia Package false PDF of Presentation https://pretalx.com/juliacon2024/talk/NCVSZ3/ https://pretalx.com/juliacon2024/talk/NCVSZ3/feedback/ While Loop (4.2) Talk 2024-07-11T10:30:00+02:00 10:30 00:30 Interfacing MATLAB with Julia (and the other way) is still clunky and not very "ergonomic" (from a software development point of view). We propose for a new software component that sits in between MATLAB and Julia that would allow to transparently interface these two worlds. juliacon2024-44403-blending-the-gap-mixing-matlab-with-julia General Paolo AccordiniJoris Belier en Julia and MATLAB are very different beasts and they cannot easily talk to each other. Multiple solutions were developed to allow these two worlds to communicate. But most of these solutions relies on methods of communications that are not very "ergonomic" from a software developer point of view. In other words, there is always a syntactic price to pay in order to call a function or access a data structure. This is undesirable from multiple aspects, mostly because it renders the code hard to read and might introduce extra complexity in order to marshal data structures between these two worlds. There is another way that might be useful to craft a series of interfaces that might allow MATLAB to transparently call Julia, allowing MATLAB developers to try what Julia can provide without the initial cost of learning another programming language or using a weird API to call/translate data structures between worlds. false https://pretalx.com/juliacon2024/talk/FBTMTQ/ https://pretalx.com/juliacon2024/talk/FBTMTQ/feedback/ While Loop (4.2) Lightning talk 2024-07-11T11:00:00+02:00 11:00 00:10 In this talk, we present [QuantileMatching.jl](https://github.com/JuliaExtremes/Quantile), a package that provides exhaustive high-performance functions to perform quantile matching of an actual distribution and a target distribution with Julia. The functionalities will be illustrated in this talk with stationary examples of climate models and the impacts of bias correction. juliacon2024-43332-bias-correcting-methods-for-climate-models General Charles Marois en Quantile mapping is a statistical technique used in hydrology and climatology to adjust the distribution of observed data to match a desired distribution, typically that of a climate model or historical record. This method involves mapping the quantiles of the observed data to the corresponding quantiles of the reference distribution, ensuring a more accurate representation of extreme events and improving the reliability of climate projections. By aligning the distributions, quantile mapping helps address biases in climate model outputs and enhances the utility of climate information for impact assessments and decision-making. There are several types of quantile mapping methods, each with its specific approach to adjust the distribution of observed data to a reference distribution. Generally speaking, methods are classified within parametric or non-parametric categories. In a stationary context, quantile mapping assumes a constant relationship between observed and reference distributions over time. false https://pretalx.com/juliacon2024/talk/DGGFYA/ https://pretalx.com/juliacon2024/talk/DGGFYA/feedback/ While Loop (4.2) Lightning talk 2024-07-11T11:10:00+02:00 11:10 00:10 Developing for the 6502 8-bit microprocessor is hard with your code confined to the platform. Retro6502 has a fast, pure Julia emulator that lets your code call Julia where development is orders of magnitude faster – you can code in assembly after your Julia version works and passes your tests. You get - macros / code gen in Julia - Assembly in the Julia REPL - Pure Julia 6502 emulation - Live coding - Automated testing - Julia prototyping you can test against your 6502 code - Read-only memory juliacon2024-44311-retro6502-for-8-bit-dev-smashing-a-mosquito-with-a-pile-driver General /media/juliacon2024/submissions/FWD39E/talk_BOp0ma3.png William R Burdick en Youtube: https://www.youtube.com/live/PzgFzorRtoo?si=W9TENH5mxrax2bgf&t=8919 Background music: https://www.youtube.com/watch?v=5ZoLphdE7l8 -- I had intended to play PRESS PLAY ON TAPE's cover of Martin Galway's classic Comic Bakery. This cover song is famous for certain values of "nerd". Also, thanks to Roy Riggs, author of Hired Sword II for inspiration and guidance (and being my roommate in college). This talk will demonstrate and discuss Retro6502, an open source Julia package licensed under the MIT license and available on GitHub at https://github.com/zot/Retro6502.jl Developing for the 6502 8-bit microprocessor typically means compiling/assembling code, loading it into an emulator or a physical machine, and running and testing it there. There are advanced debugging environments like C64Debugger and the beta RetroDebugger that let you visualize memory and even use omniscient debugging, stepping backwards in time and finding the code and point in time that drew a particular pixel. Despite these advantages, there is plenty of room for improvement. Coding and testing for the 6502 is tedious. Failure is always part of programming but the slow, error prone aspects of assembly language programming make it cost even more. If your 6502 code could somehow call Julia code outside the emulator, you could prototype and test in Julia and then, after the prototype code worked properly, you could write the 6502 code, radically reducing development time and relieving a lot of pain. Retro6502 allows you to do just that. It does not implement Julia for the 6502 instruction set but it does allow you to use Julia code during development that interoperates reentrantly with 6502 code inside the emulator. Also, you don’t have to write (or wait for) a C++ plugin to support extra features you want or need because you can just write them in Julia. Retro6502 initially focuses on the VIC-20 and Commodore-64 6502 architectures but provides hooks for extending into other architectures like Atari, Apple II, NES, etc. Retro6502 also supports - A Julia REPL extension: * Designated pure Julia 6502 emulator instance, * files watching for live coding. - Custom assembler where Julia is the scripting language, Exciting future directions like: - Rewindable execution (after a test, etc.) - Scrubbing back and forth in time and starting execution in the past to make alternate timelines. - Showing divergent future screens based on input variations. - Debugging with breakpoints and watchpoints that invoke custom Julia code. false Slides https://pretalx.com/juliacon2024/talk/FWD39E/ https://pretalx.com/juliacon2024/talk/FWD39E/feedback/ While Loop (4.2) Talk 2024-07-11T14:00:00+02:00 14:00 00:25 One of Julia's greatest strengths is processing gigabytes of tabular data in seconds. However, getting code ready for production and performant for web app users is another challenge. With Julia experience since 2015, this talk presents GLCS.io’s best practices in using Julia as a Service for large in-memory computation. juliacon2024-52827-effective-julia-computation-as-a-service Industrial Julia Michael Bologna en Perhaps one of the longest-running Julia applications used in production (since 2015) is for medical financial modeling. This data has many columns (100+), and one model can be upwards of 10GB+ on disk. Now consider giving users access to *multiple* models from a GUI that can ask database-like questions such as filter, groupby, transform, and join. Is this all possible to accomplish in a small number of seconds? The answer: generally, yes. After an initial start using JuliaDB.jl, [GLCS.io](http://GLCS.io) has moved away from this defunct package and utilized DataFrames.jl with a few more tricks. As a result, this database-like application has increased in stability and performance for end-users. This talk generically diagrams the architecture of this back-end service. We follow by covering the Julia packages utilized to make this service performant and available, ultimately resulting in a queryable endpoint that returns a database-like result set. The most important tips for writing data-heavy julia applications are discussed. Finally, we relect on where Julia can be used elsewhere and answer further questions. This Julia success story aims to encourage industry professionals (Managers and Developers alike!) to use Julia for their existing and greenfield projects. The hope is that existing Julia users will share this story with non-Julians they know and utilize Julia for themselves and their industry! Slides: [here](https://pretalx.com/media/juliacon2024/submissions/DWMEL7/resources/glcs_effective_julia_service_atxWiHK.pdf) Other useful links: - https://glcs.io - https://blog.glcs.io - https://github.com/GLCS false Slides https://pretalx.com/juliacon2024/talk/DWMEL7/ https://pretalx.com/juliacon2024/talk/DWMEL7/feedback/ While Loop (4.2) Lightning talk 2024-07-11T14:25:00+02:00 14:25 00:10 For many companies PowerPoint presentations are a common means of communication. The PPTX.jl package allows for automatically generating PowerPoint presentations filled with pictures tables and text. juliacon2024-44292-pptx-jl-an-open-source-package-by-asml Industrial Julia Xander en Within the Julia community there are many creative and exciting ways of presenting data, however, some companies still like the safe familiarity of a PowerPoint presentation. It may not be the most fancy way of presenting data, but it gets the job done. In this talk I would like to show an open-source contribution that ASML has made to the Julia ecosystem in the form of PPTX.jl a package that allows autmatic generation of PowerPoint presentations. false https://pretalx.com/juliacon2024/talk/YK9RRU/ https://pretalx.com/juliacon2024/talk/YK9RRU/feedback/ While Loop (4.2) Talk 2024-07-11T14:35:00+02:00 14:35 00:25 When developing a big project, there are good reasons to split it up into multiple packages. We look into the setup and workflow for developers where they need to make changes in multiple packages at once, while working with a team. We discuss the aspects of version management, testing, compilation times and deployment. We consider where the Julia tooling limits us and what could possibly lead to improvements. juliacon2024-50740-workflow-for-developing-multiple-interdependent-packages Industrial Julia Koen Rutten en When developing a big project, there are good reasons to split it up into multiple packages. We look into the setup and workflow for developers where they need to make changes in multiple packages at once, while working with a team. We discuss the aspects of version management, testing, compilation times and deployment. We consider where the Julia tooling limits us and what could possibly lead to improvements. false https://pretalx.com/juliacon2024/talk/9WMRXU/ https://pretalx.com/juliacon2024/talk/9WMRXU/feedback/ While Loop (4.2) Lightning talk 2024-07-11T15:00:00+02:00 15:00 00:10 The talk focuses on integrating Julia in a demonstrator car (Ford mondeo) to perform perception tasks (lidar pointcloud segmentation) in real-time. A special focus is set on the Phyton - Julia interface and how both languages can work well together. juliacon2024-44104-integrating-julia-for-perception-task-in-autonomous-driving Industrial Julia Gerhard Dorn en Future autonomous vehicles need to process a million LIDAR points in real time. Julia is a perfect fit for these perception tasks including ground segmentation, creation of a semantic occupancy grid or object detection. The talk shows how to use Julia in the development of ML algorithms and integration process in a real car. Special focus will be at the algorithmic development process (compared to PyTorch), experience with the training phase, integration process in C++ / Python environments, parallelism and runtime issues. The results presented in this talk have been created within the EU project AI4CSM (ai4csm.eu) (ECSEL Joint Undertaking program). false Slides without videos https://pretalx.com/juliacon2024/talk/SMPJ9S/ https://pretalx.com/juliacon2024/talk/SMPJ9S/feedback/ While Loop (4.2) Talk 2024-07-11T15:20:00+02:00 15:20 00:25 PeaceFounder is a centralised E2E verifiable e-voting system that enhances privacy and simplifies deployment by leveraging history trees and pseudonym braiding. This talk introduces it and highlights the use of Julia for its development, emphasising its strengths in suitability for complex, full-stack applications. juliacon2024-44296-unveiling-full-stack-development-with-peacefounder Industrial Julia Janis Erdmanis en In conventional E2E verifiable e-voting systems such as Helios, Verificatum, ElectionGuard and others, the vote is stored in a group element, encrypted and signed with a digital identity provider, and then submitted to the bulletin board. When the vote closes, votes go through the reencryption shuffle and are decrypted in the threshold decryption ceremony. Voters can ensure that their vote has been counted by finding their encrypted vote within the list of inputs of the mix cascade. Furthermore, everyone can verify the final tally by counting the decrypted votes and verifying supplemented zero-knowledge proofs without compromising privacy. In this way, the integrity of the election result can be assured. However, issues like forced abstention and potential vote substitution of unverified votes can happen if authorities are corrupt and auditing/monitoring does not occur. Publishing vote-casting signatures can alleviate many of those issues, but that violates participation privacy. The threshold decryption ceremony further compounds the system's complexity; if more than a few collude, votes remain encrypted, while a low threshold risks privacy breaches. The result is that deploying current E2E verifiable voting systems is the unreachable goal for small and medium-sized organisations if privacy, integrity and robustness are assured. PeaceFounder is an alternative approach that is the first to revitalise the work proposed by Haenni & Spycher and improve it using history trees. The immutability of the bulletin board is maintained replication-free by voter’s client devices with locally stored consistency-proof chains. Meanwhile, pseudonym braiding done via an exponentiation mix before the vote allows anonymisation to be transactional with a single braider at a time. In contrast to existing E2E verifiable e-voting systems, it is much easier to deploy as the system is fully centralised, free from threshold decryption ceremonies, trusted setup phases and bulletin board replication. Furthermore, the body of a vote is signed with a braided pseudonym, enabling unlimited ballot types. You might wonder why Julia is for such a project. Julia is known for high-performance computing but has yet to be the first pick for e-voting systems, cryptographic protocols or, in fact, full-stack applications. However, its rich ecosystem and code readability, adaptability, and performance make it an excellent choice. Furthermore, Julia's robust type system and multiple dispatch capability have been instrumental in precisely modelling and efficiently implementing the core structures of PeaceFounder. In the talk, following the introduction, I'll present a brief demo of the system. This will include server setup, registration of members, braiding, proposal announcement, voting, and, finally, the overview and auditing of the public evidence. Then, after the short demo, I will outline the project's requirements and how Julia ecosystem helps to address those needs. The last part of the talk will concern an obvious question of why the project is not done in the Rust. The reasons will include reliance on heterogonous lists, garbage collection, and operator overloading for cryptographic operations to keep the notations aligned with pseudocodes in the papers. A rich standard library has been a big plus. In contrast, using complex external libraries like QML or SMTPClient without worrying about compilation and linking issues has been a stellar experience. Furthermore, parallelising a proof of shuffle (if the scaling ever would need to be addressed) would be a much more pleasant experience in Julia as it is a simple HPC problem and even allows to explore the utilisation of GPU with elliptic curves on binary fields while also maintaining readability of the code. However, the lack of ability to deploy mobile apps written in Julia will likely make Rust relevant in the future, and this will be fine. Meanwhile, figuring out the exact details of how the PeaceFounder should function and include all imaginable features that do not impede deployability is much easier in Julia. Ultimately, a detailed specification of the PeaceFounder system will be necessary, and it's better if this specification is tested in practice rather than remaining theoretical. Through this talk, I present a convincing case for Julia as a viable candidate for complex full-stack applications. Additionally, I will introduce the PeaceFounder e-voting system, which may inspire some to try its deployment, report issues, and contribute to the project. For more details on the system, refer to a preprint that expanded upon work presented as [a poster at the EVoteID 2023](https://janiserdmanis.org/artefacts/EVOTEID-2023-poster.pdf). The preprint is available at https://eprint.iacr.org/2024/1040. false A Demo Set Up on Raspberry PI GitHub PeaceFounder Client Installers https://pretalx.com/juliacon2024/talk/U7JMMZ/ https://pretalx.com/juliacon2024/talk/U7JMMZ/feedback/ While Loop (4.2) Lightning talk 2024-07-11T15:45:00+02:00 15:45 00:10 Fugro is a global leader in geospatial data analytics, and as a part of our product workflows we need to deal with large amounts of data as efficiently as possible. In this presentation, we will describe how we use Julia to accelerate our HPC applications and how we integrate this with Amazon Web Services to distribute computing on the cloud. We will also cover some of the challenges and the insights we’ve gained on working with Julia in industry. juliacon2024-43540-julia-at-fugro Industrial Julia Ben CurranDr. Megan Dawson en Here at Fugro, we process large amounts of geospatial data in numerous HPC workflows to provide our clients with insights about real-world assets. Efficient processing enables faster delivery times for clients and reduced costs. We write our applications in Julia and have built systems using Github Actions that can seamlessly integrate these applications with cloud infrastructure hosted by Amazon Web Services (AWS). In this talk, we will outline our process at Fugro to develop a production-ready HPC application with Julia. This will start with how we build these packages into binary system images and integrate them into docker images. We will then show how to use AWS and Github to deploy these docker images to a cloud environment, as well as some design considerations along the way to ensure you get the most out of your application. Throughout we will share our experiences and lessons learnt for anyone starting or considering using Julia in an industrial application. false https://pretalx.com/juliacon2024/talk/VCPCRS/ https://pretalx.com/juliacon2024/talk/VCPCRS/feedback/ While Loop (4.2) Talk 2024-07-11T16:05:00+02:00 16:05 00:25 Integrating a model into a useful application is made challenging with today's tools. The difference in productivity that Julia offers for model-based app development creates a paradigm shift. This talk will demonstrate the workflow for developing a model integrated into an algorithm and application business logic in pure Julia, then wrapped in a c# windows desktop frontend. Benefits of this framework will be demonstrated and compared with an alternative Modelica workflow. juliacon2024-43442-how-a-julia-backend-accelerates-model-based-app-development Industrial Julia Bradley CarmanAvinash Subramanian en One of the biggest inefficiencies engineers and developers face when integrating a model into a useful algorithm or application is the dual language problem. Tools for building mathematical models are often designed purely for that task alone and are not written in a full featured programming language that allows the user to consume the model in a more useful way, such as integrating into a deployable application. The difference in productivity that Julia offers having solved the dual language problem offers a paradigm shift for model-based app development. This talk will demonstrate the workflow for developing a model using ModelingToolkit.jl and then integrating the model into a c# Windows based desktop application. The process of discovering a model bug at the end of the workflow and how this can be fixed nearly instantaneously will be demonstrated and compared with a Modelica workflow, proving an orders of magnitude improvement in development efficiency. false Presentation https://pretalx.com/juliacon2024/talk/F8VJAC/ https://pretalx.com/juliacon2024/talk/F8VJAC/feedback/ While Loop (4.2) Lightning talk 2024-07-11T16:30:00+02:00 16:30 00:10 TulipaEnergyModel.jl is a Julia/JuMP package developed by TNO and eScience Center that models the electricity market and its coupling with other energy sectors (e.g., hydrogen, heat, natural gas, etc.). Its main features are flexible connection based on graph theory, flexible temporal resolution, and the use of representative periods without losing accuracy. juliacon2024-44369-tulipaenergymodel-jl-an-efficient-and-flexible-energy-model Industrial Julia Diego TejadaLauren Clisby en TulipaEnergyModel.jl provides an optimization model for the electricity market and its coupling with other energy sectors (e.g., hydrogen, heat, natural gas, etc.). The optimization model determines the optimal investment and operation decisions for different types of assets (e.g., producers, consumers, conversion, storage, and transport). Currently, TulipaEnergyModel.jl has two main core features. The first one uses graph theory for a more adaptable model representation. This representation provides a more flexible framework to model energy assets in the system as vertices, and to model flows between energy assets as edges. This carrier-agnostic approach makes it adaptable to different systems. Furthermore, in the classic approach, nodes play a crucial role in modelling. By implementing our approach, as the nodes are no longer needed to connect assets, we can connect assets directly to each other, thus reducing the model size. The other core feature is fully flexible time resolution. TulipaEnergyModel.jl can handle different time resolutions on the assets and the flows even if they are not multiples of each other. Typically, the time resolution in an energy model is hourly and fixed through most of the model. Depending on the input data and the level of detail you want to model, hourly resolution in all the variables might not be necessary. TulipaEnergyModel.jl allows different time resolutions for each asset and flow to simplify the optimization problem and approximate hourly representation. This feature is particularly useful for large-scale energy systems that involve different sectors, so greatly speeding solving times since detailed granularity is not always necessary due to the unique temporal dynamics of each sector. false GitHub https://pretalx.com/juliacon2024/talk/ABAQSK/ https://pretalx.com/juliacon2024/talk/ABAQSK/feedback/ While Loop (4.2) Minisymposium 2024-07-11T16:40:00+02:00 16:40 00:20 A minisymposium dealing with the social and technical challenges of adopting Julia in an industrial environment. Speaking out on the qualms that we -- and our colleagues -- have with the language, we can start to address the real bottlenecks. At the same time, we indubitably have much to learn from each other's experiences. It could also be a motivation for others to start to make the push for Julia in their organization. juliacon2024-41880-industrial-julia-panel-discussion Industrial Julia Keith MyerscoughTom Lemmens en Call for Proposals: Have you deployed Julia in an industrial setting? Have you tried to teach your colleagues about Julia? We are keen to learn from you about the ups and downs of these experiences. We are aiming to make this an open session with plenty of room for discussion with the goal of improving the adoption of Julia as an industrial language. This can focus both on actions we can immediately take ourselves as well as on actions that require input from the wider Julia community and/or the Julia core developers. false https://pretalx.com/juliacon2024/talk/VWDUHM/ https://pretalx.com/juliacon2024/talk/VWDUHM/feedback/ REPL (2, main stage) Ceremony 2024-07-12T08:50:00+02:00 08:50 00:10 Opening the last day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer. juliacon2024-53125-opening-ceremony Raye Kimmerer en Opening the last day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer. false https://pretalx.com/juliacon2024/talk/7V7FX8/ https://pretalx.com/juliacon2024/talk/7V7FX8/feedback/ REPL (2, main stage) Keynote 2024-07-12T09:00:00+02:00 09:00 01:00 Large language model-based chatbots such as chatGPT are very impressive, but you cannot ask them to go out and learn how to ride a bike. Learning how to ride a bike is about an agent that learns a skill through efficient, real-time interactions with a dynamic environment. In this presentation, I will discuss the underlying technology that enables brains to learn new skills and acquire knowledge solely through unsupervised environmental interactions. juliacon2024-45605-natural-artificial-intelligence AI/ML/AD Bert de Vries en Large language model-based chatbots such as chatGPT are very impressive, but you cannot ask them to go out and learn how to ride a bike. Learning how to ride a bike is about an agent that learns a skill through efficient, real-time interactions with a dynamic environment. In this presentation, I will discuss the underlying technology that enables brains to learn new skills and acquire knowledge solely through unsupervised environmental interactions. How much do we understand about what brains compute? And is this knowledge transferable to AI engineering systems? I will discuss Karl Friston’s Free Energy Principle, which is the theory on what, why and how brains compute. I will also discuss the efforts of our research lab (http://biaslab.org) at TU Eindhoven to develop a Julia ecosystem of packages to support transfer of these ideas to working AI engineering tools. false https://pretalx.com/juliacon2024/talk/H3LLTK/ https://pretalx.com/juliacon2024/talk/H3LLTK/feedback/ REPL (2, main stage) Lightning talk 2024-07-12T10:10:00+02:00 10:10 00:10 [CodeEvaluation.jl](https://github.com/JuliaDocs/CodeEvaluation.jl) and its companion [IOCapture.jl](https://github.com/JuliaDocs/IOCapture.jl) are two small Julia packages that offer simple interfaces for emulating(*) Julia code execution (e.g. when evaluating code examples in documents). The talk will give a brief overview of the packages' interfaces, and discusses the challenges of trying to emulate Julia code execution. juliacon2024-44236-codeevaluation-jl-emulating-julia-code-evaluations Julia Internals and Tooling Morten Piibeleht en CodeEvaluation.jl is a higher-level package that offers an interface for executing Julia code snippets, and then capturing the outputs. You provide a code snippet as a string, and the package then tries to run it as if you pasted it into a clean REPL or started it as a script from the command line. The captured outputs aim to be a faithful representation of what you would see in the terminal. One non-trivial piece of the puzzle is the output capture. IOCapture.jl is a lightweight package that offers a simple interface to capture outputs (in particular, the standard output and error streams, and also the output from the logging macros) from arbitrary code execution, hiding away the complexity from you. Their main users for these packages is tooling that evaluates user-written code snippets, such as documentation and report generators. The code in these packages has been battle tested in the Documenter.jl code base for a long time, and is now factored out in the hopes is that it will be useful people writing similar tools. Acknowledgments: much of the hard implementation work was done by other contributors, and my main contribution here is factoring this into a separate package. (*) Just for clarity, the CodeEvaluation is not a Julia emulator, but evaluates the code snippets in the running Julia process. However, does tricks to make it look as if the code is running in a clean Main module. false GitHub Slides https://pretalx.com/juliacon2024/talk/KMKBYH/ https://pretalx.com/juliacon2024/talk/KMKBYH/feedback/ REPL (2, main stage) Lightning talk 2024-07-12T10:20:00+02:00 10:20 00:10 This project goes through the process of building an application dashboard with Pluto.jl. Although Pluto provides an excellent way to interact with notebooks, the result is always... well, a notebook! We exploit Pluto's flexible design and reactivity to customize it with a clear objective: make it look more like a dashboard and less like a notebook! But Julians are greedy, so we want to combine them by offering a "secret" developer mode for advanced users. Let's make Pluto-dashboards a thing! juliacon2024-43245-building-a-customized-application-dashboard-with-pluto-jl Notebooks & Graphics /media/juliacon2024/submissions/DBKMFD/dashboard_overview_26cqoDb.png Filippos ChristouNiels Hermsen en ## Motivation for a [Pluto.jl](https://plutojl.org/) dashboard Dashboards are a great way for users to interact with a large set of information. They are lightweight, trivial to use, and appealing. On the other hand, [Pluto.jl](https://plutojl.org/) is a Julia package that is excellent for experimenting with all kinds of Julia code using notebooks. [Pluto.jl](https://plutojl.org/) notebooks integrate code and their output in a browser and provide flexible bindings with HTML, CSS, and JavaScript. In this talk we will demonstrate how these two can be combined! ## Previous efforts There has been **independent** previous work on creating reactive dashboards with [Pluto.jl](https://plutojl.org/). - [Visualization Dashboards with Pluto](https://www.youtube.com/watch?v=dP9UuEL00iM) uses [Pluto.jl](https://plutojl.org/)'s isolated cell view to only show cell outputs instead of using JavaScript scripts to move or hide certain notebook parts. - [Pluto, Dashboards and ... Excel](https://www.youtube.com/watch?v=nRmLfB-bKdc) aims to create a dashboard with adding a new mode to notebooks where one can freely move cells around. Both projects make it easy for the user to create a dashboard, but offer less fredoom that one would have with using JavaScript scripts combined with HTML and CSS, like we do it in our approach. ## Presentation content - Motivation behind the project, why is it useful for the community and why can't we just use a normal notebook? - Using [Pluto.jl](https://plutojl.org/) to add HTML elements to the notebook as well as deploy JavaScript and modify the whole notebook. - Simplifying things and wrapping functionality in an external package. - Fusing everything together and creating a [Pluto.jl](https://plutojl.org/) dashboard! - A little bit about the future of the project. ## Background [Pluto.jl](https://plutojl.org/) notebooks consist of so-called cells that are filled with Julia code and output the result. The output can also be HTML code, which is appropriately rendered in the output section of that cell. The HTML code can also contain a `<script>` tag, so we can write custom JavaScript which is then executed in the browser. To make the application interactive, [Pluto.jl](https://plutojl.org/) offers a macro to bind custom HTML elements (e.g. buttons, sliders) to a Julia variable. The most interesting part is also the simplest, just bare [Pluto.jl](https://plutojl.org/) cells! We can move them on the dashboard and thus give the user the ability to add custom Julia code to the dashboard! This code can be everything, e.g. printing variables that aren't visible from the outside or even modifying parts of the dashboard - all limited by the user's creativity! ## Building the dashboard With all those functionalities, it is possible to - Render custom HTML code as output of a cell - Resize cell outputs to be fullscreen as well as move cells or hide [Pluto.jl](https://plutojl.org/) HTML elements completely - Load custom CSS frameworks like Bootstrap or Tailwind - Make custom interactive HTML elements that interact with the notebook as in triggering a change of a Julia variable - Give advanced users the possibilty to write Julia code in traditional [Pluto.jl](https://plutojl.org/) cells To keep the notebook file clean, we wrote a package that contains all needed functions which can directly be used by a notebook to build a dashboard. ## Working example The current working example of such a dashboard in [Pluto.jl](https://plutojl.org/) focuses on the libraries [MINDFul.jl](https://github.com/UniStuttgart-IKR/MINDFul.jl) and [MINDFulMakie.jl](https://github.com/UniStuttgart-IKR/MINDFulMakie.jl). They are simulation tools for intent-based multi-domain networking, which means we can create, edit and visualise connectivity intents, a perfect use case for a dashboard to show off capabilities of a library. The dashboard has buttons and drop down menus for creating and editing intents as well as boxes to put the plots which visualise those intents in. On top of that, we also have a developer mode, which gives the user access to [Pluto.jl](https://plutojl.org/) cells, so they can tinker with the library and do more advanced things - limited by the creativity of the user! A static HTML export of said notebook can be found [here](https://unistuttgart-ikr.github.io/MINDFulNotebookExamples.jl/plutodash.html). The full notebook with instructions on how to run it can be found [here](https://github.com/UniStuttgart-IKR/MINDFulNotebookExamples.jl)! ## Where to? Currently all work goes into creating one customized dashboard which doesn't scale fast, that's why we have high interests in building a general framework to allow other users with interests in building a [Pluto.jl](https://plutojl.org/) dashboard creating those easier! In the future there will be a discussion about this project, where it will be decided whether we create said framework. false Table of created intents Developer mode presentation https://pretalx.com/juliacon2024/talk/DBKMFD/ https://pretalx.com/juliacon2024/talk/DBKMFD/feedback/ REPL (2, main stage) Talk 2024-07-12T10:30:00+02:00 10:30 00:30 Sioux is a high-tech service provider in the brainport region. Its Mathware department has a long-standing history as a technology translator, linking novel research to real-world applications. In this talk, I will showcase how we are adopting the Julia language for this purpose. juliacon2024-53113-building-bridges-with-julia General Keith Myerscough en Sioux is a high-tech service provider in the brainport region. Its Mathware department has a long-standing history as a technology translator, linking novel research to real-world applications. In this talk, I will showcase how we are adopting the Julia language for this purpose. false https://pretalx.com/juliacon2024/talk/TPVJ8Z/ https://pretalx.com/juliacon2024/talk/TPVJ8Z/feedback/ REPL (2, main stage) Talk 2024-07-12T11:00:00+02:00 11:00 00:30 Much of science can be explained by the movement and interaction of molecules. Molecular dynamics (MD) is a computational technique used to explore these phenomena, from noble gases to biological macromolecules. Molly.jl is a pure Julia package for MD, and for the simulation of physical systems more broadly. This talk will introduce Molly.jl and its features, which include a flexible interface for custom interactions and support for differentiable simulations. juliacon2024-43593-molly-jl-molecular-dynamics-in-julia Physics & Quantum Chemistry Joe Greener en Molecular dynamics (MD) is the physical simulation of a molecular system using Newton's equations of motion. It can be used to gain mechanistic insight into experiments and to make predictions. There are a variety of mature, widely-used packaged for MD including Gromacs, NAMD, LAMMPS and OpenMM. Due to the performance requirements of MD, however, these all consist of an interface layer and fast code running under the hood in one or more low-level languages. Julia presents an opportunity to write a MD package in the same language all the way down, making it easier to interact with and extend. Molly.jl, which has grown steadily since its inception in 2018, is such a package. It has had 13 non-trivial contributors and has been the focus of 3 Summer of Code projects. This talk will introduce Molly.jl including its features, its unique selling points, and the challenges of competing with mature software whilst allowing differentiability. Implemented features include classical biomolecular force field potentials, various integrators and thermostats, Monte Carlo simulation, enhanced sampling methods, support for different boundary types, and some analysis functions. The package is designed to be modular and extensible, with user-implemented potentials and simulators being as fast as the built-in versions. There is support for different precision and custom number types; for example, the recommended approach is to use Unitful.jl to ensure that all quantities have compatible units. The flexible logging interface allows user-defined properties to be recorded during a simulation, and there is simple functionality to animate trajectories using GLMakie.jl. Molly.jl is part of the JuliaMolSim ecosystem and is compatible with the AtomsBase.jl interface, allowing interoperability with packages such as ACEpotentials.jl and DFTK.jl. The emerging research field of differentiable molecular simulation (DMS) uses automatic differentiation, the technique usually used to train neural networks, to improve the force fields used in MD. DMS can also be used to train neural networks. It usually requires specialist MD software such as Jax MD or TorchMD. Molly.jl allows fast differentiable simulations of biomolecules on multi-threaded CPU and GPU by making use of Zygote.jl and Enzyme.jl. The ability to take gradients through GPU kernels written in a high-level language with CUDA.jl is a unique feature of Julia. To date Molly.jl has been used in research to improve biomolecular force fields with differentiable simulation and to compute transport coefficients. It is starting to attract users from the materials modelling and machine learning potential communities due to its flexibility and ease of use within the wider Julia package ecosystem. Future developments including bond and angle constraints, Ewald summation methods, better system setup and faster GPU performance aim to make Molly.jl a widely useful package for biomolecular simulation. false Talk slides GitHub https://pretalx.com/juliacon2024/talk/HRW3EU/ https://pretalx.com/juliacon2024/talk/HRW3EU/feedback/ REPL (2, main stage) Lightning talk 2024-07-12T11:40:00+02:00 11:40 00:10 When Julia 1.0 was released several years ago, we were faced with the challenge of migrating over our large Julia 0.4 codebase while making sure our customers didn't notice a thing. This talk is a story about reassessing life choices, keeping customers happy, and a quick build, slow release, 5 year, 40 step migration from 0.4 to 1.6. We hope to never have to do this again! juliacon2024-39351-migrating-from-julia-0-4-to-julia-1-6 General Philip Tellis en We started our Julia journey with version 0.2 over 10 years ago, and upgraded fairly quickly up to 0.4.7 as new versions were released. Then we started getting more customers, and our APIs stabilised, and migrations became expensive, so we sat at 0.4.7, watching every quarter as various dependencies reached the end of their supported lives. Given that migrations were expensive, we knew that whenever we migrated, it we'd have to make it count for many years to come. We started migrating our code to 1.0, deciding to skip all the advice about migrating to 0.7 first. While this was happening, Julia moved to 1.1, 1.2, 1.3, 1.4, and 1.5, so we decided to jump to 1.5 instead, and then Julia released 1.6. Over the course of the migration we developed a series of 40 steps that allowed us to change the underlying library while requiring only minimal changes to our customers' code. In this talk, we will quickly go over some of the more surprising changes we've had to make. We will not discuss plans for 1.10 or 1.11. false Online Presentation Downloadable Presentation https://pretalx.com/juliacon2024/talk/PSNXJ9/ https://pretalx.com/juliacon2024/talk/PSNXJ9/feedback/ REPL (2, main stage) Lightning talk 2024-07-12T11:50:00+02:00 11:50 00:10 How can you teach ChatGPT to write well informed Julia code? In this talk we’ll address the basic retrieval augmented generation (RAG) ideas that back JuliaHub’s AskAI feature; one of the most popular code generation tools for Julia. juliacon2024-43430-juliahub-s-askai-enhancing-chatgpt-with-julia-specific-context AI/ML/AD Panagiotis Georgakopoulos en JuliaHub’s AskAI feature has been generating good Julia code since the Spring of 2023. To power it up, we are processing a big archive of julia knowledge, and we are combing through it, to find the most relevant knowledge regarding the user’s query. In this talk we will discuss issues with Julia documentation maintenance, the splitting of this knowledge into chunks the retrieval and the context engineering required to achieve improved performance over plain ChatGPT. We’ll show that our methods improve ChatGPT (3.5) at least over two dimensions: - serving the latest relevant information and - reducing the hallucinations that make ChatGPT think that Julia is just python.jl Finally we’ll discuss limitations and next steps in Julia code generation, along with potential integrations into IDEs (Pluto, Jupyter) false slides https://pretalx.com/juliacon2024/talk/P8E8D9/ https://pretalx.com/juliacon2024/talk/P8E8D9/feedback/ REPL (2, main stage) Talk 2024-07-12T12:00:00+02:00 12:00 00:30 Turing.jl is a probabilistic programming language in Julia which have been around for a while now. Over the years it has seen a steady increase in use and adoption, with many users and contributors. Moreover, over the past few years Turing.jl has seen a lot of development in terms of new features and improvements, both in its core and in the surrounding ecosystem. And so in this talk I will give an overview of the current state of Turing.jl and where it is headed in the future. juliacon2024-43600-what-s-new-with-turing-jl-and-its-ecosystem General Tor Erlend Fjelde en Turing.jl is a probabilistic programming language in Julia, i.e. a framework that let's you do Bayesian inference for your problem at hand without too much hassle. Turing.jl is one of the older packages in Julia, with the first commits dating all the way back to when Julia was a mere v0.4. Since then it has seen a steady increase in use and adoption, with many interesting applications and contributions. And as Julia has matured and improved, so has Turing.jl. In addition to development on Turing.jl itself, the TuringLang team has also been working on a number of other packages that feed into the Turing ecosystem with the aim of modularizing the ecosystem and making it easier to use and extend, both inside and outside of Turing.jl. And so, as we just passed Julia v1.10 and internal whispers of the first major release (v1.0) of Turing.jl are forming, I thought it would be a good time to give an overview of the current state of Turing.jl and what the future holds. I'll also give an overview over the full ecosystem of packages that make up the Turing ecosystem and how this can be used to hook your code into the Turing ecosystem or simply use it to build your own stuff on top of. Finally, I'll showcase some success stories of people using Turing.jl to solve real-world problems. false Slides https://pretalx.com/juliacon2024/talk/DBXQMA/ https://pretalx.com/juliacon2024/talk/DBXQMA/feedback/ REPL (2, main stage) Talk 2024-07-12T14:00:00+02:00 14:00 00:30 Julia documentation is one of the sore points and usual barrier to entry for newcomers. To try to solve this we setup a website where curated examples and recipes can be contributed and shared to the community! juliacon2024-44160-julia-kitchen-the-finest-julia-recipes Community Jorge Alberto Vieyra Salas en Julia documentation is one of the sore points and usual barrier to entry for newcomers. Users coming from MATLAB suffer because MathWorks documentation has been curated and refined for commercial use. Python users have the advantage of python's ubiquity ... even though arguably python's documentation is as good or bad as Julia's there is *a lot* of it! With Julia.kitchen we are trying to provide documentation, examples and most important recipes a place to exist and to share. false https://pretalx.com/juliacon2024/talk/MGRXYP/ https://pretalx.com/juliacon2024/talk/MGRXYP/feedback/ REPL (2, main stage) Talk 2024-07-12T14:30:00+02:00 14:30 00:30 Python.jl takes seamless language blending to a new level, nearly creating a superset of Python and of Julia simultaneously. As an experiment on taking "just works" and "magical behavior" to the extreme, this package is not viable for use in critical applications but still provides insight on what is possible within a Julia package. In just a few hundred loc, this package uses dual parsing, language detection, and global variable transfer to create a remarkably native dual-language experience. juliacon2024-44388-python-jl-seamlessly-blend-python-and-julia General Lilith Hafner en Slide link: https://raw.githack.com/LilithHafner/JuliaCon2024_Python_Talk/main/reveal.js/index.html This talk will include demonstrations of Python.jl's capabilities; a description of how it enables those features; demonstrations of its failings and various tricky to reconcile differences between the two languages; and finally a discussion on what we can learn from a package like this. I hope that this talk will have impressive demos; a comedic air (as the package is of a lighthearted and exploratory nature); and provide insights into the possibilities uncovered when taking embedding DSLs into Julia to the extreme. The source code is available for review at https://github.com/LilithHafner/Jokes/tree/main/Python false GitHub https://pretalx.com/juliacon2024/talk/ZH3JN3/ https://pretalx.com/juliacon2024/talk/ZH3JN3/feedback/ REPL (2, main stage) Talk 2024-07-12T15:00:00+02:00 15:00 00:30 This talk introduces Kezdi.jl, a Julia package designed to ease the transition for Stata users into Julia's data analysis ecosystem. Recognizing Stata's limitations with big data and its cost, Kezdi.jl offers Stata-like syntax for data wrangling, exploratory analysis, and regression in Julia, leveraging the strengths of DataFrames.jl and Tidier.jl. The presentation will discuss the challenges Stata users face in adopting open source alternatives, and demonstrate Kezdi.jl's capabilities. juliacon2024-39781-kezdi-jl-a-data-analysis-package-for-economists Economics Miklós Koren en Stata (registered TM) is widely used by economists for data wrangling, exploratory analysis and regressions. Its scripting language is easy to learn and provides a user friendly syntax for these tasks. There is a large and active community of Stata users, discussing problems and developing custom packages. The cost of Stata and its performance limitations with big data encourage analysts to seek open source alternatives. Switching to popular R, Python or Julia solutions, however, requires very different syntax and, more importantly, mental models for analysts. The aim of our package, Kezdi.jl, is to help Stata users adopt Julia as their main language for data analysis. It implements the key data wrangling, exploratory analysis and regression operations in Julia, using Stata-like syntax. Inspired by and building on DataFrames.jl and Tidier.jl, it provides a user interface familiar for Stata users, while retaining the flexibility and high performance of Julia. The talk will illustrate the problem and the gap between existing solutions and user needs. We will showcase the Kezdi.jl implementation of the most widely used data analysis commands and discuss further development plans. false Slides Documentation GitHub https://pretalx.com/juliacon2024/talk/MSHLDP/ https://pretalx.com/juliacon2024/talk/MSHLDP/feedback/ REPL (2, main stage) Lightning talk 2024-07-12T15:40:00+02:00 15:40 00:10 Many interactive applications will, at some point, need to move work out of the primary user loop, into a background process that operates asynchronously. To do this easily, scalably, efficiently and robustly is a non trivial problem. This talk introduces _Horus.jl_, a Julia package that makes it easy create and run background jobs in any Julia application. juliacon2024-44429-horus-robust-background-jobs-in-julia Julia Internals and Tooling Avik Sengupta en Users expect interactive applications to always be responsive, even when doing large computations, or connecting to to unstable network services such as mail servers. So when an application needs heavy compute, or to perform action such as sending emails that don't need to be finished before a response is sent back to the user, a background job can be used to shift the work out of the main user loop. This can be done somewhat trivially with a thread or even an async task. However, that does not account for some requirements of robust multiuser systems. What happens if the application server crashes before the background job is completed? How do you distribute the load if a large number of simultaneous request are received? What happens if the task depends on a service (say a mail server) that is down at the moment? *Horus.jl* is a new Julia package that allows you to create background jobs easily. It uses Redis as a transactional queue, and that job will run successfully only once. It provides facilities for error handling and retries. It provides somewhat similar functionality, in Julia, to Python libraries such as Celery, or Ruby libraries like Sidekick. It is the missing piece to building large interactive applications in Julia. false https://pretalx.com/juliacon2024/talk/8Y9WVR/ https://pretalx.com/juliacon2024/talk/8Y9WVR/feedback/ REPL (2, main stage) Lightning talk 2024-07-12T15:50:00+02:00 15:50 00:10 [Prometheus](https://prometheus.io/) is an open-source monitoring system designed for reliability and scalability and is widely used to collect and analyze metrics from running systems and applications. In this talk I will present [Prometheus.jl](https://github.com/fredrikekre/Prometheus.jl) which is Prometheus client library written in Julia. juliacon2024-44499-service-monitoring-with-prometheus-jl Julia Internals and Tooling Fredrik Ekre en To collect metrics Prometheus *pulls* data from the server. In practice this means that Prometheus periodically sends an HTTP request to the server, and the server responds with the metrics it currently exposes. A metric can be almost anything, for example the total number of HTTP requests the server have received, or the total amount of allocated memory. On the server side it is thus necessary with a client library that gathers the metrics and responds to the HTTP request. In this talk I will present the Julia client library [Prometheus.jl](https://github.com/fredrikekre/Prometheus.jl) which seemlessly enables Prometheus integration for services running Julia. I will showcase the available functionality and demonstrate how to integrate into an existing Julia application. Finally, as a case study, I will discuss how Prometheus.jl has been integrated into the global package server network behind Pkg. false https://pretalx.com/juliacon2024/talk/NYEBZW/ https://pretalx.com/juliacon2024/talk/NYEBZW/feedback/ REPL (2, main stage) Talk 2024-07-12T16:00:00+02:00 16:00 00:30 In reinforcement learning problems, interactions between an agent and its environment are simulated in discrete time steps: after a pre-determined amount of time passes, the agent and environment exchange observations and actions that are used to generate new observations for the agent, etc. RxEnvironments.jl changes this assumption and uses a Reactive Programming framework to model agent-environment interactions, allowing interactions at any time and natively supporting multi-agent environments juliacon2024-43274-rxenvironments-reactive-multi-agent-environments AI/ML/AD Wouter Nuijten en Introduction At the core of Reinforcement Learning and self-organizing systems are agent-environment interactions, forming the framework for designing agents that learn by interacting with an external environment. In traditional Reinforcement Learning implementations, the agent and environment have a synchronized clock and communicate on a predetermined frequency. While this framework is convenient, it imposes a fixed temporal discretization on the communication protocol between the agent and the environment. Furthermore, because the environmental transition function usually takes the agent action into account, these environments are unable to simulate a multi-agent environment. The package RxEnvironments.jl alleviates these shortcomings by employing a reactive programming strategy to model agent-environment interactions. Users specify how agents and environments react to different stimuli and how internal states change in the absence of external stimuli. In this paradigm, the agent and environment can handle infrequent stimuli at any time and can react accordingly. Furthermore, by modeling the impact of agent-environment interactions, environments written in RxEnvironments generalize to multi-agent settings. The reactive behavior of RxEnvironments is implemented using Rocket.jl. Markov blankets RxEnvironments is inspired by the Active Inference community. This means that every agent and environment is separated from its environment by a Markov Blanket. By implementing interactions on these Markov Blankets, we fully specify how agents and environments incorporate stimuli from their Markov Blankets and determine the data to emit to subscribers. This separates the internal states of the agent and the environment from the observable states witnessed and emitted on the Markov Blanket. The power of reactivity Reactivity is at the core of the philosophy of RxEnvironments. A consequence of this is that the transition function in reinforcement learning is decomposed into two separate functions in RxEnvironments: A state transition function that models the behavior of an environment in the absence of any stimuli, and a function that describes the influence of actions on the environment internal state. By continually calling the state transition function and calling the action incorporation function reactively whenever an action is observed, the environment is simulated even in the absence of stimuli, or whenever an agent emits multiple actions in a short period. This decomposition of the transition function also enables multi-agent environments natively, since the environment knows how to react to any incoming action. As the action is not part of the transition function over time, we can add multiple agents to the same environment and the environment will behave accordingly. Contrast with traditional frameworks The impact of splitting this transition function is apparent when compared to popular Reinforcement Learning frameworks like OpenAI Gym. In Gym, the environmental simulation can only proceed when presented with an action from an agent, fixing both the amount of agents as well as the time simulated by the transition function. By introducing reactivity and splitting the transition function, we are not limited by these constraints: the environmental simulation will continue running until any agent conducts an action, and the environment will react to this action by updating its internal state. This allows more complex agent-environment interactions with a framework closer to real-world interactions. Conclusions RxEnvironments implements a different paradigm for simulating self-organizing agents in an environment than is common in reinforcement learning literature. By alleviating the constraints on the communication protocol between agents and environments we can model a wider scope of environments. A reactive programming approach keeps this paradigm computationally feasible while providing interesting byproducts, such as multi-agent environments. false https://pretalx.com/juliacon2024/talk/83ZWZN/ https://pretalx.com/juliacon2024/talk/83ZWZN/feedback/ REPL (2, main stage) Talk 2024-07-12T16:30:00+02:00 16:30 00:30 We discuss the design, development, and debugging of a highly parallel cloud-native application, with a deep dive into the tooling used, while highlighting difficulties and possible improvements within Julia’s ecosystem. juliacon2024-44420-a-cloud-native-parallel-data-processing-application-in-julia Data Science and Dynamics Ian ButterworthRyan Benasutti en Julia is a great choice for researchers and developers to write expressive and performant code, and promises a smooth transition to production level systems. This talk focuses on that intersection between research and production by explaining a cloud-native application we have built in Julia for highly parallel data processing. We will explain the application's design, demonstrate Julia's strengths, show how we debugged and profiled that application, discuss some of Julia's shortcomings when building such an application, and point out avenues of future work which can address these shortcomings. Topics include: - design: AWS, containerization, parallel Julia - debugging/profiling: Tracy.jl, Intel VTune, Profiling.jl - work in progress: easier identification of performance impeding lock contention false https://pretalx.com/juliacon2024/talk/XYTURN/ https://pretalx.com/juliacon2024/talk/XYTURN/feedback/ REPL (2, main stage) Keynote 2024-07-12T17:10:00+02:00 17:10 01:00 Quantum computing is an emerging field, with a variety of hardware platforms in development and proposed applications. We will review some of these hardware approaches and quantum algorithms in a way accessible to experts in classical computing, discussing the challenges that lie ahead for practical applications of quantum technology. Finally, we'll discuss the role Julia and its community can play in the field and opportunities to fix some of what Julia lacks in this area. juliacon2024-45601-why-i-use-julia-for-quantum-computing Physics & Quantum Chemistry Katharine Hyatt en Quantum computing is an emerging field, with a variety of hardware platforms in development and proposed applications. We will review some of these hardware approaches and quantum algorithms in a way accessible to experts in classical computing, discussing the challenges that lie ahead for practical applications of quantum technology. Finally, we'll discuss the role Julia and its community can play in the field and opportunities to fix some of what Julia lacks in this area. false Slides https://pretalx.com/juliacon2024/talk/G3HMAP/ https://pretalx.com/juliacon2024/talk/G3HMAP/feedback/ REPL (2, main stage) Ceremony 2024-07-12T18:10:00+02:00 18:10 00:20 Closing the final day of JuliaCon 2024. juliacon2024-53121-closing-ceremony Raye Kimmerer en Closing the last and final day of JuliaCon Global 2024 at Eindhoven with our full organizing committee. false https://pretalx.com/juliacon2024/talk/SSGKJ9/ https://pretalx.com/juliacon2024/talk/SSGKJ9/feedback/ If (1.1) Lightning talk 2024-07-12T10:10:00+02:00 10:10 00:10 Notebooks like Pluto provide a great environment for enhancing code with explanations and interactive explorability. While popular with experimental research code, this is rarley found in package implementations. Since Pluto notebooks are actually plain Julia code under the hood, they can be used to implement a package while still being a descriptive place for exploration. In this talk, we learn how to use packages like PlutoDevMacros and PlutoTest to go from quick and dirty to reusable! juliacon2024-44500-literate-package-development-using-pluto Notebooks & Graphics Andreas Kröpelin en We have come a long way since Donald Knuth's WEB programming language for literate programming from the 1980s. His vision of interweaving code for the computer and text for humans is still popular today, however. Nowadays, notebooks like Jupyter and Pluto are the most popular tools for that purpose. While Jupyter notebooks are stored as JSON files and can therefore only be interpreted as notebooks, Pluto uses plain Julia files and annotates it with some comments to specify the notebook structure. This means that other Julia code does not have to concern itself with the Pluto-origin of that file and can just interact with it as with any other Julia file. Among many others, one benefit of this fact is that the Pluto notebook can contain the implementation of a reusable package. Such a package often naturally evolves from a script or notebook that answers one specific research question when the broader context and applicability become evident. Usually, this evolution then means starting from scratch and reimplementing the logic from the exploration. The extracted package will also miss all the deeper explanations and derivations of the implemented algorithms that were present in the notebook, making it literal in Knuth's sense. Additionally, more often than not, one will continue to experiment with the original code and, at this point, much effort is necessary to keep the code bases in sync. Therefore, transforming the explorative notebook into the package itself can be an alternative worth considering. A growing package quickly becomes impractical to maintain in a single file or notebook. Here, packages like PlutoDevMacros and PlutoLinks help because they are able to connect multiple Pluto notebooks with eachother. With PlutoTest, we can even add interactive testing for our code. In this talk, we follow an example that starts as a typical research notebook and then showcases the evolution towards a reusable package by employing the mentioned packages step by step. The devolper experience is not yet perfect at this point, so the purpose of this talk is merely to suggest a workflow for literate package development and hint at where further improvements could be beneficial. false https://pretalx.com/juliacon2024/talk/JCRRLL/ https://pretalx.com/juliacon2024/talk/JCRRLL/feedback/ If (1.1) Lightning talk 2024-07-12T10:20:00+02:00 10:20 00:10 Pluto Notebooks are awesome for building quick experiments and dashboards. But did you know that you can also create real-time processes by reusing Pluto's reactivity? In this talk I will demonstrate to you how powerful Pluto notebooks really are. juliacon2024-44472-build-real-time-processes-with-pluto-s-reactivity Notebooks & Graphics Stephan Sahm en PlutoHooks.jl has been out for quite some time, but not many know about these hidden Pluto gems. While PlutoUI is about client-side triggers, PlutoHooks is about server-side triggers, also called self-updates. Actually the mechanism is built into Pluto itself. This talk I will showcase a concrete example: Applying RxInfer.jl for real time probabilistic prediction of financial bitcoin data. false https://pretalx.com/juliacon2024/talk/TVDJ3H/ https://pretalx.com/juliacon2024/talk/TVDJ3H/feedback/ If (1.1) Talk 2024-07-12T10:30:00+02:00 10:30 00:30 Interactive package development in Julia is possible thanks to Revise.jl, which is an amazing tool but still has a few drawback like the need to restart julia when modifying struct definitions. This talk will introduce a set of tools from the PlutoDevMacros.jl and PlutoVSCodeDebugger.jl packages which aim to improve the package development and debugging workflow using Interactive Pluto notebooks. juliacon2024-44153-pluto-jl-interactive-package-development-and-debugging Notebooks & Graphics Alberto Mengali en This talk will introduce and explain the use of the `@frompackage` macro from PlutoDevMacros which can be used to load a target local package under development inside a Pluto notebook. This macro also emulates a manual Revise-like workflow that reloads the latest package definitions within the notebook on demand. Thanks to Pluto reactivity and its capability of redefining structs, this workflow will automatically trigger re-execution of test code in the notebook when reloading a package code and will reduce the need of restarting the julia sessione when changing struct definition inside package code. A part of this talk will also be allocated to the introduction of the PlutoVSCodeDebugger.jl package which provides a streamlined way to attach a VSCode instance to a running Pluto notebook for debugging notebook code via the VSCode debugger GUI. The two packages can be used together to greatly streamlined package development and debugging inside Pluto false https://pretalx.com/juliacon2024/talk/MKDTV3/ https://pretalx.com/juliacon2024/talk/MKDTV3/feedback/ If (1.1) Talk 2024-07-12T11:00:00+02:00 11:00 00:30 [Quarto](https://quarto.org/) is an open-source scientific and technical publishing system that was first presented at JuliaCon 2022. We propose new extensions and workflows that we hope will help the community embrace this promising new tool and boost developers' efforts toward effective communication and reproducibility. juliacon2024-43410-quarto-extensions-for-the-julia-community Notebooks & Graphics /media/juliacon2024/submissions/JGT893/intro_cbQtgY6.gif Patrick AltmeyerRonny Bergmann en What if there was a single tool, an engine that can turn your work into all kinds of different output formats? Markdown, PDF, LateX, beamer, HTML, reveal.js, ePub, MS Office, OpenOffice, entire websites, dashboards … all of that starting from the same place: a plain Markdown document blended with chunks of your favorite programming language. That is the prospect that Quarto offers. **Note**: Please find the Revealjs slides [here](https://www.patalt.org/quarto-julia-website/examples/contributed/juliacon_2024/quarto_extensions/presentation.html#/sec-quarto) or see the PDF slide pack attached. ### 🤕 Those Damn Edge Cases ... The problem is that this is a very ambitious prospect. Even though Quarto is being continuously improved by a committed and responsive development team, there will always be edge cases that require customization. Your presentation at work, for example, might have to comply with certain styling rules. Similarly, the journal you are targeting for your next research project almost definitely has very specific editing guidelines that (if you're lucky enough) are specified in a LaTeX template. In both cases, you will need to invest some time into modifying or extending the behavior of Quarto. ### 🚑 Quarto Extensions to the Rescue Thankfully - and in true open-source spirit - Quarto has come up with a way to ensure that such efforts never go in vain: [extensions](https://quarto.org/docs/extensions/). Producing and sharing extensions is so simple that it feels almost like a by-product of tailoring Quarto to your specific use case. > When I first learned about extensions, I had already created a custom template for myself to create reveal.js presentations in the iconic white-blue theme of Delft University of Technology. Releasing that [template](https://github.com/pat-alt/quarto-tudelft) to the public was almost as easy as creating my first Julia package (obligatory hat tip to the folks behind PkgTemplates.jl). > > — Speaker 1 A few months later, Speaker 1 heard from at least a few of their colleagues that they had presented pretty HTML slides in white and blue right from their browser. ### 🔴🟢🟣 Julia-Themed Quarto [Julia-Themed Quarto](https://www.paltmeyer.com/quarto-julia-website/) presents a number of Quarto extensions that are specific to Julia and will be the topic of this talk. 1. The [quarto-julia](https://github.com/pat-alt/quarto-julia) extension contributes various basic format templates for Julia-themed HTML content. It ships with standard Julia colors and fonts to provide your next presentation with a beautiful look. 2. The [quarto-juliacon-proceedings](https://github.com/pat-alt/quarto-juliacon-proceedings) extension is a more ambitious project. This extension adds support for writing JuliaCon Proceedings papers in Quarto. It is based on the existing [JuliaCon Proceedings LaTeX template](https://github.com/JuliaCon/JuliaConSubmission.jl) and can be used to render standard [PDF](https://www.paltmeyer.com/quarto-juliacon-proceedings/template.pdf) while leveraging all of Quarto's functionalities such as executable code chunks. On top of that, it provides a new [HTML](https://www.paltmeyer.com/quarto-juliacon-proceedings/template.html) template that currently inherits the style of [quarto-julia](https://github.com/pat-alt/quarto-julia). This provides new opportunities for JuliaCon Proceedings papers to include animated and interactive content. 3. Finally, the [Julia-Themed Quarto](https://www.paltmeyer.com/quarto-julia-website/) website also includes a section on the marriage of Quarto and Documenter.jl. This has not yet been turned into a fully-fledged extension but we provide guides for common workflows that facilitate this marriage. This topic will be presented by Speaker 2. ### 🎯 Goals and Limitations The [quarto-juliacon-proceedings](https://github.com/pat-alt/quarto-juliacon-proceedings) is not yet officially supported and there remain some [issues](https://github.com/pat-alt/quarto-juliacon-proceedings/issues) that need to be addressed to make it fully compatible with the existing LaTeX template. Similarly, there is scope for improvement concerning the experience of using Quarto with Documenter.jl. We hope that through this talk we can stimulate discussion in the community and encourage others to contribute to these efforts. false Github Link to slides (Revealjs) PDF Slides https://pretalx.com/juliacon2024/talk/JGT893/ https://pretalx.com/juliacon2024/talk/JGT893/feedback/ If (1.1) Lightning talk 2024-07-12T11:40:00+02:00 11:40 00:10 At PumasAI, we create a lot of tables. No existing package could deliver minimalistic, aesthetic, flexible tables with the same look across docx, HTML, LaTeX and Typst formats. So we wrote our own! This talk introduces SummaryTables.jl, showcasing its included pharma-focused table functions and options to create your own formats. We'll also take a brief look at WriteDocx.jl, another new package which allows to create docx files from scratch in Julia (and put SummaryTables tables into them!). juliacon2024-43795-summarytables-publication-ready-tables-in-docx-html-latex-typst Notebooks & Graphics /media/juliacon2024/submissions/KZNFPS/summarytables_example_wJUMHoe.png Julius Krumbiegel en The workflows of many pharma companies we work with at PumasAI involve creating reports in a mixture of formats: HTML, pdf via LaTeX and Typst, or docx files which are often the easiest way to quickly edit together the assets our users need at any given moment. While general-purpose tools like pandoc allow targetting many output formats, including HTML, pdf and docx, style information is usually lost in translation. This was not good enough for our purposes, we wanted a tool to create our tables with the same look across all formats. This requirement also prompted the development of WriteDocx.jl, which through its detailed mapping of the actual docx XML spec, allows creating docx files with much higher precision than using a generic conversion tool. The other purpose of SummaryTables.jl is to offer a collection of statistical table formats that are commonly found in pharma-related workflows. Currently, we have implemented listing tables, parameter summary tables and what's commonly called a "table 1" in our field. With the open-sourcing of SummaryTables.jl and WriteDocx.jl, we want to contribute back to the Julia ecosystem and strengthen its arsenal of utility packages which are useful in the pharma world and beyond. false https://pretalx.com/juliacon2024/talk/KZNFPS/ https://pretalx.com/juliacon2024/talk/KZNFPS/feedback/ If (1.1) Lightning talk 2024-07-12T11:50:00+02:00 11:50 00:10 Typst is a modern type setting system excelling at user experience and compilation speed. In this talk, I present the package Jlyfish for Typst and Julia that allows users to include Julia code directly in the Typst source, have it executed, and its output inserted into the document. Similar to PythonTeX for LaTeX, this enables a workflow where results of computations are not hardcoded in the document but dynamically inserted, making the latter reproducible and in sync with the rest of the code. juliacon2024-43479-jlyfish-reproducible-documents-with-julia-and-typst Notebooks & Graphics /media/juliacon2024/submissions/QPMKZP/logo_FHxZqgE.svg Andreas Kröpelin en [Jlyfish on GitHub](https://github.com/andreasKroepelin/TypstJlyfish.jl) There are many software solutions that combine code, its output, and prose. Beginning with interactive notebooks such as Pluto or Jupyter, over code presentation focused systems like Weave.jl or Quarto, to extensions for general purpose typesetting software like PythonTeX for LaTeX or showman for Typst. Jlyfish can be found in the last catergory and aims at providing the best interaction between Typst and Julia. To this end, it consists of a package for Typst and one for Julia and makes use of Julia's powerful features. As Typst supports displaying text, PNG, JPG, and SVG, Jlyfish will use Julia's display system to display the result of a computation in the richest possible MIME type. It additionally supports the MIME `"text/typst"` that will then be interpreted as Typst source code on the Typst side, allowing emitting markup or more complex document features. Users can also configure whether the Julia code, the standard output, and/or logs should be shown in the document. Julia's support for metaprogramming facilitates parsing the user provided code and evaluating it in an encapsulated module and its own environment. The Julia package is used like a standalone program by calling a `watch()` function. It then watches the Typst source file for changes and automatically reruns evaluation, but only if the Julia code has actually changed. In this talk, I will briefly introduce Typst and why one should consider preferring it over LaTeX. Then, I will present how to use Jlyfish and how it works behind the scenes, focussing on the Julia parts. After demonstrating what is possible with Jlyfish today, I will close with some ideas for its future development. false presentation slides https://pretalx.com/juliacon2024/talk/QPMKZP/ https://pretalx.com/juliacon2024/talk/QPMKZP/feedback/ If (1.1) Lightning talk 2024-07-12T12:00:00+02:00 12:00 00:10 TidierPlots.jl is a faithful reimplementation of R's ggplot2 package in Julia. It relies on AlgebraOfGraphics and Makie to generate plots while retaining syntax that will be very familiar to users coming from the tidyverse. This lightning talk will discuss the development process, the current state of the package, and the future goals for its capabilities and use. juliacon2024-42845-tidierplots-jl-bringing-ggplot2-to-julia Notebooks & Graphics Randall Boyes en TidierPlots.jl is part of the Tidier ecosystem of packages in Julia which aim to bring the functionality and syntax of R's tidyverse packages to Julia users. TidierPlots.jl is the reimplementation of ggplot2, which provides data visualization capabilities. This lightning talk will discuss the origins and motivations of the package, challenges I have encountered in development and their solutions, and my future goals for the package. I will also highlight the areas where the design of the Julia Language has already allowed for extensions on the capability of TidierPlots as compared to the original ggplot2. false Link to Package https://pretalx.com/juliacon2024/talk/CJ3P9D/ https://pretalx.com/juliacon2024/talk/CJ3P9D/feedback/ If (1.1) Lightning talk 2024-07-12T12:10:00+02:00 12:10 00:10 This talk will highlight the year's most interesting developments around Makie, the powerful and high-performance data visualization ecosystem written almost entirely in Julia. juliacon2024-44446-what-s-new-with-makie-jl Notebooks & Graphics /media/juliacon2024/submissions/CXVZMP/makie_banner_USF41xp.png Simon DanischJulius Krumbiegel en Makie is Julia's most extensive and powerful "native" plotting ecosystem, where everything but the lowest level drawing routines is written in Julia. This also makes it one of the most flexible and hackable systems to build interactive or static data visualizations with. It supports gpu-accelerated rendering on desktops and in web browsers, vector graphics, as well as experimental ray tracing. Makie has seen a lot of development in the last year, and in this talk, we'll summarize the most important aspects for you. Get inspired by the cool things people are creating with Makie right now, and get excited by what's in store for the next year! false https://pretalx.com/juliacon2024/talk/CXVZMP/ https://pretalx.com/juliacon2024/talk/CXVZMP/feedback/ If (1.1) Lightning talk 2024-07-12T12:20:00+02:00 12:20 00:10 How to create and deploy interactive Dashboards with Makie and Bonito. juliacon2024-44275-interactive-dashboards-with-wglmakie-and-bonito Notebooks & Graphics Simon Danisch en In this brief talk, we'll explore the essentials of creating interactive dashboards in Julia using the Makie and Bonito packages. I'll introduce the fundamental capabilities of Makie for dynamic data visualization and demonstrate how to build an interactive dasbhoard for it with Bonito. The talk will include a quick walkthrough of a basic dashboard setup, highlighting key features, a few notes about deployment and the seamless integration of both tools in Julia. Attendees will leave with an understanding of how to get started with these tools for interactive data visualization. false https://pretalx.com/juliacon2024/talk/GA7JNJ/ https://pretalx.com/juliacon2024/talk/GA7JNJ/feedback/ If (1.1) Talk 2024-07-12T14:00:00+02:00 14:00 00:30 Path planning is used in applications from self-driving cars, unmanned aerial vehicles and in robotics. Recent developments in mathematical optimization theory and more capable solvers will enable exciting optimization-based techniques to further improve performance and reliability of autonomous systems. This talk will walkthrough from theory to application how trajectory optimization can be applied in the context of path planning for your desired application. juliacon2024-44248-optimization-methods-for-robot-motion-planning-in-jump Optimization Alexander Leong en The optimization problem is as follows: our objective is to find the “smoothest” path from a starting point to an end point such that we avoid collision with any obstacles. The obstacles are assumed stationary for all time. Smooth means not jerky (i.e. low rate of change in acceleration over time). To represent this problem, the map is divided into a set of safe regions. A safe region is one that does not contain any part of an obstacle. This is done so we can use mixed integer programming to assign path segments to safe regions. The paths themselves will be represented as polynomials. Using Hypatia, a generic conic solver with MOSEK solver one can solve this problem. Once a feasible and optimal solution is found we need to visualize to verify the results. The talk will demonstrate using Makie to analyze these results. Furthermore, using IJulia, one can develop dashboards in an REPL like fashion so researchers and scientific programmers alike can focus on the problem at hand. We will discuss some main concepts such as observables, accepting user input and dynamically updating charts. Finally, the talk will discuss the main results for a numerical experiment and outline the challenges associated with optimization-based approaches and techniques the practitioner can apply. This includes exploring some of the main APIs in JuMP and related math packages used to solve this optimization problem. The talk is appropriate for a general audience especially for those in applied math, engineering, and robotics. false GitHub Presentation https://pretalx.com/juliacon2024/talk/WKX8SB/ https://pretalx.com/juliacon2024/talk/WKX8SB/feedback/ If (1.1) Talk 2024-07-12T14:30:00+02:00 14:30 00:30 Polygonal complexes are combinatoric objects that arise from polyhedra and facilitate various combinatoric and geometric studies. In this talk, we present the Julia package GeoCombSurfX which enables the study of polygonal complexes and the construction of their corresponding embedding. Moreover, we demonstrate the usage of our package by targeting the problem of deciding whether a given asssembly of 3D-blocks gives rise to a topological interlocking. juliacon2024-44059-geocombsurfx-exploring-properties-of-polygonal-complexes Math(s) /media/juliacon2024/submissions/YDS7HF/assembly3_6431_nViE3uG.png Sascha StüttgenReymond Akpanya en By denoting the incidence structure of the vertices, edges and facets of a given polyhedron, a polygonal complex is obtained. In our talk we give an overview of the basic definitions and the underlying theory of convex and non convex polyhedron and their corresponding polygonal complex. A given polygonal complex can be analysed from a combinatoric point of view by examining the corresponding isomorphism group, different vertex- and edge-colorings and manipulations of the incidence structure that give rise to new polygonal complexes, whereas geometric properties that can be highlighted are convexity properties of the given complex and the problem of embedding the complex into 3-space as a polyhedron. Julia's diverse package ecosystem and great performance makes it a suitable candidate to develop a software that contains implementations to analyse all aspects that arise in the study of polygonal complexes. As an example for the usage of our package we formulate the interlocking problem of an assembly of 3D-blocks. This problem can be summarised as follows: Suppose you are given a collection of blocks, which are in contact with one another and a subset of the blocks (frame) that is fixed in space. Are there non-zero simultaneous motions of the remaining blocks such that applying these motions to the blocks of the assembly does not result in penetrations of any blocks? If there are no such motions, the assembly is called topologically interlocking. Furthermore, we describe a sufficient criterion for a given assembly to be topologically interlocked and outline how Julia and its ecosystem, in particular the packages Polyhedron.jl, JuMP.jl and HiGHS.jl, can be used to tackle this problem. Finally, we describe future projects and features that we aim to include into GeoCombSurfX-package. We want to make use of the OSCAR project to answer algebraic questions about polygonal complexes. In particular, OSCAR offers an interface to the computer-algebra system GAP that is being developed at RWTH Aachen University and for which a package has already been implemented that deals with combinatorial aspects of polygonal complexes. Further, we want to parameterise all embeddings of polygonal complexes into 3-space with triangular faces and given edge lengths algebraically, which requires the exact solutions of multivariate polynomial systems over the reals. false Slides https://pretalx.com/juliacon2024/talk/YDS7HF/ https://pretalx.com/juliacon2024/talk/YDS7HF/feedback/ If (1.1) Talk 2024-07-12T15:00:00+02:00 15:00 00:30 This talk is about Attractors.jl, the newest module of DynamicalSystems.jl. It is the result of two _featured_ scientific articles, and implements several new cutting edge tools to study stability in dynamical systems. It goes beyond traditional continuation tools by focusing explicitly on multistability and global stability, concepts extremely relevant for modern applications of dynamical systems such as climate tipping points or power grid stability. juliacon2024-39588-attractors-jl-next-gen-multi-stability-analysis Math(s) George Datseris en Attractors.jl is a Julia package (part of the DynamicalSystems.jl) focusing on finding attractors of dynamical systems and continuing them along a parameter axis. Attractor is a concept that generalizes established concepts such as "fixed point" and "steady state". Our approach with Attractors.jl was inspired by modern applications of dynamical systems: where multistability is crucial, and transitions between attractors (often termed as "tipping points") is one of the most important aspects of the system to understand. That is why we designed Attractors.jl to be different than traditional "continuation" software. Our approach is like a "birds-eye-view" of the state space, instead of focusing locally on a particular point. This approach comes with two strong benefits: 1) multistability can be detected automatically, 2) stability of attractors is quantified in terms of more powerful and general concepts of global stability (versus the established standard concepts of local stability). Additionally, Attractors.jl has been designed so that its core interfaces are extendable out-of-the-box, allowing future progress in stability analysis to be directly integrated with the package! In this talk we will discuss the following points: - Introduction to multistable dynamical systems for a general audience (with some background in math or natural sciences) - Overview of the features of Attractors.jl - The importance of multistability and global stability in real-world applications of dynamical systems - The interface(s) of Attractors.jl and their extendable design - Comparison with traditional continuation software - A runnable code snippet using the package false https://pretalx.com/juliacon2024/talk/ABCYFC/ https://pretalx.com/juliacon2024/talk/ABCYFC/feedback/ If (1.1) Lightning talk 2024-07-12T15:40:00+02:00 15:40 00:10 In this 10-minute talk, we will explore the usage of the open source geospatial visualization app, KeplerGl (formerly Uber but now under OpenJS foundation) within a Pluto notebook ecosystem. Users are able to add data in the form of DataFrames and add filter configurations in a similar manner. juliacon2024-44492-using-keplergl-visualizations-in-pluto Notebooks & Graphics Thaddeus Low en At Teleport, we run Agent-Based-Modeling simulations on OpenStreetMaps to simulate ridesharing in different cities. In this quick, 10-minute chat, we'll dive into how you can use the KeplerGl toolkit to spice up your geospatial data visualization in Julia's Pluto notebooks. Think of it as a cool way to make your maps and spatial data analysis more interactive and visually impressive, all within the easy-to-use Pluto notebook environment. false https://pretalx.com/juliacon2024/talk/ELKWRN/ https://pretalx.com/juliacon2024/talk/ELKWRN/feedback/ If (1.1) Lightning talk 2024-07-12T15:50:00+02:00 15:50 00:10 One of the options to build a GUI in Julia is the [QML.jl](https://github.com/JuliaGraphics/QML.jl) package, which provides the tools to connect a Qt QML GUI to Julia code. The package has been around for some years, but in 2023 it was updated to use Qt 6 and a new, more flexible model was introduced for working with tables. This talk will focus on these enhancements. In addition, there will be some remarks on graphical GUI design tooling and future Makie.jl integration plans. juliacon2024-44382-what-s-new-in-qml-jl Notebooks & Graphics Bart Janssens en The [Qt QML language](https://doc.qt.io/qt-6.5/qmlapplications.html) allows users to describe graphical user interfaces using a declarative programming style, similar in style to a JSON file. A simple example for showing a rectangle is: ```qml import QtQuick import QtQuick.Controls ApplicationWindow { Rectangle { width: 100; height: 100; color: "red" Text { anchors.centerIn: parent text: "Hello!" } } } ``` The QML.jl package offers the infrastructure to launch the GUI from within Julia, and link Julia functions and values to elements of the GUI. This makes it possible to e.g. execute a Julia function when clicking a button, or show the output of a plot command in the GUI. Since the previous presentation of QML.jl at JuliaCon 2020 Qt has been upgraded to version 6, and QML.jl now supports this. Aside from overall improvements in quality and performance, this change also enables full compatibility with Wayland on Linux and the matching of the native platform desktop style has improved, so applications can take on a Windows or macOS look automatically on the respective platform. Qt 6 also introduces a new way of using tabular data, which prompted the development of the new `JuliaItemModel` type, which makes it easier than ever to present and modify tabular data in any of the standard QML elements that take a table or list of items. One possible application for this is to make an interactive `DataFrame` editor, for example. The objective of this talk is to illustrate these new features, based on a simple demo application for working with tables, which we will first design in a GUI design tool. Even though QML is an easy language to read and write, many people prefer to design GUIs visually, so we will show that this workflow is also possible for QML.jl, using the standard tools provided by Qt. Once the GUI design is complete, we will show how to link it to Julia code and data. Finally, we will end with some remarks on future work, such as more elaborate and up-to-date support for Makie.jl. Indeed, QML.jl already supports overlaying both regular OpenGL content and Makie.jl scenes with QML elements, but the idea is to split off this functionality into a separate package, so it becomes easier to use and keeps up better with the latest Makie version. ## Resources * [Slides](https://slides.bartjanssens.org/juliacon2024/) * [Demo code](https://github.com/barche/QMLJuliaCon2024) false GitHub https://pretalx.com/juliacon2024/talk/MZUBGM/ https://pretalx.com/juliacon2024/talk/MZUBGM/feedback/ If (1.1) Talk 2024-07-12T16:00:00+02:00 16:00 00:30 Rosenbrock methods are known to be efficient within OrdinaryDiffEq.jl for stiff ODEs and DAEs in mass matrix form. This is especially true if the dimension of the problem is not too high or the evaluation of the Jacobian matrix of the right-hand side of the differential equation system is not too expensive. There are implementations of many different Rosenbrock and Rosenbrock-W methods. In the talk we want to give an overview, present new methods and show some benchmarks and applications. juliacon2024-44352-rosenbrock-methods-within-ordinarydiffeq-jl Math(s) Gerd Steinebach en Currently, more than 30 Rosenbrock-type methods are implemented in the widely used Julia package OrdinaryDiffEq.jl. We discuss the differences and similarities of the various methods and explain why there is room for further improvements. In particular, this concerns the solution of time dependent algebraic equations and continuous output within the solution of DAE problems. We present new methods Rodas23W and Rodas3P that are equipped with an error control of the interpolation. We compare this approach with alternative concepts such as residual control or modification of the stiffly accurate embedded method of Rodas5P, we perform some benchmarks and present an application in the field of energy network simulation. false Talk https://pretalx.com/juliacon2024/talk/CGNHDG/ https://pretalx.com/juliacon2024/talk/CGNHDG/feedback/ If (1.1) Talk 2024-07-12T16:30:00+02:00 16:30 00:30 In this talk, we introduce a Julia package that transforms hybrid system models into a formal language for theorem proving, providing a new tool to analyze your model. We explore how, with the help of our package, you can automatically find proofs to verify system properties. By explaining key concepts such as quantifier elimination and loop invariants, we show the core principles of proof search. Finally, we compare our approach to other methods in the Julia ecosystem. juliacon2024-44425-automated-theorem-proving-with-dl-in-julia Math(s) Jonathan Hellwig en In the realm of software engineering, uncovering bugs lurking within code can prove to be a challenging task. However, theorem proving offers a formal and rigorous approach to verifying program correctness, providing a valuable tool for software verification. This is particularly important in hybrid systems like cars, robots or planes, where both continuous and discrete dynamics are present. As a system modeler, having theorem proving in your tool belt alongside other software verification techniques can be a useful addition to ensure the reliability and correctness of your code. In this talk, we introduce Elenchos, a Julia package aimed at simplifying the theorem proving process for hybrid system models. Elenchos introduces a Julia macro that makes it easier to translate a model from ModelingToolkit.jl into differential dynamic logic, a formal language for verification of hybrid systems. Additionally, the package provides macros to interface with the theorem prover KeYmaera X to automatically verify system properties. Throughout the talk, we explain the technologies behind proof automation by exploring fundamental theorem proving concepts such as loop invariants and quantifier elimination. Furthermore, we will compare the theorem proving approach with other existing methods like simulation, reachability analysis, or manual analysis to highlight its unique advantages. Join us as we explore the intricacies of theorem proving and its application in hybrid system verification. false Slides https://pretalx.com/juliacon2024/talk/QDMQQL/ https://pretalx.com/juliacon2024/talk/QDMQQL/feedback/ Else (1.3) Lightning talk 2024-07-12T10:10:00+02:00 10:10 00:10 With GNSSReceiver.jl you can process GNSS (Global Navigation Satellite System) signals in real time. It supports streaming from a SDR (Software Defined Radio) platform such that you can hook up an antenna to your Laptop and calculate your position and velocity. juliacon2024-44433-gnssreceiver-gnss-signal-processing-and-positioning-in-real-time General /media/juliacon2024/submissions/FCPJU9/Screenshot_20240131_193937_ui3IiZT.png Sören Schönbrod en Processing GNSS signals with a general purpose CPU is a challenging task. The signal has a high bandwidth (between 2 MHz and 25 MHz) which demands a high computational throughput. In addition, multiple satellite signals need to be decoded in order to estimate a reliable position. GNSSReceiver.jl achieves that in real time using Julia. Furthermore, it is capable to stream signals from multiple antennas coherently in order to enhance the Signal to Noise Ratio (SNR) with some sophisticated beamforming techniques. In its current implementation, it supports GPS and Galileo satellite signals, with more to follow. false Github https://pretalx.com/juliacon2024/talk/FCPJU9/ https://pretalx.com/juliacon2024/talk/FCPJU9/feedback/ Else (1.3) Lightning talk 2024-07-12T10:20:00+02:00 10:20 00:10 Powders are ubiquitous in industry, from pharmaceutical powders to food powders. Powders are often stored in silos, where the powder builds up stress under its own weight. The Janssen model describes this build up, but this model has unknown parameters that must be estimated from experimental data. This parameter estimation involves several challenges, such as unidentifiability and correlated measurements. To overcome these challenges, a Bayesian NLME model is implemented in Turing.jl. juliacon2024-44295-bayesian-non-linear-mixed-effects-model-for-safer-powder-storage General Arno Strouwen en Powders are ubiquitous in the chemical industry, from pharmaceutical powders for tablet production, to food powders like sugar. Powder flowability is a crucial aspect for smooth processing in all these applications. When powder is stored in silos, it builds up stress under its own weight. This stress can affect its flowability, leading to problems like arching or ratholing. Janssen’s approach is the most used stress model for silos [1]. This model contains unknown parameters that must be estimated from experimental data at lab scale. One of these parameters is the relation between horizontal and vertical stress in the system. This parameter enables the correct prediction of the stress propagation throughout the system. To estimate this parameter, measurements of both stresses need to be linked. However, no commercial set-ups are readily available to measure the relation between the horizontal and vertical stress directly. Data from a new experimental protocol was published in [2], extracting the stress relationship from wall friction measurements and an analytical set-up measuring the vertical stress propagation in a vertical pipe. This data will be used in the analyses in this presentation. In this presentation, we will perform a Bayesian non-linear mixed effects analysis on these data. The non-linear model is derived from a force balance. Random effects are introduced because high variability between repetitions of experiments under the same set of conditions is observed, compared to the measurement noise within a set of conditions. The choice for the Bayesian paradigm is twofold. First, because we have physical bounds available for most parameters of interest, which can serve as prior information in the Bayesian estimation. Second, because data from two different measurement setups must be combined to be able to identify all the parameters of interest. The joint likelihood over both measurement setups is readily calculated, as are posterior densities. In contrast, incorporating data from both setups would be less straightforward in the frequentist framework. The presence of prior information and an easily calculated likelihood thus makes the Bayesian framework a natural choice. The Bayesian inference is implemented in Turing.jl. The choice of Turing and the Julia programming language was motivated by the close resemblance of the code to the mathematical description of the Janssen equation. References [1] Schulze, Dietmar (2008). “Stresses in vertical channels (Janssen’s approach)”. In: Powders And Bulk Solids. Springer, pp. 259–262. [2] Coppens, Margot et al. (2023). “Combination and analysis of the lateral stress ratio and wall friction measurements”. In: Powder Technology 418, p. 118286. false Arno Strouwen JuliaCon 2024 https://pretalx.com/juliacon2024/talk/P7N7GB/ https://pretalx.com/juliacon2024/talk/P7N7GB/feedback/ Else (1.3) Talk 2024-07-12T10:30:00+02:00 10:30 00:30 The [Ray compute framework](https://ray.io) is widely used for distributed computing, supporting multiple compute environments and client languages. [Ray.jl](https://github.com/beacon-biosignals/Ray.jl) is a Julia client library and runtime for distributing Julia computation on Ray developed by Beacon Biosignals. Ray.jl can be used to scale distributed workloads from local machines to large cloud instances to Kubernetes clusters, without needing deep expertise in distributed computing. juliacon2024-43921-ray-jl-julia-runtime-and-client-for-the-ray-compute-framework Accelerated & large-scale computing Curtis VogtDave KleinschmidtGlenn Moynihan en The [Ray compute framework](https://ray.io) is a widely used framework for distributed computing supporting multiple compute environments. While Ray is focused on Python, it supports workflows authored in multiple client languages, including Python, Java, and C++. In this talk we'll describe [Ray.jl](https://github.com/beacon-biosignals/Ray.jl), a Julia-language client library and runtime for distributing Julia computation on Ray developed at Beacon Biosignals. Ray has a number of properties that make it a good fit for our Julia-based distributed computing needs at Beacon. 1. Ray has a simple "core" mental model (of Objects, Tasks, and Actors) that allows our developers to reason about distributed computing without requiring deep expertise. 2. Ray provides a set of back-end features that are battle-tested and used in production by other organizations of various scales. These features---including a distributed object store, scheduler, and worker orchestration---bridge the gap between "local dev" and "massively scalable Kubernetes cluster" environments and provide a landing zone for distributed workloads that frees our developers from worrying about provisioning compute resources. While many of these features are provided by existing solutions, no single solution provided all of them, and to fill in any of the gaps to the level of robustness we need would have been impractical with a small engineering team. 3. Because the Ray compute framework supports multiple client languages (Python, Java, and C++) each with their own runtime, the core C++ API has been pared down to something that is reasonably language-agnostic, and having multiple client language implementation to reference made it possible to implement our own client and runtime. In this talk we'll cover some of the challenges involved in building out a functional MVP of Ray.jl, including interfacing with a complex C++ API, building binary artifacts with a build toolchain not supported by BinaryBuilder.jl, serializing functions across Julia processes, and more. We'll also present case studies of how we've used Ray.jl to scale workloads at Beacon, demonstrate the basic functionality that Ray.jl provides, and discuss future features we plan to add to the package. false Ray.jl Talk Slides https://pretalx.com/juliacon2024/talk/M3QTGC/ https://pretalx.com/juliacon2024/talk/M3QTGC/feedback/ Else (1.3) Talk 2024-07-12T11:00:00+02:00 11:00 00:30 `Extrae` is a tracer and sampler profiler developed at the Barcelona Supercomputing Center (BSC). In this talk we will showcase its feature and demonstrate how to use it to optimise the performance of Julia applications, in particular in the high-performance computing domain. juliacon2024-43449-extrae-jl-advance-profiling-of-julia-code-in-hpc-clusters Accelerated & large-scale computing Mosè GiordanoSergio Sánchez RamírezArtur Garcia Saez en Julia has revolutionized the development of high-performance applications. Yet its native profiling capabilities limit to callstack sampling (i.e. periodic statistical sampling of the process callstack). Although useful for identifying bottlenecks, callstack sampling fails to explain the source of performance degradation. Without querying hardware counters, it is impossible to know if vector units are fully used or that memory access pattern is provoking many cache misses. In this work, we present the bindings to the `Extrae` tracer and sampler profiler developed at BSC. It lets you: - Annotate user regions - Sample hardware counters - Inspect the callstack inside C libraries - Mark inter-node, inter-process, inter-thread communication - Intercept MPI, CUDA and OpenMP calls - Emit custom user events We will showcase the performance evaluation of a some scientific apps written in Julia on x86_64 and AArch64 architectures. Some of these architectures features interesting capabilities such as scalable vector ISA (i.e. SVE) or unified memory between CPU and GPU (e.g. NVIDIA Grace Hopper). `Extrae` will show to be vital to understand its performance behaviour, and to later optimize it. false GitHub https://pretalx.com/juliacon2024/talk/DLC7TH/ https://pretalx.com/juliacon2024/talk/DLC7TH/feedback/ Else (1.3) Lightning talk 2024-07-12T11:40:00+02:00 11:40 00:10 We present the current state of PartitionedArrays.jl. This library is a parallel sparse linear algebra toolkit implemented in Julia, which was first introduced to the Julia community in JuliaCon 2022. This time, we discuss the new tools and enhancements introduced since then, including parallel algebraic multigrid (AMG) methods and other parallel linear solvers. With this work, we want to contribute towards a native Julia alternative to well known HPC packages such as PETSc. juliacon2024-43411-parallel-algebraic-multigrid-in-julia-with-partitionedarrays-jl Accelerated & large-scale computing Francesc Verdugo en Algebraic multigrid (AMG) methods [1] are among the most popular techniques to solve large systems of linear algebraic equations on supercomputers. They are widely used in the computational solid and fluid dynamics communities to solve problems with several millions of unknowns in parallel. Even though AMG schemes are key in many high-performance computing (HPC) applications, there are not many Julia alternatives available. AMG methods have been implemented in pure Julia in AlgebraicMultigrid.jl [2], which is a very valuable tool for the Julia community, but its implementation is sequential and thus not suitable for large-scale problems on supercomputers. Parallel AMG schemes remain available almost exclusively in packages with a long history such as PETSc [3] and Hypre [4], and implemented in traditional HPC languages like Fortran and C/C++. Even though these packages can be used from Julia via bindings (see e.g. HYPRE.jl [5]), a modern Julia implementation of parallel AMG methods is still missing. Without this implementation, the Julia package ecosystem misses a key feature in its otherwise rich scientific computing toolkit. In this talk, we present the latest additions to PartitionedArrays.jl [6]. The package was initially introduced in JuliaCon 2022, and we want to share the key updates introduced since then with our users and the broader Julia community. In particular, we will focus on the implementation and usage of parallel AMG methods and other large-scale linear solvers in Julia. The goal of this work is not to merely translate existing implementations of AMG into Julia, but to addresses some of their key limitations. Virtually all large-scale linear solvers are based on the Message Passing Interface (MPI) for parallelization. While MPI provides an efficient communication layer, it makes challenging the development cycle, specially in Julia. When debugging MPI code, a portion of the bugs can be tracked with conventional tools in a single MPI rank, but genuine parallel errors need to be debugged in parallel. Fixing an application that requires at least 100 ranks to crash can be very challenging, even with state-of-the-art (often proprietary) MPI debuggers. The situation is even worse in Julia. MPI codes are executed in batch mode with a fresh Julia session at each run. This makes difficult to reuse compiled code between runs, which is a major problem if your Julia code takes few minutes to compile from scratch. In addition, packages like Debugger are hard to use in combination with MPI on several processes. For this reason, PartitionedArrays.jl introduces an alternative parallel programming interface that aims at solving these problems. This interface exposes a set of communication directives, which are defined as simple operations on arrays (hence the name PartitionedArrays.jl). These operations are implemented both for standard (sequential) Julia arrays as well as for MPI-distributed arrays. One can rely on standard arrays (and thus standard Julia tools) in the development and debugging process, and then change to MPI-distributed arrays when deploying large production runs in HPC clusters. This interface has been proven successful to implement distributed linear algebra data structures (vectors and sparse matrices), and key computational kernels (distributed sparse matrix-vector product). In this talk, we will show how it can also be exploited to implement AMG schemes and other important functions such as distributed sparse matrix-matrix multiplication kernels. With this, we aim at simplifying the development process of such complex algorithms. References [1] https://doi.org/10.1016/S0377-0427(00)00516-1 [2] https://petsc.org/release/ [3] https://computing.llnl.gov/projects/hypre-scalable-linear-solvers-multigrid-methods [4] https://github.com/JuliaLinearAlgebra/AlgebraicMultigrid.jl [5] https://github.com/fredrikekre/HYPRE.jl [6] https://github.com/fverdugo/PartitionedArrays.jl false https://pretalx.com/juliacon2024/talk/DLJXNY/ https://pretalx.com/juliacon2024/talk/DLJXNY/feedback/ Else (1.3) Lightning talk 2024-07-12T11:50:00+02:00 11:50 00:10 [Taija](https://github.com/JuliaTrustworthyAI) is a growing ecosystem of packages geared towards *T*rustworthy *A*rtificial *I*ntelligence in *J*uli*a*. Various ongoing efforts towards trustworthy artificial intelligence have one thing in common: they increase the computational burden involved in training and using machine learning models. This talk will introduce [TaijaParallel.jl](https://github.com/JuliaTrustworthyAI/TaijaParallel.jl): Taija's recent venture into supercomputing. juliacon2024-42602-trustworthy-ai-in-julia-meets-supercomputing Accelerated & large-scale computing /media/juliacon2024/submissions/XLCNXN/wide_logo_SsN4tSe.png Patrick Altmeyer en In the wake of recent rapid advances in artificial intelligence (AI), it is more crucial than ever to ensure that the technologies we deploy are trustworthy. Efforts surrounding [Taija](https://github.com/JuliaTrustworthyAI) have so far centered around explainability and uncertainty quantification for supervised machine learning models. [CounterfactualExplanations.jl](https://github.com/JuliaTrustworthyAI/CounterfactualExplanations.jl), for example, is a comprehensive package for generating counterfactual explanations for models trained in [Flux.jl](https://fluxml.ai/Flux.jl/dev/), [MLJ.jl](https://alan-turing-institute.github.io/MLJ.jl/dev/) and more. ### 🌐 Why supercomputing? In practice, we are often required to generate many explanations for many individuals. A firm that is using a machine learning model to screen out job applicants, for example, might be required to explain to each unsuccessful applicant why they were not admitted to the interview stage. In a different context, researchers may need to generate many explanations for [evaluation](https://juliatrustworthyai.github.io/CounterfactualExplanations.jl/stable/tutorials/evaluation/) and [benchmarking](https://juliatrustworthyai.github.io/CounterfactualExplanations.jl/stable/tutorials/benchmarking/) purposes. In both cases, the involved computational tasks can be parallelized through multi-threading or distributed computing. ### 🤔 How supercomputing? For this purpose, we have recently released [TaijaParallel.jl](https://github.com/JuliaTrustworthyAI/TaijaParallel.jl): a lightweight package that adds custom support for [parallelization](https://juliatrustworthyai.github.io/CounterfactualExplanations.jl/stable/tutorials/parallelization/) to Taija packages. Our goal has been to minimize the burden on users by facilitating different forms of parallelization through a simple macro. To multi-process the evaluation of a large set of `counterfactuals` using the [MPI.jl](https://juliaparallel.org/MPI.jl/latest/) backend, for example, users can proceed as follows: firstly, load the backend and instantiate the `MPIParallelizer`, ```julia using CounterfactualExplanations, TaijaParallel import MPI MPI.Init() parallelizer = MPIParallelizer(MPI.COMM_WORLD) ``` and then just use the `@with_parallelizer` macro followed by the `parallelizer` object and the standard API call to evaluate counterfactuals: ```julia @with_parallelizer parallelizer evaluate(counterfactuals) ``` Under the hood, we use standard [MPI.jl](https://juliaparallel.org/MPI.jl/latest/) routines for distributed computing. To avoid depending on [MPI.jl](https://juliaparallel.org/MPI.jl/latest/) we use [package extensions](https://www.youtube.com/watch?v=TiIZlQhFzyk). Similarly, the `ThreadsParallelizer` can be used for multi-threading where we rely on `Base.Threads` routines. It is also possible to combine both forms of parallelization. ### 🏅 Benchmarking Counterfactuals (case study) This new functionality has already powered [research](https://arxiv.org/abs/2312.10648) that will be published at AAAI 2024. The project involved large benchmarks of counterfactual explanations that had to be run on a supercomputer. During the talk, we will use this as a case study to discuss the challenges we encountered along the way and the solutions we have come up with. ### 🎯 What is next? While we have so far focused on [CounterfactualExplanations.jl](), parallelization is also useful for other Taija packages. For example, some of the methods for predictive uncertainty quantification used by [ConformalPrediction.jl](https://github.com/JuliaTrustworthyAI/ConformalPrediction.jl) rely on repeated model training and prediction. This is currently done sequentially and represents an obvious opportunity for parallelization. ### 👥 Who is this talk for? This talk should be useful for anyone interested in either trustworthy AI or parallel computing or both. We are not experts in parallel computing, so the level of this talk should also be appropriate for beginners. false Github Link to slides (Revealjs) Link to slides (PDF) https://pretalx.com/juliacon2024/talk/XLCNXN/ https://pretalx.com/juliacon2024/talk/XLCNXN/feedback/ Else (1.3) Talk 2024-07-12T12:00:00+02:00 12:00 00:30 This talk will present the latest developments in Peridynamics.jl, a Julia package designed for dynamic fracture simulations. We rewrote the package from scratch to enhance multithreading and enable MPI support, redesigned the API to catch errors earlier, and implemented new material models to match the state-of-the-art peridynamics research. The talk will focus on how and why we changed the package and provide simple tutorials on the new API using fascinating examples of dynamic fracture. juliacon2024-44193-advancements-in-peridynamics-jl-for-dynamic-fracture-simulations General /media/juliacon2024/submissions/BDHASB/logo_zWncC0G.png Kai Partmann en Peridynamics is a nonlocal continuum formulation that uses an integro-differential equation to describe the relative displacement and forces between material points. This equation is also fulfilled for material discontinuities, allowing for modeling of crack propagation, fragmentation, and many other effects. Peridynamics has been shown to correctly map complex fracture problems with different materials, making it suitable for various engineering applications. Our ongoing development aims to address the package's critical limitations and needed functionality enhancements. The newest version of the package acknowledges these challenges, particularly the limited support for high-performance computing. To improve this, we have rewritten the package from scratch, incorporating a dual strategy: multithreading via Threads.jl for an interactive user experience and MPI.jl integration for scaling simulations on HPC clusters. This effort involved rethinking the underlying data structure and implementing a customized halo-exchange approach to communicate between threads and MPI ranks. Additionally, a new API focuses on early error detection, addressing past issues where wrong user input could only be caught at the start of a simulation. Inspired by user feedback, the new API offers a more streamlined experience for single and multi-body simulations. The bond-based model is the first peridynamics formulation with significant limitations and a high sensitivity to discretization errors. New material models that overcome these limitations exist. In the new version of the package, we introduce some of them, like the correspondence formulation, allowing for advanced simulations with higher accuracy and fewer discretization errors. The talk will feature simple tutorials on example simulations, highlighting the functionality of the new API and the expanded capabilities due to new material models and MPI integration. false Slides https://pretalx.com/juliacon2024/talk/BDHASB/ https://pretalx.com/juliacon2024/talk/BDHASB/feedback/ Else (1.3) Talk 2024-07-12T14:00:00+02:00 14:00 00:30 In this talk, we present a serializer-independent interface to a task-based workflow management system. This package aims at simplifying the process of writing a distributed application. Given a workflow pattern as a Petri net and the code for the workflow tasks, our package can be used on a cluster (e.g. with Slurm), to automate the application's parallel deployment. Hence, DistributedWorkflows.jl will be an invaluable addition to the growing high-performance computing packages in Julia. juliacon2024-43493-distributedworkflows-jl-a-task-based-workflow-system-interface Accelerated & large-scale computing Firoozeh Dastur en Over the last few years, Julia has gained rising amounts of attention in the High-performance computing community. Similarly, Julia developers have come up with packages making the use of HPC tools approachable for domain scientists. This is mainly due to Julia's design in performance and ease of use. ```Distributedworkflows.jl``` is an addition to this increasing collection of useful HPC packages in Julia. In this talk, we will showcase ```DistributedWorkflows.jl```, a Julia interface to a task-based workflow management system that enables users to build domain-specific workflows in the form of high-level Petri nets and rely on the runtime system for the workflow's task scheduling. The underlying ecosystem of the workflow manager "auto-manages" the application runs with dynamic scheduling, in-built distributed memory transfer and distributed task execution. An important feature of ```DistributedWorkflows.jl``` is that it is independent of serialization format which makes it flexible to use and compatible with all serializer formats that are supported by Julia. The main objective of this package is to simplify the process of writing a parallel distributed application and enable HPC experts as well as domain scientists to easily deploy their workflow code from within the Julia environment. The workflow is defined in the form of a high-level Petri net, which at the moment needs to be written in an xpnet file format following a certain XML schema. In the future, we will provide the generation of the Petri nets as a feature of this package for a better user experience. Using this interface, one can test the deployment of their parallel application locally before launching it on expensive cluster resources with ```Slurm``` or other cluster management tools. We will demonstrate this using various examples (locally), starting with a simple example and showing a more advanced example with a complex Petri net workflow design. In the future, this package could also pair up with Julia's ```Distributed``` package, from its standard library. The ```Distributed``` package could take care of the resource management while this package handles the workflow management. This makes our package even more attractive for users who rely on the ```Distributed``` package for their applications. In the end, we will show a list of features and upgrades to look forward to with regards to distributed computing and expand this package with user feedback. We provide an easy installation process and tutorials on the GitHub repository, ```https://github.com/FiroozehDastur/DistributedWorkflows.jl```, for anyone interested. This approach guarantees that everyone has the opportunity to benefit from the automated deployment of their distributed application, which will create the possibility to compute large examples that would have previously been considered infeasible to compute in their respective domains. false GitHub https://pretalx.com/juliacon2024/talk/MXUGRG/ https://pretalx.com/juliacon2024/talk/MXUGRG/feedback/ Else (1.3) Talk 2024-07-12T14:30:00+02:00 14:30 00:30 The talk will be about Rembus: a new package for implementing distributed applications using a pub/sub communication style and/or a RPC communication style. Rembus integrates into a single middleware the Publish/Subscribe and the Remote Procedure Call pattern: this is a unique feature amongst similar existing solutions (for example kafka, MQTT, grpc). juliacon2024-42915-rembus-jl-a-pub-sub-and-remote-procedure-call-middleware Julia Internals and Tooling Attilio Donà en Rembus targets microservices oriented enterprise systems. Main goals are: - Make it easy implementing distributed applications avoiding the boilerplate of connections management. - Overall performance. - Broker and broker-less architecture. - Exchange primitive types but also binary data and Dataframes objects between components. Rembus leverages Julia's metaprogramming capabilities to propose a novel API approach for transforming a function into a "distributed" function, for example: #### Pub/Sub: 1 publisher and N subscribers The application "publisher" produces a message: ```julia @component "publisher" @publish mytopic(arg1, arg2, arg3) ``` > **NOTE:** arguments `arg1, arg3, arg3` are encoded as the data content of the published message with topic `mytopic`. The application "consumer1" subscribes to the topic `mytopic`: ```julia @component "consumer1" # invoked for each received message on topic mytopic function mytopic(arg1, arg2, arg3) # body end @subscribe mytopic # declare interest to topic mytopic ``` The same hold true for "consumer2" .. "consumerN" applications each of them with specific body implementation of `mytopic` method. #### Talk outline The talk session will be organized as follows: - Introduction: motivations and Rembus main features. - Fault-tolerance features: brief explanation of a non trivial use of [Visor.jl](https://github.com/cardo-org/Visor.jl) - How to implements pub-sub and RPC systems with Rembus: code examples. - Demo: exchanging dataframes between Julia, Python and Rust. - Q&A false Rembus slides https://pretalx.com/juliacon2024/talk/SLLVYC/ https://pretalx.com/juliacon2024/talk/SLLVYC/feedback/ Else (1.3) Talk 2024-07-12T15:00:00+02:00 15:00 00:30 _Are you sick of practicing arpeggios? Is the metronome your natural enemy? Are you suffering from Julia withdrawal symptoms when you play music?_ _No worries, Julia can help._ Simply learn live coding, the art of changing a program that generates music _while it generates music!_ Generative music and improvisation combined. This presentation is a short music performance with Julia followed by a breakdown and tutorial into live coding with Julia. juliacon2024-44148-a-live-coding-music-performance-with-julia General Steffen Plunder en _The core of this presentation is a live coding music performance using hot code reloading and [PortMidi.jl](https://github.com/JuliaMusic/PortMidi.jl)._ Live coding essentially combines musical improvisation with generative music. Expanding on the idea of the REPL (read-evaluate-print-loop), one can consider live coding as a performance during which 'the human' changes 'the program' that generates the music; all done in a way that does not interrupt the musical flow. This allows interactive exploration of musical ideas, and live coding is a very cool subgenre of electronic music. There exist many domain-specific languages for this task: Extempore, Impromptu, Max, Pure Data, TidalCycles, and SuperCollider. The common challenge is to combine _hot code reloading_ during execution without introducing timing issues. These are all features Julia already has, making it a fun environment for live coding. To implement hot code reloading, we rely on _temporal recursion_. Imagine a function that calls itself after a given delay using `Base.invokelatest`. If we redefine the function during this sleeping time, we can change it without interrupting the "read-evaluate-play music-recursion". Together with a bit of asynchronous programming, plain Julia is basically all you need for live coding. Now, the cool part is that Julia's ecosystem is much larger than most other live coding environments. For example, what about using [DifferentialEquations.jl](https://docs.sciml.ai/DiffEqDocs/stable/) to generate the notes? Or using [Makie](https://docs.makie.org/stable/)'s reactive programming for visuals! And, of course, how about using the packages from [JuliaMusic](https://github.com/JuliaMusic) for the theory? Unlimited options to make the next hit (or extremely crappy tunes). false GitHub https://pretalx.com/juliacon2024/talk/ARKMTV/ https://pretalx.com/juliacon2024/talk/ARKMTV/feedback/ Else (1.3) Lightning talk 2024-07-12T15:40:00+02:00 15:40 00:10 Implicit diagonal estimation is a long-standing problem that is concerned with approximating the diagonal of a matrix (function) that can only be accessed through matrix-vector products. We present RandomizedDiagonalEstimation.jl, which implements existing and novel randomized methods for accomplishing this task in a scalable way. The practical applications of the provided algorithms extend across diverse domains such as network science, material science, optimization and machine learning. juliacon2024-43099-randomized-diagonal-estimation-in-julia General /media/juliacon2024/submissions/3M8WUH/RandDiag_logo_32a20Qz.svg Niclas Popp en RandomizedDiagonalEstimation.jl provides the first comprehensive toolkit of methods for implicit diagonal estimation. It features established algorithms for approximating the diagonal of large matrices when one has only access to matrix-vector products. This problem is of interest in various fields of application, examples include the estimation of subgraph centralities in network science, the approximation of charge densities in material science or efficient second-order optimization methods in machine learning. The package includes the Girard-Hutchinson estimator and Diag++, recently proposed by Baston and Nakatsukasa. In addition, we propose and implement novel extensions tailored at the diagonal of matrix functions, such as the exponential and the inverse of a matrix, using polynomial interpolation and Krylov methods. The package integrates well within the Julia ecosystem and provides the possibility to easily add additional algorithms in the future. false Slides RandomizedDiagonalEstimation.jl https://pretalx.com/juliacon2024/talk/3M8WUH/ https://pretalx.com/juliacon2024/talk/3M8WUH/feedback/ Else (1.3) Lightning talk 2024-07-12T15:50:00+02:00 15:50 00:10 We present a successful approach for a sustainable development of stencil-based HPC applications in Julia. The approach includes automatic performance optimization for hardware-agnostic high-level kernels, data layout abstractions enabling memory layouts optimized per backend, and GPU-aware inter-process communication that is automatically hideable behind computation. We demonstrate on multiple examples near optimal performance and scaling on thousands of GPUs. juliacon2024-44435-sustainable-development-of-stencil-based-hpc-applications Accelerated & large-scale computing /media/juliacon2024/submissions/QLVPSN/logo_ParallelStencil_8sfZXE3.png Ludovic RässSamuel OmlinIvan Utkin en In the context of the rapid evolution of hardware over the last decades and the fastly growing hardware diversity, the High Performance Computing (HPC) community has identified the three "P"s, (scalable) Performance, (performance) Portability, Productivity, as key goals for sustainable HPC developments. In order to bring these orthogonal goals under one hood, the challenge needs to be split up into manageable tasks, where the demanding computer science tasks are largely solved in what we call "HPC building blocks". We present here a successful approach for sustainable development of stencil-based HPC applications, where the HPC building blocks are implemented in the three Julia packages ParallelStencil.jl, ImplicitGlobalGrid.jl and CellArrays.jl. In our approach, numerical algorithms are formulated with architecture-agnostic math-close code, which hides computer science aspects as, e.g., parallelization and optimization as much as possible or sensible. Writing such code leads to a productivity like in a classical prototyping environment. The HPC building blocks turn then these codes into massively scalable high performance multi-GPU/CPU applications or frameworks. More concretely, the HPC building blocks 1) perform automatic performance optimization and parallelization for hardware-agnostic kernels written explicitly or in math-close notation (ParallelStencil.jl), 2) contain data layout abstractions enabling memory layouts optimized per backend (CellArrays.jl), and 3) enable GPU-aware distributed parallelization that is automatically hideable behind computation (ImplicitGlobalGrid.jl). Other important aspects of our approach are 1) extensibility of the math-close notation for writing computation kernels, 2) integration into the ecosystem enabling, e.g., Enzyme-powered automatic differentiation using high level syntax, and 3) compatibility of our architecture-specific code generation with Julia's extension feature. We discuss these points briefly. We report performance and scaling of benchmarks and real-world applications on the EuroHPC flagship AMD GPU supercomputer, LUMI, and on the Nvidia GPU supercomputer Piz Daint at the Swiss National Supercomputing Centre. We show that near optimal performance and scaling on thousands of GPUs on the world's fastest supercomputers is possible. false https://pretalx.com/juliacon2024/talk/QLVPSN/ https://pretalx.com/juliacon2024/talk/QLVPSN/feedback/ Else (1.3) Talk 2024-07-12T16:00:00+02:00 16:00 00:30 Industrial systems often rely on modeling and simulation from design to operation and require robust, performant and scalable computational approaches. In this talk we will focus on techniques used to build robust calibration methods for HVAC and Battery systems in JuliaSimModelOptimizer, part of JuliaSim, a commercial product from JuliaHub. juliacon2024-44251-robust-calibration-of-industrial-hvac-and-battery-systems General Sathvik BhagavanSebastian Micluța-Câmpeanu en ModelingToolkit.jl provides a scalable and performant way of building large scale models for industrial systems due to its advanced symbolic manipulation techniques and its acasual nature. Once these models are constructed, fine-tuning becomes essential to align their behavior with real-world industrial systems. This calibration process entails incorporating design constraints and integrating experimentally measured real-world data into the models. Calibrating models to data can be difficult due to the behavioral complexity of the models and the challenges that are brought in by the data, such as noise, partial observability or sparsity of the measurements. The JuliaSim Model Library includes high performance, composable, domain specific tools for industrial systems. JuliaSim-HVAC is one such component, which can be used to describe refrigeration, air conditioning systems etc. Additionally, JuliaSim-Batteries can be used to design and simulate electrochemical models of large battery packs. In this talk we will explore techniques such as Single Shooting, Multiple Shooting, Collocation and Prediction Error Method exemplified on HVAC and Battery systems and show how they can help avoid local minima during calibration procedures. In order to demonstrate the robustness of our results, we will compare our predictions against validation data sets. Moreover we can investigate the effects of unidentifiability of parameters using Bayesian priors on the parameters. false https://pretalx.com/juliacon2024/talk/XQFTZB/ https://pretalx.com/juliacon2024/talk/XQFTZB/feedback/ Else (1.3) Talk 2024-07-12T16:30:00+02:00 16:30 00:30 Quantized State System (QSS) solver is an alternative method to classic numerical integration methods in solving sparse systems of Ordinary Differential Equations (ODE), which exhibits stiffness and discontinuities. I will explain the internals of a package that implements these methods, and I will provide its results in the simulation of some well-known systems in comparison to the DifferentialEquations.jl package. juliacon2024-40009-qss-a-solver-for-a-large-sparse-stiff-discontinuous-system Math(s) /media/juliacon2024/submissions/VGEXHQ/Elmongi_elbellili_poster_C9tw1JO.png elmongi elbellili en In classic methods, the difference between tk (the current time) and tk+1 (the next time) is called the step size. In QSS, the difference between xk (the current value of one variable) and xk+1 (the next value) is called the quantum ∆. The step size is determined by the smallest time that is needed for a variable to exceed the threshold ∆. Since in QSS algorithms, variables of the system do not necessarily get updated at the same time, they can outperform classic solvers in large sparse stiff discontinuous systems such as switched power converter circuits. I built a family of explicit and implicit QSS algorithms of orders 1,2, and 3 in Julia. The package is in the testing phase, and many systems of ODEs are successfully tested as well as well-known problems such as the Tyson model and the Advection Diffusion Reaction problem. While the package is optimized to be fast, extensibility is not compromised. It is divided into 3 modules that can be extended separately: Problem, Algorithm, and Solution. The package uses other packages such as MacroTools.jl for user-code parsing, SymEngine.jl for Jacobian computation, and a modified TaylorSeries.jl that uses caching to obtain free Taylor variables. The approximation through Taylor variables transforms any complicated equations to polynomials, which makes root finding cheaper. The general form of the QSS algorithm is as follows: - Find the variable ‘i’ with the fastest dynamics and compute the elapsed time ‘e’ since the last update. - update its value using a Taylor expansion and compute the time of next change. - update any variable ‘j’ that depends on ‘i’ and compute its next time of change. - update any zero-crossing function that depends on ‘i’. Even though, the QSS algorithms are significantly different from conventional methods implemented in the DifferentialEquations.jl, they can be incorporated in this ecosystem. Repository: https://github.com/mongibellili/QuantizedSystemSolver.jl issue in DifferentialEquation.jl where QSS was tested: https://github.com/SciML/DifferentialEquations.jl/issues/998 false Github ppt https://pretalx.com/juliacon2024/talk/VGEXHQ/ https://pretalx.com/juliacon2024/talk/VGEXHQ/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-12T10:30:00+02:00 10:30 01:00 A get together of all the people interested in the current state and the future of Plots.jl juliacon2024-39664-plots-jl-quo-vadis Notebooks & Graphics /media/juliacon2024/submissions/AZZLTN/Plots_Ox1YL9f.png Simon Christ en This BoF-meeting is aimed to gather people that are curious about shaping the future of Plots.jl. There will be a short overview of the current state and outstanding issues. This will be followed up by an open discussion about onboarding new contributors and how to sustain maintenance. false https://pretalx.com/juliacon2024/talk/AZZLTN/ https://pretalx.com/juliacon2024/talk/AZZLTN/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-12T11:30:00+02:00 11:30 01:00 The Julia HPC community has been growing over the last years with monthly meetings to coordinate development and to solve problems arising in the use of Julia for high-performance computing. The Julia in HPC Birds of a Feather is an ideal opportunity to join the community and to discuss your experiences with using Julia in an HPC context. juliacon2024-44431-julia-in-hpc Accelerated & large-scale computing Valentin ChuravyMosè Giordano en The JuliaHPC working group meets monthly to discuss challenges and issues of using Julia in HPC. Building on the success of this format at JuliaCon'23 and the well-received Julia BoF at SuperComputing23, we are looking forward to invite the wider Julia community again, and discuss Julia for high performance computing in person! false https://pretalx.com/juliacon2024/talk/F7BHGS/ https://pretalx.com/juliacon2024/talk/F7BHGS/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-12T14:00:00+02:00 14:00 01:00 The Scientific Machine Learning (SciML) ecosystem is rapidly gaining momentum within the field of systems biology. Following up on last year, with this birds of feather discussion we want to bring the international community of systems biology tool developers and users at one table to (a) brainstorm promising routes for future developments, and (b) facilitate collaborative projects. juliacon2024-42755-systems-biology-community-needs-plans-and-visions Biology & Life Sciences Paul LangSebastian Persson en **Purpose**: The Scientific Machine Learning (SciML) ecosystem in Julia holds great potential for applications in the field of systems biology. Much of this can be attributed to state-of-the-art ODE solvers and parameter estimation packages, and convenient interface with automatic differentiation packages, neural differential equations and systems biology standards/formats. While an increasing number of systems biology groups are starting to use Julia to address biological questions, many existing systems biology tools are not yet available in an easy-to-use manner in Julia. In this Birds of Feather discussion we want to address the following questions: 1. What are the community needs, plans and visions? 2. Which existing systems biology tools hold great potential for faster implementations if ported to Julia? 3. Which new tools are enabled by the features of the SciML ecosystem? 4. Where can we find synergies and common interests for joining efforts on systems biology tool development? 5. (How) can we improve on the existing communication channels to facilitate coordinated and collaborative tool development? **Significance**: Bringing researchers in the field of open-source systems biology tool development at one table to discuss the above questions will facilitate a flourishing ecosystem of systems biology tools and pipelines in Julia, and increase the uptake of the language by the community as a consequence. **Agenda**: the following points will be on the agenda. - ~5 min: Introduction by Paul Lang or Sebastian Persson - ~10 min: Participants briefly addresses question (1) from above from their perspective - ~30 min: Participants are split up into 2-5 groups to discuss questions (2)-(5) from above. - ~10 min: One member of each group summarizes the main points from the group discussion for the other groups. - ~5 min: Closing remarks by Paul Lang and Sebastian Persson - (Optional if time is left: Talking to people from other discussion groups and unguided networking.) false https://pretalx.com/juliacon2024/talk/QLHUJ9/ https://pretalx.com/juliacon2024/talk/QLHUJ9/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-12T15:00:00+02:00 15:00 01:00 In the proposed panel for the Julia Conference, titled "Empowering Life Sciences with Julia," we aim to highlight the significant impact of the Julia programming language in advancing life sciences, encompassing fields like chemistry, physics, and biology. The panel will explore Julia's capabilities in handling complex computations, facilitating interdisciplinary research, and its application in data analysis, visualization, machine learning, and AI. juliacon2024-44361-julia-for-fundamental-scientific-questions-in-life-sciences Biology & Life Sciences Paul LangLetícia MadureiraMax de Rooij en In this proposed panel for the Julia Conference, we delve into the transformative role of Julia in the life sciences - chemistry, physics, and biology. Renowned for its high performance and user-friendly syntax, Julia stands at the forefront of computational advances addressing fundamental questions in these fields. The panel aims to illuminate how Julia’s integration into research and education can catalyze breakthroughs in data analysis, visualization, and simulation, thus accelerating scientific discoveries and fostering interdisciplinary work. Key discussion points include: 1. Julia’s Impact on Performance and Efficiency: Focusing on Julia’s adeptness in handling complex computations and large datasets, a critical requirement for life sciences research. 2. Interdisciplinary Research and Collaboration: Demonstrating Julia’s role in bridging chemistry, physics, and biology through its versatile nature and compatibility with other languages. 3. Innovations in Data Analysis and Visualization: Showcasing how Julia’s potent data processing capabilities can unlock new insights, particularly in managing large-scale biological data. 4. Machine Learning and AI in Life Sciences: Discussing the expanding role of Julia in applying AI and machine learning for predicting and modeling in biological and chemical domains. 5. Modeling and Simulation Strengths: Highlighting Julia’s capabilities in precise modeling and simulations, integral to life sciences. 6. Championing Reproducibility and Open Science: Promoting Julia’s open-source ethos to foster collaborative, transparent, and reproducible scientific research. 7. Development of Specialized Tools for Life Sciences: Exploring the potential of creating novel, Julia-based tools tailored for life science research. 8. Educational Outreach and Accessibility: Strategizing the integration of Julia into life sciences curricula to broaden access for diverse student and researcher groups. A prime example of these efforts is the “Introduction.jl” package, developed specifically to disseminate Julia among chemists in the LatinX community. This package, created by the panelist, encompasses modules on reaction mechanisms, chemiometry, and quantum chemistry, demonstrating Julia’s practical applications in chemistry. It exemplifies how Julia can be tailored to address specific educational needs and research interests within the life sciences. This panel seeks to unite experts and enthusiasts from various scientific areas to discuss Julia’s integration in life sciences. It will feature presentations, interactive discussions, and Q&A sessions, aiming to inspire, inform, and engage both the Julia community and life sciences professionals and students. false https://pretalx.com/juliacon2024/talk/PSFVVT/ https://pretalx.com/juliacon2024/talk/PSFVVT/feedback/ Struct (1.4) Birds of Feather (BoF) 2024-07-12T16:00:00+02:00 16:00 01:00 JuliaCon is growing and changing as we attract a larger and more diverse audience across academia, research organizations, and businesses. How do we currently organize JuliaCon and how can we grow to address all our attendees and our online community members? What do you want to see at future JuliaCons, and in Julia's general online presence. How do you volunteer or help out in those efforts? All that and more at the JuliaCon Organizers BoF juliacon2024-46480-one-does-not-simply-juliacon Community Raye Kimmerer en JuliaCon has taken many different forms over the years, from a small event with < 20 talks in 2014, to online events viewed by thousands, and finally the last two years of in-person conferences with well over 300 speakers / talks. The audience has also shifted over that time period, we see more and more attendees from businesses small and large, in addition to the often academic / research driven audience of traditionally associated with the conference. The first third of this BoF will be a peek behind the curtain of JuliaCon, the funding and committee structures, volunteering, etc. The rest of the BoF will be an open session about the future of JuliaCon as the conference grows to handle a larger and more diverse audience. The organizing committee is also responsible for much of the official online content on Julia Language channels, so we'll discuss the future of those channels, and how to use them to grow the reach of the language. Finally, time permitting, we'll discuss how to foster local groups which can eventually play host to a JuliaCon or JuliaCon Local. false https://pretalx.com/juliacon2024/talk/QNJSCV/ https://pretalx.com/juliacon2024/talk/QNJSCV/feedback/ Method (1.5) Lightning talk 2024-07-12T10:10:00+02:00 10:10 00:10 The Julia extension for VS Code provides features that help with developing Julia packages and ease interactive coding. It is widely used in the Julia community and sees continuous development. This talk will go over features and enhancements introduced since last JuliaCon as well as ongoing and future developments. juliacon2024-53139-what-s-new-in-the-julia-extension-for-vs-code Sebastian Pfitzner en The Julia extension for VS Code provides features that help with developing Julia packages and ease interactive coding. It is widely used in the Julia community and sees continuous development. This talk will go over features and enhancements introduced since last JuliaCon as well as ongoing and future developments. false https://pretalx.com/juliacon2024/talk/HCJ3SH/ https://pretalx.com/juliacon2024/talk/HCJ3SH/feedback/ Method (1.5) Lightning talk 2024-07-12T10:20:00+02:00 10:20 00:10 The global electricity system is significantly transforming due to national and international efforts to reduce carbon emissions. To support the decision-making process in this changing electricity landscape, we have developed GenX, an open-source, highly configurable electricity resource capacity expansion model written in Julia and JuMP. The software allows the creation of different scenarios and optimization based on physical, operational, and policy constraints. juliacon2024-44514-genx-a-high-performance-tool-for-electricity-system-planning General Luca Bonaldo en The global electricity system is undergoing a significant transformation driven by both national and international initiatives focused on de-carbonizing electricity generation to combat climate change. This shift is further fueled by the increased adoption of distributed energy resources, the decentralization of electricity service provision, the digitization of power systems, and the broader electrification of transportation, heating, and industrial energy demand. Additionally, the growth of variable renewable energy sources like wind and solar energy contributes to the evolving landscape. In this dynamic electricity environment, decision support tools play a pivotal role by aiding in the simulation of diverse scenarios, assessing the impact of new technologies, and exploring the consequences of emerging policies and incentives. An example of these tools is GenX, an open-source and highly modular capacity expansion model written in Julia. GenX abstracts power system operational details, offering decision-making support during the ongoing transformation of the power sector. GenX utilizes linear programming and mixed integer linear programming, implemented in Julia and JuMP, to model various technologies, grid interconnections, and physical and policy constraints. The complexity of the problem, characterized by a substantial number of variables and constraints, poses significant computational challenges. Therefore, leveraging high-performance computing techniques and infrastructures becomes essential for effectively addressing these types of calculations. Adopting a centralized planner's perspective, GenX aims to determine the cost-optimal generation portfolio, storage, and transmission investments needed to meet a user-defined system demand. false Lightning talk slides https://pretalx.com/juliacon2024/talk/YM8TJT/ https://pretalx.com/juliacon2024/talk/YM8TJT/feedback/ Method (1.5) Talk 2024-07-12T10:30:00+02:00 10:30 00:30 Mathematics is a science and one of the most important discoveries of the human race on earth. In our daily life, we use mathematics knowingly and unknowingly. Many of us are unaware that forensic experts use mathematics to solve crime mysteries. In this talk, we will explore how Mathematics and Julia programming language is used to solve crime mysteries. juliacon2024-44488-investigating-crimes-using-julia General Gajendra Deshpande en Julia is a Scientific Computing language and solving crime mysteries especially forensics is a scientific process. The investigation officers use the concepts of mathematics, science, geography, and technology to solve crime cases. The workshop begins with an introduction to forensic science and mathematics and covers basic principles thereby setting the stage. Then, we will solve simple crime puzzles using science and mathematics and simple Julia programs. Finally, we will solve a few complex hypothetical crime mysteries using advanced advanced concepts. The participants will learn how to use the concepts of science and mathematics such as chemistry, physics, biology, statistics, probability, trigonometry, and graph theory, and Julia and its packages such as Measurements.jl, Plots.jl, Graphs.jl, DataFrames.jl, RecursiveArrayTools.jl, and MatrixNetworks.jl to solve the crime puzzles. false https://pretalx.com/juliacon2024/talk/GFAW3F/ https://pretalx.com/juliacon2024/talk/GFAW3F/feedback/ Method (1.5) Lightning talk 2024-07-12T11:00:00+02:00 11:00 00:10 We present TSearch, an experimental software system which attempts to unify the disparate, heterogeneous information sources across the Julia community into a coherent, searchable structure. juliacon2024-44432-tsearch-an-experimental-search-system-for-the-julia-community Community Caleb Allen en Online communities preserve their written knowledge across a diverse set of digital repositories. The Julia community, for instance, organizes Julia’s source code on GitHub; it conducts conversation on the Julia discourse; and it hold realtime conversations on Slack, and so on. Despite the highly heterogeneous formats of these community repositories, they each encompass a unique mechanism of Julia related communication, with varying degrees of formality and structure. In the aggregate, these platforms reflect a web of people and their multitudinous ways of communicating. Since the growth of the World Wide Web, search engines have primarily derived their ranking systems using a variety of techniques built from the graph structure provided by hypertext. The supremely successful PageRank algorithm powered the explosive growth of Google by deriving rankings largely with hypertext signals. We discuss the limitations that hypertext presents in any endeavor to derive complex structure, especially in the information ecosystems generated by a coherent network of people like the Julia community. We present TSearch, an experimental attempt to unify these disparate, heterogeneous sources into a coherent, searchable structure. As our motivating application we use the Julia programming language, its extensive library ecosystem, and its diverse communication platforms. false Presentation Slides tsearch.org https://pretalx.com/juliacon2024/talk/QRXPDB/ https://pretalx.com/juliacon2024/talk/QRXPDB/feedback/ Method (1.5) Lightning talk 2024-07-12T11:10:00+02:00 11:10 00:10 [InferOpt.jl](https://github.com/axelparmentier/InferOpt.jl) is a Julia package for using combinatorial optimization algorithms in machine learning pipelines. It enables more expressive machine learning pipelines, and unlocks new applications in both machine learning and combinatorial optimization fields. The goal of this talk is to showcase InferOpt's features and capabilities through some application examples. juliacon2024-44264-inferopt-jl-combinatorial-optimization-and-machine-learning Optimization Léo Baty en Combinatorial optimization algorithms and many discrete functions in general are piecewise constant in their input, which means zero derivatives almost everywhere. Using these as layers in machine learning pipelines is difficult because of this lack of meaningful gradients. InferOpt.jl is a toolbox containing many state-of-the art layers and loss functions that can be used learn such hybrid pipelines. Each method is implemented as a generic wrapper for the combinatorial function you want to differentiate through, fully compatible with ChainRules.jl automatic differentiation ecosystem, and machine learning packages such as Flux.jl. Slides: https://batyleo.github.io/JuliaCon2024-InferOpt/ false https://pretalx.com/juliacon2024/talk/FRSW3J/ https://pretalx.com/juliacon2024/talk/FRSW3J/feedback/ Method (1.5) Lightning talk 2024-07-12T11:20:00+02:00 11:20 00:10 Two years ago, back in 2022, our Optimization.jl package took off. It's not just about the 600+ stars it's earned – it's how it's become a go-to tool for many users. What makes it stand out? It's the mix of solver options and automatic differentiation it offers, makes it a breeze to experiment with, more so than any other Julia package or those in other languages. Plus, we've been busy improving the interface, adding cool new features that make using it an even better experience. juliacon2024-42643-all-that-s-new-and-improved-in-optimization-jl Optimization Vaibhav Dixit en Though there have been a multitude of exciting developments in the package, in the talk I will highlight some that are unique and extremely useful. The EnsembleProblem interface of SciML for optimization problems allows any algorithm to be used with a multistart strategy. The intermediate optimization state and the final solver statistics are now uniform across the solver wrappers. The state is passed to the callback so users can create complex callbacks for logging, plotting or termination conditions. Advanced symbolic capabilities allow for features like automatic solver selection based on problem structure, alias elimination in problems with equality constraints and more. false https://pretalx.com/juliacon2024/talk/KHPCUJ/ https://pretalx.com/juliacon2024/talk/KHPCUJ/feedback/ Method (1.5) Lightning talk 2024-07-12T11:40:00+02:00 11:40 00:10 The equal-tempered 12-tone scale is ubiquitous in modern western music. It is characterized by successive semi-tones having a constant frequency ratio of 2^(1/12) ≈ 1.06. But there are many other ways to define tunings of musical instruments, and Julia is a great tool for exploring these tuning systems. The talk will demonstrate how I have used Julia to generate tones and explore tuning systems visually and auditory. juliacon2024-43527-exploring-musical-tunings-with-julia General Thomas A. Poulsen en Julia has a number of well designed packages for representation of musical notes and generation of sounds. I've used these packages to explore tuning systems based on a series of blog posts by John Baez. I'll share my experiences and make some noise for Julia as a musical synthesizer. false GitHub Recording TuningSystems-Slides https://pretalx.com/juliacon2024/talk/3W8DDA/ https://pretalx.com/juliacon2024/talk/3W8DDA/feedback/ Method (1.5) Lightning talk 2024-07-12T11:50:00+02:00 11:50 00:10 What do financial markets look like up close? TotalView-ITCH is a unique data source that allows researchers to explore limit order activity on the Nasdaq exchange down to nanosecond precision. Working with this data, however, poses a challenge to researchers due to its volume (over 100 million messages per day) and its distinct binary format. This lightning talk describes a new package built to parse and process this deluge of data in Julia. juliacon2024-44511-totalviewitch-jl-parse-the-messages-in-julia Economics Colin Swaney en Nasdaq TotalView-ITCH (“TotalView”) is a data feed used by professional traders to maintain a real-time view of market conditions. TotalView disseminates all quote and order activity for securities traded on the Nasdaq exchange—over 100 million message per day—allowing users to reconstruct the limit order book for any security up to arbitrary depth with nanosecond precision. It is a unique data source for financial economists and engineers examining topics such as information flows through lit exchanges, optimal trading strategies, and the development of macro-level indicators from micro-level signals (e.g., a market turbulence warning). While TotalView data is provided at no charge to academic researchers via the Historical TotalView-ITCH offering, the historical data offering uses a binary file specification that poses challenges for researchers. TotalViewITCH.jl is a pure Julia package developed to efficiently process historical data files for academic research purposes. The package consists of: (1) a core module to parse Historical TotalView binary file format messages (i.e., deserialization), (2) a module to reconstruct limit order books from parsed messages, and (3) a module to store processed data into a research-friendly format. false Slides https://pretalx.com/juliacon2024/talk/YLXKQW/ https://pretalx.com/juliacon2024/talk/YLXKQW/feedback/ Method (1.5) Talk 2024-07-12T12:00:00+02:00 12:00 00:30 JSOSuite.jl is a one-stop solution for optimization in Julia. Built on top of the Julia Smooth Optimizers (JSO) packages, this package provides a user-friendly interface for users who want a quick solution to their linear or nonlinear optimization problems. In the background, JSO provides research-level optimization and linear algebra modules, which JSOSuite.jl packages conveniently. juliacon2024-44270-jsosuite-jl-one-stop-solution-for-optimization Optimization /media/juliacon2024/submissions/RU73SS/jso-square_sH5t5Az.png Abel Soares Siqueira en We bring JSOSuite.jl into the spotlight: a one-stop solution for optimization. This package provides an interface for users to quickly supply their optimization problem to one of our solvers. The solver is selected automatically, or selected by the user. This allows users to have access to research-level optimization solvers, most of which are written in pure Julia. This means that you can find solvers that handle multiple precision and custom types. JSOSuite is powered by the Julia Smooth Optimizers ecosystem (https://jso.dev). This includes many optimization and linear algebra solvers, such as Percival.jl and Krylov.jl, as well as modeling interfaces---most notably, ADNLPModels.jl. With our modeling interfaces, you can supply the minimum information and use automatic differentiation, be explicit with all derivatives, or a mix of both. You can exploit the structure of the problems, for instance for Nonlinear Least Squares problems, or PDE-constrained optimization. Finally, you can integrate with JuMP and AMPL to keep using what you're familiar with. The Julia Smooth Optimizers organization has been around since 2015. We have over 50 registered packages dealing with a variety of linear/nonlinear optimization and linear algebra topics. Many of our packages are in use in other ecosystems. false GitHub Slides https://pretalx.com/juliacon2024/talk/RU73SS/ https://pretalx.com/juliacon2024/talk/RU73SS/feedback/ Method (1.5) Talk 2024-07-12T14:00:00+02:00 14:00 00:30 The Earth’s crustal magnetic field is a powerful tool for navigation as an alternative to GPS. MagNav.jl is an open-source Julia software package that contains a full suite of tools for aeromagnetic compensation and airborne magnetic anomaly navigation. Alongside baseline algorithms, such as Tolles-Lawson and an extended Kalman filter, this package enables multiple approaches for real-time compensation and navigation. This talk will cover these techniques and advanced use cases for MagNav.jl. juliacon2024-44399-real-time-airborne-magnetic-navigation-with-magnav-jl General Jonathan TaylorAlbert R. Gnadt en The final talk of the MagNav.jl JuliaCon series will discuss the development and options for real-time compensation and navigation, which is important for real-world implementation. At a high level, MagNav.jl provides tooling to compensate for an aircraft’s magnetic field, removing most of the corruption to enable comparing magnetometer readings with detailed maps of the Earth’s magnetic field. It can then use the resultant signal, alongside other readings, as input to a navigation filter, such as an extended Kalman filter, in order to estimate position. Julia is integral to our research in this field due to its specialties in automatic differentiation, ease of neural network construction, and its performance. This talk will showcase how state-of-the-art (Tolles-Lawson) and machine learning aeromagnetic compensation models can be implemented for real-time compensation, otherwise known as online aeromagnetic compensation. Navigation performance for these approaches will also be compared with the standard (not online) models. false https://pretalx.com/juliacon2024/talk/GBHW7G/ https://pretalx.com/juliacon2024/talk/GBHW7G/feedback/ Method (1.5) Talk 2024-07-12T14:30:00+02:00 14:30 00:30 This talk delves into the challenges of developing task planning languages for robots in complex environments. In this work, we make use of categorical databases and rewriting methods, implemented in Julia, to effectively store and manipulate knowledge bases with large ontologies but sparse data. Julia's multiple dispatch and metaprogramming features have allowed us to develop a concise and scalable task planning system for robotic applications. juliacon2024-43455-what-s-the-plan-asked-my-robot General Angeline Aguinaldo en The slides for the talk can found [here](https://angelineaguinaldo.com/assets/slides/juliacon-2024/presentation.html#/title-slide). As robots become more capable of computing short-horizon motion plans, the question of how to assemble these atomic gestures into more complex, goal-oriented task plans becomes increasingly relevant. In order to orchestrate the execution of motion plans, task planners must be able to reason about knowledge bases with large ontologies but sparse data. For example, in the world where the robot task planner must reason about items in a kitchen-- there are often at least one but no more than a ten, let's say, of a particular type of item in the scene. Contrastingly, these scenes are often rich with relationships between items such as items being next to or on top of other items. Therefore, it is necessary that a task planning system be capable of storing and manipulating such data. To date, there have been few task planning languages that focus on planning within worlds that are described using large ontologies-- a gap this work aims to fill. Julia's multiple dispatch allows us to efficiently implement new logic for existing interfaces. This has been helpful as we expanded our implementation of ACSets to support dynamic instantiations of data. This is especially useful for our application because we often have to instantiate knowledge bases with facts as new information is obtained, for example when cognitive modules return results at different times. Additionally, Julia's metaprogramming has allowed us to define custom DSLs such that we can concisely structure the actions that manipulate our world state. In this talk, we will present the motivation for an alternate task planning language and show how we have leveraged features of the Julia programming language to express and store actions and world states. This work makes use of the packages-- [Catlab.jl](https://github.com/AlgebraicJulia/Catlab.jl), [AlgebraicRewriting.jl](https://github.com/AlgebraicJulia/AlgebraicRewriting.jl), and [ACSets.jl](https://github.com/AlgebraicJulia/Acsets.jl). false https://pretalx.com/juliacon2024/talk/BTHAFN/ https://pretalx.com/juliacon2024/talk/BTHAFN/feedback/ Method (1.5) Talk 2024-07-12T15:00:00+02:00 15:00 00:30 GraphBLAS.jl is a sparse linear algebra package which provides both conformant sparse AbstractArrays and a novel array type for writing graph kernels. Since the last talk on this package a lot has changed: A cross language JIT between Julia and C, complete AbstractArray support, compiler-based backends including GPU support, and Julia-level kernel fusion are all recent additions to the package. juliacon2024-44451-what-s-new-in-graphblas-jl Graphs Raye Kimmerer en Initially named SuiteSparseGraphBLAS.jl a few years ago, the current edition of GraphBLAS.jl provides among the fastest sparse linear algebra libraries in any language today. At it’s core is the SuiteSparse:GraphBLAS C library which provides hand-tuned kernels for CPU execution of sparse and graph algorithms. However, GraphBLAS.jl now uses these kernels as one of several directed acyclic graph (DAG) execution strategies which includes library functions from CUDA / AMDGPU, and runtime compilation from multiple compilers like Finch.jl. These new execution backends are supported by three separate array types, `EagerGBMatrix`, `LazyGBMatrix` and `GBMatrix`. `EagerGBMatrix` executes function calls in a blocking fashion, and performs minimal laziness or fusion (with the exception of lazy `setindex!`). The `LazyGBMatrix` performs no computation until a function is called to explicitly materialize the array, and any `LazyGBMatrix` which is not explicitly materialized may never be computed. However this does not conform to the `AbstractArray` interface, so the final type `GBMatrix` performs this laziness only when it is safe to do so. When laziness is enabled, or the lazy DAG is explicitly constructed, the GraphBLAS.jl runtime will first attempt to dispatch to hand-tuned kernels such as those found in CUDA/AMDGPU or SuiteSparse:GraphBLAS. SuiteSparse:GraphBLAS in particular provides a large number of function skeletons which are highly fusible. For instance, a matrix multiplication preceded and followed by multiple elementwise maps can be fused into a single function call. Using a novel Julia + C -> LLVM cross language JIT built for GraphBLAS.jl the runtime generates code using LTO which is as fast as C native implementations of the same functions. This functionality is used to implement the lazy complex adjoint, by fusing the conjugation into the matrix multiplication, as well as other common AbstractArray functionality. A similar library of function skeletons is implemented in Julia for various important kernels like Sampled-Dense-Dense-Matrix-Multiplication. Other fused expressions or arrays are not able to be dispatched to these hand-tuned libraries. This may occur for more complex expressions, or for array types which are unsupported by library backends. A particularly common case is when the fill value for a sparse array is not equivalent to the identity and/or annihnilator of the function. For these cases a compiler is used to generate a new kernel, which is cached to avoid expensive recompilation. Several compiler backends are supported including Finch.jl, and a modified version of TACO. In the future this may be expanded to more compilers including MLIR Sparsifier, the Sparse Polyhedral Framework, and Etch. In this talk we will briefly discuss the structure of DAG execution, before diving into performance numbers for a selection of common use cases and algorithms. false GitHub https://pretalx.com/juliacon2024/talk/NS3NVT/ https://pretalx.com/juliacon2024/talk/NS3NVT/feedback/ Method (1.5) Lightning talk 2024-07-12T15:40:00+02:00 15:40 00:10 BoxCox.jl is a lightweight package implementing the Box-Cox transformation. It natively supports transformations of unconditional distributions and distributions conditional on a linear predictor. Via package extensions, it also has specialized support for the Wilkinson-Roger formula syntax, GLM.jl, and MixedModels.jl. Diagnostic plots are provided via a package extension for Makie.jl. juliacon2024-44240-boxcox-jl-a-lightweight-package-with-nice-extensions Data Science and Dynamics Phillip Alday en BoxCox.jl provides a StatsAPI.jl-compatible implementation of the Box-Cox transformation, with plans for supporting additional power transformations such as the Yeo-Johnson transformation and Bickel-Doksum transformation. The struct representing the fitted Box-Cox transformation is callable, such that the call `fit(BoxCoxTransformation, y).(y)` fits and transforms the data in single step. Implementations of the Box-Cox transformation differ in their normalization of the log-likelihood; BoxCox.jl's implementation is normalized to match the behavior of the MASS package in R. The transformation is fit via nonlinear optimization, which can be applied to either the unconditional distribution or to a conditional distribution. The core package supports a conditional distribution from linear regression when passed a suitable model matrix. The core package is kept lightweight by placing specialized functionality in package extensions on Julia 1.9+. For example, the package also provides support for the StatsModels.jl-based implementation of the Wilkinson-Roger formula syntax and linear mixed-effects models from MixedModels.jl. All of these packages are used to compute a conditional distribution. No extension support is provided for GLM.jl-based models because the package-internal linear regression implementation is optimized for the repeated regression-model fitting done while fitting the Box-Cox transformation. The resultant transformation can nonetheless be used to fit a model with GLM.jl. The package was motivated by mixed-effects models and the desire for a fast, easy-to-use implementation. The tight integration with MixedModels.jl provides for exactly this: a very fast implementation of the Box-Cox transformation compared to offerings in other languages. Via a Makie.jl-based extension, the package also provides a profile plot of the likelihood for different values of the λ parameter, including confidence intervals. These plots provide the analyst with the ability to more easily choose a parameter value that has a natural interpretation but is statistically indistinguishable from the maximum likelihood estimate -- for example, a transformation of time to speed. false GitHub Presentation Materials https://pretalx.com/juliacon2024/talk/AZCU8N/ https://pretalx.com/juliacon2024/talk/AZCU8N/feedback/ Method (1.5) Lightning talk 2024-07-12T15:50:00+02:00 15:50 00:10 Would you like to have access to your favourite C/C++ library from Julia, but don't know where to start? Follow this case-study for the development of [MuJoCo.jl](https://github.com/JamieMair/MuJoCo.jl), which highlights the steps and tools required to create one of these packages. juliacon2024-44355-mujoco-jl-a-case-study-for-developing-julia-bindings Julia Internals and Tooling Jamie Mair en Slides at [https://cbindings-jc2024.netlify.app/](https://cbindings-jc2024.netlify.app/) As a large and frequently updated C library, [MuJoCo](https://github.com/google-deepmind/mujoco) serves as a great case study to showcase what it takes to develop high quality bindings for Julia. In this talk, we follow the development of [MuJoCo.jl](https://github.com/JamieMair/MuJoCo.jl), covering the following topics: - Writing a script using [BinaryBuilder.jl](https://docs.binarybuilder.org/stable/) to generate a cross-platform JLL binary for your package. - Creating a basic Julia wrapper for your JLL with automatic source code generation using [Clang.jl](https://github.com/JuliaInterop/Clang.jl). - Taking your package to the next level by writing an automated script to scrape documentation and generate native bindings, converting to Julia types when necessary. - Keeping your package up-to-date with **minimal** maintenance. By the end of this talk, you should know what is needed to develop a portable, high-performance, user-friendly and well-documented package that gives the Julia community seamless access to an existing C/C++ library. false GitHub Talk slides https://pretalx.com/juliacon2024/talk/LXAMKE/ https://pretalx.com/juliacon2024/talk/LXAMKE/feedback/ Method (1.5) Lightning talk 2024-07-12T16:00:00+02:00 16:00 00:10 This package offers efficient storage of large array snapshots during simulations, using ZFP compression for in-memory or out-of-core (file-based) storage. Both compress 2D to 4D arrays for intermediate steps in iterative process, which can be used for gradient calculation, plotting, and other applications. The Innn-memory compresses arrays into byte vectors, while the out-of-core storage compresses and writes array slices to files per thread, showing great performance in heavy simulations. juliacon2024-44440-sequentialcompression-jl-out-of-core-multi-array-compression Accelerated & large-scale computing /media/juliacon2024/submissions/GENHM9/mainGraphics_aNySfuU.png Átila Saraiva Quintela SoaresMauricio D Sacchi en It is common in numerical simulations to store the state variable, commonly an array, at each or select iterations of the simulation. This is done for many reasons, such as restarting the simulation from a certain point, analyzing the evolution of the state variable, or calculating the gradient using the adjoint state method. In this work, we present a package that aims to provide a simple interface to compress arrays that compose the state of a simulation using the ZFP compression algorithm. Preserving a simulation's state is a well-established practice, often achieved through advanced techniques. In the context of implementing the adjoint state method, it is essential to store the state of the forward modelling function. This stored state is then utilized in each iteration of the adjoint modelling to compute the gradient. However, due to the extensive data involved – a product of the grid's spatial dimensions and the number of temporal iterations – storing every state in memory becomes impractical for large-scale models. The more straightforward solution is to store every state in a data storage device, which raises several other issues. The most obvious is that the storage device might need more space to support the size of the collection of arrays. Given enough space, the storage device has to have enough performance not to increase the simulation time per iteration considerably. However, even if it can store all of them, it is a matter of how many write cycles this storage device can handle before it breaks. Compression tries to trade computation time for a reduction in needed storage, increasing the storage device's lifespan and allowing it to fit more data. However, several algorithms have different parameters to consider when it comes to floating point compression. The chosen one was the ZFP algorithm (Lindstrom, 2014; Diffenderfer et al., 2019), with the wrapper ZfpCompression.jl, because it can handle different levels of lossy compression with different parametrizations that allow more control over throughput, space-saving and decompressed image quality. It is a lossy and lossless compression algorithm that can compress arrays of floating point numbers targeting numerical simulations. The main argument for its creation was that simulations usually have barely any size decrease when using lossless compression, as can be seen in Table 4 of Ratanaworabhan et al. (2006), given that the numbers are all floating point with very little room for deduplication techniques commonly employed by this kind of algorithm. However, lossy compression can use thresholding/truncation techniques to decrease the size of the array. However, it has to be careful to keep the signal-to-noise ratio lower so that it does not reduce the accuracy of the simulation. The ZFP algorithm allows users to control how much accuracy, throughput or precision is necessary for their specific problem and is highly parallelizable. Thus, the package described in this paper uses it in the backend by leveraging the ZfpCompression.jl package. The package SequentialCompression.jl described in this report can compress a collection of arrays, fed to a data structure sequentially, and decompress arrays in any order by simple linear indexing. It has two compressors; one compresses whole arrays and saves them in a long binary vector in memory, and the other splits each array on its last dimension and compresses and saves each piece to one or several data storage devices, with one file per CPU thread. The former will be called the ''in-memory'' compressor, and the latter the ''multifile'' compressor. It aims to provide a simple interface to compress and access these arrays. The interface of the described package provides much functionality in the form of optional keyword arguments for the constructor. The user can control what compressor he wants to use and specify a prediction of the number of arrays to be compressed to optimize the in-memory compressor. For the multi-file compressor, the user can specify a folder containing all compressed array slice files or different folders in different devices to maximize bandwidth. The purpose of this package is to facilitate the usage of lossy compression of iterative processes such as physical simulations, where it is frequent to have arrays of the same size at each iteration. Depending on the number of threads, the performance obtained with the multifile compressor is between saving the array into disk and another higher dimensional array. In summary, it has the functionality and performance to be easily integrated into simulation research workflows. false The source code of the package https://pretalx.com/juliacon2024/talk/GENHM9/ https://pretalx.com/juliacon2024/talk/GENHM9/feedback/ Method (1.5) Lightning talk 2024-07-12T16:10:00+02:00 16:10 00:10 High-dimensional partial differential equations (PDEs) arise in various scientific domains, including physics, engineering, finance, and biology. However, simulating these PDEs is challenging due to the “curse of dimensionality.” As dimensions increase, the computational cost of solving these equations grows exponentially. HighDimPDE.jl is a Julia package that addresses this curse of dimensionality, offering deep learning-based solutions for the simulation of high-dimensional PDEs. juliacon2024-44346-highdimpde-jl-solving-high-dimensional-pdes-using-deep-learning SciML Ashutosh Bharambe en Building upon the SciML ecosystem in Julia, HighDimPDE.jl implements algorithms to solve problems related to high dimensional PDEs, such as non-local non-linear PDEs, Kolmogorov PDEs and their parametric families. Additionally, it provides solutions for optimal stopping strategies for pricing high-dimensional stock options (Obstacle PDEs). In this talk, we will, - Demonstrate the NNStopping algorithm for solving optimal expected pay-off and optimal stopping strategy for high-dimensional stock options. - Demonstrate the NNKolmogorov algorithm for solving Kolmogorov PDEs - Demonstrate the NNParamKolmogorov algorithm, which solves a parametric family of high-dimensional Kolmogorov PDEs, and provides a solution over all parameters and initial values of independent variables. - Building on the previous point, we will perform parameter estimation on the model obtained from NNParamKolmogorov. false https://pretalx.com/juliacon2024/talk/WJTHSD/ https://pretalx.com/juliacon2024/talk/WJTHSD/feedback/ Method (1.5) Lightning talk 2024-07-12T16:20:00+02:00 16:20 00:10 We introduce Cairn.jl, a Julia library of state-of-the-art active learning algorithms for training machine learning interatomic potentials for molecular dynamics simulation. This package provides a unifying Julia-based platform for rapid comparison and prototyping of active learning schemes, including a novel technique based on kernel Stein discrepancy for data querying and labeling. juliacon2024-44405-cairn-jl-enhanced-molecular-dynamics-for-active-learning Physics & Quantum Chemistry Pablo ZubietaJoanna Zou en **Background.** The adoption of machine learning methods in atomistic simulations has accelerated the tractability of computational materials characterization and discovery. *Machine learning interatomic potentials* (ML-IPs) are developed as surrogate models for estimating electronic structure properties such as potential energy and forces of local atomic environments. From a training dataset of quantum mechanical (QM) calculations of energy and forces, ML-IPs have the potential to achieve quantum-level accuracy at a fraction of the cost, enabling molecular dynamics (MD) simulation on scales at which macroscopically observable chemical and physical properties can be quantified. The central challenge in machine learning model development is the tight dependency of the model’s performance on the choice of reference data used for training. Developing a reference dataset for training ML-IPs is non-trivial, involving manual assembly of datasets based on expert heuristics or sampling atomic configurations from MD simulation, which often exhibit metastable dynamics and fail to converge on the canonical probability distribution [1]. As a response, several algorithms for *active learning* for ML-IPs have been introduced, where the objective is to most efficiently improve model performance through the iterative acquisition of training data and labeling using expensive QM calculations as an oracle. As noted in [2], comparison of these methods is difficult, due to “inhomogeneous [...] notation schemes” and implementations in different programming languages and platforms. **Contribution.** We introduce Cairn.jl, a Julia library of active learning algorithms for training ML-IPs. These techniques assemble diverse datasets of atomic configurations representing a wide range of energetic states to train ML-IPs capable of characterizing chemical and physical processes of interest. The active learning strategy in Cairn.jl is an alternating-stage algorithm where the first stage centers on data acquisition through sampling by MD simulation. Users may choose between existing simulators - such as Velocity Verlet or Langevin dynamics - and “enhanced” simulators implemented in Cairn.jl, in which a biasing force term in the equation of motion guides the simulation path toward underrepresented regions of the free energy landscape [3,4,5]. The samplers include: * Query-by-committee methods [3] * Uncertainty-driven dynamics [4,5] * Stein repulsive dynamics [7,8] The second stage centers on data labeling, in which a criterion calculated during MD simulation triggers retraining of the ML-IP. An uncertainty or diversity metric determines a subset of samples from the MD trajectory for which to label using calls to the oracle and augment to the training set. The retraining criteria include: * Thresholds using ensemble-based or GP-based estimates of uncertainty [3,4,5,6] * Thresholds using similarity kernel evaluations (kernel Stein discrepancy) [7] We show that ML-IPs trained using iteration of this active learning scheme achieve greater accuracy with significant gains in efficiency compared to those trained with brute force methods of data acquisition and labeling. **Research impact.** This work provides one of the first platforms to unify recent active learning algorithms for ML-IPs. Moreover, it contains the first implementation of a novel active learning scheme derived from Stein variational gradient descent, to be detailed in a future article. The package provides the optionality to execute MD simulation on multiple software platforms, including the widely used LAMMPS and the Julia-native Molly.jl. Cairn.jl will enable easy comparison of the techniques, such that users may quickly prototype active learning routines and choose the algorithm best suited for their problem. **Relevance to the Julia community.** Cairn.jl fills a key gap in the growing Julia ecosystem for molecular simulation, existing in the software suite of CESMIX (Center for Exascale Simulation of Materials in Extreme Environments) and interfacing with packages such as PotentialLearning.jl, InteratomicPotentials.jl, Molly.jl, and ACEpotentials.jl. Moreover, the package serves as a starting point for general purpose active learning algorithms for machine learning model development which rely on MCMC-type sampling of probability distributions, which is a broader interest of the Julia scientific community. **References.** [1] Comer (2015). J of Phys Chem B. doi: 10.1021/jp506633n. [2] Henin (2022). LiveCoMS. doi: 10.33011/livecoms.4.1.1583. [3] Smith (2018). J of Chem Phys. doi: 10.1063/1.5023802. [4] Kulichenko (2023). Nat Comp Sci. doi: 10.1038/s43588-023-00406-5. [5] van der Oord (2023). npj Comp Mat. doi: 10.1038/s41524-023-01104-6. [6] Vandermause (2020). npj Comp Mat. doi: 10.1038/s41524-020-0283-z. [7] Liu (2016). NeurIPS. url: http://arxiv.org/abs/1608.04471. [8] Ye (2020). NeurIPS. url: http://arxiv.org/abs/2002.09070. false slides https://pretalx.com/juliacon2024/talk/3RFKKQ/ https://pretalx.com/juliacon2024/talk/3RFKKQ/feedback/ Method (1.5) Talk 2024-07-12T16:30:00+02:00 16:30 00:30 This talk introduces cadCAD.jl, a work in progress open source Julia library for modeling and simulating dynamical systems with generic attributes. Instead of evolving numbers over time, system engineers and data scientists can now evolve any kind of data structure in their dynamic systems simulations. juliacon2024-43289-cadcad-jl-a-modeling-library-for-generalized-dynamical-systems General Emanuel Lima en This talk introduces cadCAD.jl, a work in progress open source Julia library for modeling and simulating dynamical systems with generic attributes. Instead of evolving numbers over time, system engineers and data scientists can now evolve any kind of data structure in their dynamic systems simulations. With cadCAD.jl, models of these systems can yield: (1) all possible trajectories produced by transformations; (2) identification of properties associated with underlying assumptions; and (3) iterated insights about the model. Our goal with this talk is to show the main ideas behind the library, how it promotes open science, and how it would fit in a data science workflow, by running an example simulation. Outline: Introduction (2 minutes) What is a dynamical system and why should you care (5 minutes) What is a generalized dynamical system and how it empowers modelers (5 minutes) What are block diagrams and what are their relation to generalized dynamical systems (5 minutes) How cadCAD.jl fits all those concepts into an easy to use UI and UX (3 minutes) Live demo of a simulation from start to finish (10 minutes) false GitHub https://pretalx.com/juliacon2024/talk/JNFYPP/ https://pretalx.com/juliacon2024/talk/JNFYPP/feedback/ For Loop (3.2) Lightning talk 2024-07-12T10:10:00+02:00 10:10 00:10 [NeuroTreeModels.jl](https://github.com/Evovest/NeuroTreeModels.jl) introduces `NeuroTree`, a differentiable tree operator for tabular data. It's implemented as a general neural network building block, similar to `Dense` or `Conv`, making it composable with the components of the Flux ecosystem. The library includes a ready to use regressor that follows the MLJ interface. Comprehensive benchmarks on common datasets show its competitiveness with state-of-the-art boosted tree models. juliacon2024-44502-neurotree-a-differentiable-tree-operator-for-tabular-data AI/ML/AD Jeremie Desgagne-Bouchard en NeuroTree addresses the greediness of traditional trees by having all node and leaves learnt simultaneously and incorporates the benefits of boosting and bagging through a built-in ensemble of trees. Computation of leaf weights consists in accumulating the weights through each tree branch, resulting to in-place element wise operations that are not friendly to auto-differentiation engines. This limitation is overcome using custom reverse rules through ChainRules, both for CPU and GPU. Benchmarks were run against some of the most common regression datasets for regression, classification and ranking tasks and state of the art algos (XGBoost, LightGBM, CatBoost, EvoTrees). We show that NeuroTree is the single best for 2 of the 6 datasets (Higgs and YEAR), close to best on 2 others, but perform worst on the 2 ranking tasks. We also highlight the relevance of Julia's machine learning capabilities in the commercial context of a portfolio manager. false NeuroTrees-JuliaCon2024.pdf https://pretalx.com/juliacon2024/talk/D3BHTT/ https://pretalx.com/juliacon2024/talk/D3BHTT/feedback/ For Loop (3.2) Lightning talk 2024-07-12T10:20:00+02:00 10:20 00:10 In the Julia community, there are a lot of packages specialized for single (i.e. not combined) methods of algorithmic differentiation (AD), like the well-known ForwardDiff.jl or ReverseDiff.jl. In contrast, the ADOL-C (https://github.com/coin-or/ADOL-C) package was aimed to build a general purpose AD package, which was originally written in C/C++. The newly developed package ADOLC.jl combines the various functionalities of ADOL-C with the convenient usability of Julia. juliacon2024-44438-the-general-purpose-algorithmic-differentiation-wrapper-adolc-jl AI/ML/AD Tim Siebert en Calculation of exact derivatives is a cornerstone of scientific computing. It enables deep learning, solving non-linear partial differential equations, simulating models in quantum field theory or even quantify the sensitivity of a portfolio value with respect to a changing volatility, to mention just a few applications. The calculation of the derivatives becomes quickly very challenging, when derivatives of complex algorithms or higher derivative tensors are required. Therefore, there is a need for practical AD software packages to automatizes the calculation for the scientific computing community. The most known techniques are the forward and reverse mode which are efficient to calculate first derivatives in various situations. When it comes to second or higher-order derivatives, combinations of forward and reverse mode are mostly more efficient, limiting the use-case of packages that are based on merely one method. Additionally, instead of full matrices including all partial derivatives, many real-world algorithms only involve jacobian or hessian vector products. In the Julia community, there are a lot of packages specialized for single (i.e. not combined) methods of AD, like the well-known ForwardDiff.jl or ReverseDiff.jl. In contrast, the ADOL-C (https://github.com/coin-or/ADOL-C) package was aimed to build a general purpose AD package, which was originally written in C/C++. The newly developed package ADOLC.jl combines the various functionalities of ADOL-C with the convenient usability of Julia. ADOLC.jl is designed to enable applications that are unfamiliar with the AD methods, to leverage the right AD-mode in the right situations. To this end, ADOLC.jl includes functionalities for forward and reverse mode and an easy-to-use derivative driver which can switch the AD mode based on the dimensions of the input and output of the given function. Furthermore, there are drivers for Taylor series propagation, jacobian and hessian vector or matrix products, as well as drivers for arbitrary high derivative tensors, among others. The interested reader is referred to the project’s GitHub: https://github.com/TimSiebert1/ADOLC.jl In the talk, we will go through the most important functionalities of ADOLC.jl. The attendee will learn how to easily compute the derivatives of a given program in forward and reverse mode, as well as the corresponding higher-order derivatives. Since the computation of higher-order derivatives should exploit the symmetries of the partial derivatives, there will be a short explanation on how to obtain the tensor in a compressed matrix format and how to decompress it to the full tensor. In the end, it will be shown how to propagate a Taylor series. The low-level methods, directly translating the C/C++ functions and the more convenient higher-level functions, are presented. The low-level functions provide the advanced user more control, whereas the higher-level functions choose suitable low-level functions in different situations. The main goals of the talk are: - how to compute first-order derivatives in forward and reverse mode - how to obtain higher-order derivative tensors - how to do a Taylor series propagation It has to be emphasized, that this package is a Julia wrapper of the C/C++ package ADOL-C. Thus, ADOLC.jl aims to directly translate most of the functions of ADOL-C to Julia. In addition, we focus on implementing higher level functions, which combines different translated functions to improve the usability. This will include for example, a derivative function which automatically selects the right mode for the evaluation from a user-defined function and a given derivative order. The package aims to reduce the effort for users to use a lot of different methods from the AD world. false Slides https://pretalx.com/juliacon2024/talk/AADQNR/ https://pretalx.com/juliacon2024/talk/AADQNR/feedback/ For Loop (3.2) Talk 2024-07-12T10:30:00+02:00 10:30 00:30 Dive into the world of Generative AI with Jan as he explores its potential and applications within the Julia ecosystem. Learn why GenAI matters, discover real-world applications across leisure, productivity, and business, and gain practical tips for building successful GenAI projects. Join the growing community of GenAI developers in Julia and start building today! juliacon2024-44306-ai-wrote-this-discover-generative-ai-in-julia AI/ML/AD Jan Siml en In this JuliaCon talk, we will explore the exciting world of Generative AI within the Julia ecosystem. We will examine the current state of Generative AI in Julia, focusing on where we see strengths and where are the gaps screaming to be filled by tinkerers. Join us at JuliaCon to dive into the world of Generative AI in Julia! We're going to take a close look at what’s currently happening in this exciting field, exploring the tools and technologies that are available right now in Julia. The main focus will be the text modality and Large Language Models (LLMs). We’ll discuss the benefits of using Generative AI to help you figure out if it's something you'd like to try or get involved in. We'll also highlight areas that are ripe for some improvement and growth. This is where the Julia community comes in: we believe that with your input and contributions, we can sprinkle some of that Julia magic sauce on these areas, enhancing them to meet the high standards of innovation and excellence that other Julia tools exemplify. We're going to keep things practical, showcasing real-world applications and the tools that make them possible. It’s all about giving you a clear picture of how Generative AI can be used, from start to finish, in various projects. So come along, learn, and get inspired. This is a great opportunity to contribute to the growth and innovation of Generative AI in the Julia ecosystem. Let’s work together to make some amazing things happen! → Thank you, GPT4! I couldn’t have said it better Resources that will be covered: - [Awesome Generative AI meets Julia](https://github.com/svilupp/awesome-generative-ai-meets-julia-language) - [Julia LLM Leaderboard](https://github.com/svilupp/Julia-LLM-Leaderboard) - [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) And many more...! false Slides Report https://pretalx.com/juliacon2024/talk/FUWUXB/ https://pretalx.com/juliacon2024/talk/FUWUXB/feedback/ For Loop (3.2) Talk 2024-07-12T11:00:00+02:00 11:00 00:30 Causal inference has proven invaluable to many organizations, however, it is often infeasible because it requires them to conduct expensive experiments. Fortunately, advances in causal machine learning give us new methods to estimate causal effects from observational data. Accordingly, in this talk, I will introduce CausalELM, a package that implements causal estimators based on extreme learning machines, and discuss how it can be used to estimate average and individualized treatment effects. juliacon2024-42943-causal-machine-learning-with-causalelm AI/ML/AD /media/juliacon2024/submissions/J9D8PL/github_logo_Mbq7iHU.jpg Darren Colby en Causal inference is a useful tool, not only for those conducting academic research, but also large organizations deciding on how to allocate resources. For example, streaming services use A/B tests to decide whether to roll out a new feature, rideshare companies estimate individual treatment effects and use them to determine how much to charge passengers, and e-commerce companies perform causal inference to decide which products to recommend to users. However, estimating causal effects is not easy. Running A/B tests or randomized control trials are expensive: researchers do not have the ability to change public policies, or the dimensionality of the potential covariates is too high for traditional statistical methods. CasualELM addresses these and other challenges by leveraging recent advances in causal machine learning. To that end, we will cover the following main topics: • Potential Outcomes Framework: We will briefly discuss the potential outcomes framework, which CausalELM's estimators fall under. • Motivating Examples: I will motivate the talk with two examples. First, I will demonstrate how CausalELM can be used to estimate the effect of 401(k) pension plan eligibility on net worth using double machine learning. Second, I will use a recent study of the effect of development aid on Taliban attacks to demonstrate how to estimate individualized treatment effects in CausalELM . These examples will make up the majority of the talk. • Extreme Learning Machines: We will discuss what extreme learning machines are, how they work, and how they are used in ensembles in CausalELM. • Other Estimators: Besides the motivating examples, we will touch upon the other estimators implemented in CausalELM. • Comparison with Other Packages: We will talk about how CausalELM is different from other causal machine learning libraries and the main tradeoffs it makes. The focus of the talk will be on the implementation of causal machine learning tasks, rather than the mathematical theory behind them, so those without an extensive background in statistics should not feel intimidated. false Github Notebooks to follow along with the talk Presentation slides https://pretalx.com/juliacon2024/talk/J9D8PL/ https://pretalx.com/juliacon2024/talk/J9D8PL/feedback/ For Loop (3.2) Lightning talk 2024-07-12T11:40:00+02:00 11:40 00:10 In this talk, we update on the developments of the [Sole.jl](https://github.com/aclai-lab/Sole.jl) framework for **symbolic AI**. In the past year we have been implementing a few algorithms for learning symbolic models (e.g., rules, lists, trees, forests), and for analyzing, evaluating, and post-processing the learned models. juliacon2024-44364-symbolic-ai-workflows-with-sole-jl AI/ML/AD Giovanni Pagliarini en Symbolic AI provides transparent alternatives to standard black-box AI algorithms, and includes methods for rule extraction, data mining and decision tree/list learning. The field is underdeveloped, its potential still to discover, and a programming framework for it is needed. Sole.jl proposes itself as the first programming framework specifically tailored for symbolic AI workflows, and it puts specific focus on a symbolic representation of knowledge, in the abstract form of syntax trees. At the moment, it is still at an early stage, but its vision includes symbolic algorithms for processing data, for learning rules, trees, lists, and ensembles, and for post-hoc processing the learned models and their knowledge. In this talk, we overview the structure of Sole.jl, and update on some advancements made in the past year. Additional resources: 1. A 10-hour course on Modal Symbolic Learning with Sole.jl: [YouTube playlist](https://www.youtube.com/playlist?list=PLyuPAlvJWIqLvYpGhenzXCA1JMW2HQwBv), [Slides and Jupyter Notebooks](https://github.com/aclai-lab/modal-symbolic-learning-course/); 2. A technical motivation for Sole.jl was [presented at JuliaCon2023](https://live.juliacon.org/talk/LYSQWS) false GitHub Slides https://pretalx.com/juliacon2024/talk/PUWYKE/ https://pretalx.com/juliacon2024/talk/PUWYKE/feedback/ For Loop (3.2) Lightning talk 2024-07-12T11:50:00+02:00 11:50 00:10 Probabilistic Programming Languages (PPLs) aim to shield users from the complex mechanics of Bayesian inference. GraphPPL has previously been introduced as the PPL of RxInfer.jl. GraphPPL uses Julia's metaprogramming functionality to transform high-level user code into correct Julia syntax. In the newest release of GraphPPL, users can use any GraphPPL model as a submodel in larger models, introducing modularity into probabilistic programming. juliacon2024-43275-what-s-new-with-graphppl-jl AI/ML/AD Dmitry BagaevWouter Nuijten en Introduction Popular Probabilistic Programming Languages (PPLs) in Julia include Turing.jl and GraphPPL.jl, with both packages exploiting Julia's metaprogramming functionality to design a syntax for specifying probabilistic generative models. This metaprogramming approach differs from approaches like Pyro that aim to define the syntax of the PPL within the used general-purpose language. PPLs based on metaprogramming generally offer a higher-level programming interface and can shield many implementational details from the user by transforming high-level user code into specific instructions. A shortcoming of existing PPLs is that there is a limited notion of modularity or reuse of models in larger models. The newest release of GraphPPL aims to fill this gap by allowing users to use any previously specified model as a submodel. By explicitly framing the generative model as a Factor Graph, existing models can always be used as subgraphs in a larger generative model. The newest release of GraphPPL also removes the dependency on a particular inference backend from the requirements, making it a backend-agnostic PPL that fully specifies a generative model and possible inference constraints. Nested model specification For deep learning modeling, PyTorch revolutionized model specification by introducing a modular model specification language. Any PyTorch module can be used as a submodule in a larger model. GraphPPL introduces this modularity to Probabilistic Programming, by allowing the user to use any GraphPPL model in a larger model specification. By materializing the specified model as a Factor Graph, existing models are represented as specific graphs and can be used as subgraphs in larger models. By allowing users to build complex models through the composition of nested sub-models, GraphPPL alleviates researchers from the burden of interpreting an entire model when making subtle adjustments. Instead, the complexity is encapsulated within the nested submodels, presenting users with a concise and focused view of the code relevant to their specific modeling decisions. This modularity is akin to the concept of functions in ordinary programming, where functions greatly improve the readability and maintainability of computer programs. Similarly, GraphPPL sub-models enhance the modularity and readability of probabilistic models, allowing for a more intuitive and efficient workflow for researchers and practitioners. Backend agnosticism Previous releases of the GraphPPL language were dependent on the inference backend provided by ReactiveMP.jl. This dependency has been removed, making GraphPPL a backend-agnostic PPL. The main advantage of this is that other Bayesian Inference packages can use GraphPPL as their user interface. A model created in GraphPPL fully specifies a generative model and inference constraints necessary for inference backends to perform Bayesian Inference. Conclusions The most recent update to GraphPPL redesigned the language to support nested model specification through the materialization of a Factor Graph. Along with other significant quality-of-life updates, this marks a significant milestone in the design of the PPL and by extension to the RxInfer ecosystem. false Presentation https://pretalx.com/juliacon2024/talk/UKB7XN/ https://pretalx.com/juliacon2024/talk/UKB7XN/feedback/ For Loop (3.2) Talk 2024-07-12T12:00:00+02:00 12:00 00:30 Machine learning model development, characterized by iterative experimentation and adjustments, often leads to complex model iterations, making tracking and debugging challenging. This talk explores the application of CI/CD methodologies to machine learning, using Julia's Pkg ecosystem, Buildkite, GitHub, and MLflow. We showcase a streamlined process for efficient model development and tracking that can lead to mass robust experimentation for machine learning workflows juliacon2024-44413-modern-ci-cd-machine-learning-workflows-using-julia AI/ML/AD Dhairya GandhiAnas Abdelrehim en By reimagining machine learning model development through the lens of package development, we introduce a stream-lined workflow that enables building machine learning models in a test-driven manner with git-level reproducibility all within Julia. This approach minimizes the hidden states and dependencies often encountered in traditional machine learning development environments. We will explore in depth how this reconfiguration leads to more robust, reproducible, and streamlined model development processes that can scale to production environments. Complementing this, we integrate MLflow, an open-source model lifecycle management tool, through MLFlowClient.jl and extend it to enhance our development pipeline. MLflow's graphical user interface facilitates easy management of model configurations and their outcomes. It provides valuable insights and a user-friendly interface for tracking, managing, and evolving machine learning models. Throughout the session, we showcase how these methodologies, when applied in the realm of machine learning, lead to more efficient, transparent, and robust model development, enabling mass robust experimentation for machine learning workflows in the julia ecosystem. false https://pretalx.com/juliacon2024/talk/ZGULY8/ https://pretalx.com/juliacon2024/talk/ZGULY8/feedback/ For Loop (3.2) Talk 2024-07-12T14:00:00+02:00 14:00 00:30 The deployment of low Earth orbit satellite internet constellations has revolutionized global connectivity. The design and operations of these systems rely heavily on large-scale simulations. At Eutelsat-Oneweb, we have developed a comprehensive full-scale constellation simulator to power our design and regulatory compliance workflows. This talk provides an overview of the simulation architecture and performance benefits that the use of Julia has unlocked for us. juliacon2024-43601-designing-satellites-constellations-with-julia General Romain Clement de Givry en Satellite internet constellations are global scale systems designed to deliver ubiquitous low-latency and high bandwidth connectivity across the globe. In these systems users are issued terminals to communicate with the constellation which relays information to and from gateways on the ground. User traffic is then routed into other networks. Notable examples of these systems include the existing Starlink and OneWeb constellations, with ongoing efforts in deploying similar systems. In the context of Eutelsat-OneWeb's system, thousands of subsystems are involved in delivering our connectivity services. The orchestration and intricate coordination amongst satellites, user terminals, semi-automated control centres, expansive internet networks and ground antenna arrays is critical for ensuring seamless service. A key aspect of the design and operation of such constellations is modelling the interaction between subsystems. For example, to estimate the impact of system configuration changes on the quality of service. Simulations become particularly detailed in that case, necessitating second level resolution over extended durations. To support the design of our next generation constellation, we undertook a rework of our simulation tooling. The guiding objectives were to enhance the flexibility and performance to facilitate rapid design iterations. This presentation is an overview of our implementation of a simulator designed to meet our design goals with minimal complexity. Specifically, we focused on the following areas: - Simulating of all our subsystems and their variants in one unified environment. - Enabling the configuration and development of the simulator without imposing stringent programming knowledge requirements. - Achieving high performance to enable fast iteration on simulation results. We'll explain how we use Julia's unique features to implement a comprehensive system simulator supporting arbitrary subsystem models transparently. In particular, how this approach allows us to develop simulations efficiently. Additionally, we will also describe the performance and large-scale deployment benefits we encountered through the switch to this language. false https://pretalx.com/juliacon2024/talk/HCAWJU/ https://pretalx.com/juliacon2024/talk/HCAWJU/feedback/ For Loop (3.2) Talk 2024-07-12T14:30:00+02:00 14:30 00:30 `BifurcationKit.jl` is a package for numerical bifurcation analysis which allows to study dynamical systems as function of a parameter. It incorporates automatic bifurcation diagram routines and efficient tools to study periodic orbits. Most of these tools run on GPU and can be used with a large number of unknowns. juliacon2024-43473-what-s-new-with-bifurcationkit-jl General Romain VELTZ en Over the past year, the `bifurcationkit` organization has undergone significant enhancements tailored for the exploration of periodic orbits and homoclinic orbits. These updates address critical gaps in comparison to other widely utilized software in the field. Additionally, integration into `ModelingToolkit.jl` promises to streamline analysis processes, complemented by substantial improvements in documentation for a more user-friendly experience. A pivotal advancement within BifurcationKit lies in the incorporation of methods dedicated to examining bifurcations of periodic orbits as functions of two parameters. This is particularly challenging for standard techniques like collocation, but our unified approach accommodates various methods for computing periodic orbits. This versatility is crucial for investigating problems spanning both low-dimensional and large-scale scenarios. Another noteworthy enhancement is the introduction of the `HclinicBifurcationKit.jl` package, designed specifically for studying homoclinic orbits as function of two parameters. Notably, our implementation supports Shooting methods, differentiating us from existing software alternatives. The ensuing discussion will spotlight these enhancements through a straightforward example, showcasing how they facilitate a comprehensive understanding of system dynamics. Subsequently, an exploration of the design choices made to accommodate the diverse solvers and methods for computing periodic orbits will be presented, along with the inherent challenges in ensuring a user-friendly interface. We will conclude by emphasizing the future trajectory of `bifurcationkit`, highlighting ongoing efforts to enhance integration with `MethodOfLines.jl`, `ModelingToolkit.jl`, and other frameworks. Lastly, an overview of anticipated general additions will be provided, outlining the continuous evolution of the `bifurcationkit` organization. false GitHub https://pretalx.com/juliacon2024/talk/B7L8QV/ https://pretalx.com/juliacon2024/talk/B7L8QV/feedback/ For Loop (3.2) Talk 2024-07-12T15:00:00+02:00 15:00 00:30 Kubernetes is the most widely used open-source container orchestration system. Kubernetes is used by businesses, big and small the world over to deploy, scale and manage their containers. Kuber.jl is a julia client library for Kubernetes. In this talk, I will present a brief overview of the basic capabilities of Kuber.jl. We will then dive into some advanced topics such as working with Custom Resource Definitions and generating the client with OpenAPI. juliacon2024-43813-kuber-jl-an-openapi-based-kubernetes-client-for-julia General Nishanth H. Kottary en [Kubernetes](https://kubernetes.io/) greatly simplifies the work of deploying and managing micro services spread across many physical or virtual machines. Kubernetes can run on-premise or on public Cloud platforms like Google cloud, Amazon AWS and Microsoft Azure. Kubernetes also lets you define and work with various other resources apart from the micro service containers themselves. These include storage devices, load balancers, configuration files, secret tokens etc. All of these resources as well as custom defined resources can be deployed and managed with [Kuber.jl](https://github.com/JuliaComputing/Kuber.jl). The Kuber.jl methods are designed following a pattern of verbs and entities. Entities are Kubernetes resources that are identified by their class and by either their name or a selector pattern. Verbs are methods that act on these entities. Verbs include create, update, get and so on. Kuber.jl also leverages the watch API of Kubernetes. This lets us run a Julia closure on notifications from Kubernetes. Using this powerful API we can implement various monitoring and management services with Julia code. In addition, verbs can be passed to the watch API to process the notification stream in various ways. In this talk I will go over some of the basics of Kuber.jl before delving into the advanced features. I will demonstrate the deployment of a web application to a local Kubernetes cluster. We will go over the details of working with namespaces, checking for pod and load balancer readiness and ways to update a deployment. I will demonstrate how we can generate the client code of Kuber.jl using the [OpenAPI](https://swagger.io/specification/) generator and some Julia scripts that we provide in the Kuber.jl GitHub repository. Using these we can modify the client if we ever need to deal with Custom Kubernetes resources. false GitHub Presentation https://pretalx.com/juliacon2024/talk/ASERZM/ https://pretalx.com/juliacon2024/talk/ASERZM/feedback/ For Loop (3.2) Lightning talk 2024-07-12T15:40:00+02:00 15:40 00:10 [HumanEval](https://github.com/openai/human-eval) and [MBPP](https://github.com/google-research/google-research/tree/master/mbpp) are two of the most frequently used benchmarks to evaluate LLM's performance in code generation. However, they mainly focus on the Python programming language only. In this talk, we will analyze SOTA code LLMs' performance in Julia. Results will be updated constantly at HumanEval.jl juliacon2024-42432-evaluate-llm-synthesized-julia-code AI/ML/AD Jun Tian en [HumanEval](https://github.com/openai/human-eval) and [MBPP](https://github.com/google-research/google-research/tree/master/mbpp) are two of the most frequently used benchmarks to evaluate LLM's performance in code generation. However, they mainly focus on the Python programming language only. In this talk, we will analyze SOTA code LLMs' performance in Julia. Results will be updated constantly at HumanEval.jl false GitHub https://pretalx.com/juliacon2024/talk/XXNT9W/ https://pretalx.com/juliacon2024/talk/XXNT9W/feedback/ For Loop (3.2) Lightning talk 2024-07-12T15:50:00+02:00 15:50 00:10 LASDatasets.jl is a newly open-sourced Julia package that provides a central interface for manipulating LAS (LASer) data files in Julia. LAS is a file format that stores point clouds with different types of features (e.g. intensity, colour) and is widely used across industry and research. Join us as we discuss the LAS data format and how we have combined and built upon the best features of existing LAS processing Julia packages to give a central interface for all your LAS processing needs. juliacon2024-43541-lasdatasets-jl-a-centralised-package-for-handling-las-data Data Science and Dynamics Ben CurranDr. Megan Dawson en LiDAR technology is used to capture real-life assets as point clouds, which are collections of 3D points that have additional attributes such as intensity, colour, return index etc. The LAS file format is a system of storing these (often large) groups of points and their metadata in a structured way, and has a compressed format, LAZ, to increase storage capacity. LAS stores points according to one of a set of predefined “point formats”, which specifies the metadata you assign to each point and their data type. On the one hand, this makes sure your point cloud data is stored and typed properly, but on the other it makes the process of converting from Julia-native structures such as Tables or DataFrames quite difficult, since as a user you need to handle the data types yourself. Although there are some great Julia packages that handle LAS data (such as LasIO.jl and LazIO.jl), there is no central entry point through which a user can simply read or write their LAS data to or from Julia without having to explicitly handle some of the data considerations themselves (e.g. whether the file is compressed, what point format it’s in, etc.). Furthermore, these packages don’t support all ten of the specified LAS Point Formats on offer. It is for this reason that we have further developed LAS.jl. We have used LAS.jl extensively in our LiDAR processing at Fugro, and so have ensured that it is both flexible and computationally efficient. In this talk, we will discuss the high-level user interface of LASDatasets.jl and some examples of reading and writing data. We will then explore the underlying systems we use to parse Julia structures into correctly typed and formatted LAS data. Finally, we will outline some future opportunities for improving this package both in terms of user experience and computational performance. You can find the code for the package here: https://github.com/fugro-oss/LASDatasets.jl false Slides https://pretalx.com/juliacon2024/talk/CJQNU7/ https://pretalx.com/juliacon2024/talk/CJQNU7/feedback/ For Loop (3.2) Talk 2024-07-12T16:00:00+02:00 16:00 00:30 Light based tomographic 3D printing is a new emerging field requiring the optimization of large scale optical problems. Simulating and optimizing parameters of those problems needs high performance packages, which we develop in Julia Lang. The implementation features CUDA acceleration (partially based on KernelAbstractions.jl) and automatic differentiation capabilities. We talk about ray tracing based methods such as the Radon transform but are also going to cover the wave nature of light. juliacon2024-40177-wave-and-ray-optics-for-light-based-tomographic-3d-printing Physics & Quantum Chemistry Felix Wechsler en The presented notebook is available here: https://github.com/roflmaostc/TalkJuliaCon2024 Our work is mainly scattered in four packages: RadonKA.jl [1], DiffImageRotation.jl [2], WaveOpticsPropagation.jl [3], SwissVAMyKnife.jl [4]. The first package features a very simple but still quite fast implementation of the Radon and inverse Radon transform based on KernelAbstractions.jl. In principle this allows to run it on multiple hardware accelerators such as CUDA.jl or AMDGPU.jl. Notably, we implemented an exponential Radon transform which is not implemented in any of the existing solutions (ASTRA, TIGRE, Matlab). The second package offers a differentiable image rotation routine implemented in KernelAbstractions.jl. According to benchmarks, it is the fastest image rotation routine in Julia. It features CUDA support and is automatic differentiation compatible. The third package is WaveOpticsPropagation.jl which is partially based on the archived PhysicalOptics.jl [5]. It provides routines to solve wave optical propagations efficiently. Notable features are the (scalable) angular spectrum method [6] or the Fraunhofer diffraction propagation. Those routines are highly memory efficient by cleverly using memory buffers and have implemented adjoints for automatic differentiation. Finally, SwissVAMyKnife.jl bundles those packages together to provide user-friendly routines to solve optimization problems connected to Tomographic Volumetric Additive Manufacturing (TVAM) [7]. TVAM is a novel light based 3D printing technique allowing to print centimeter scale objects in seconds to minutes. At submission date of this proposal, SwissVAMyknife.jl is not public available yet. By the date of JuliaCon we expect to have uploaded an arXiv paper about the details behind this package and make it publicly available. [1]: https://github.com/roflmaostc/RadonKA.jl [2]: https://github.com/roflmaostc/DiffImageRotation.jl [3]: https://github.com/JuliaPhysics/WaveOpticsPropagation.jl [4]: https://github.com/EPFL-LAPD/SwissVAMyknife.jl [5]: https://github.com/JuliaPhysics/PhysicalOptics.jl [6]: https://opg.optica.org/optica/fulltext.cfm?uri=optica-10-11-1407&id=541154 [7]: https://www.nature.com/articles/s41467-020-14630-4 false https://pretalx.com/juliacon2024/talk/WEXWEJ/ https://pretalx.com/juliacon2024/talk/WEXWEJ/feedback/ For Loop (3.2) Talk 2024-07-12T16:30:00+02:00 16:30 00:30 Transducers.jl was a brilliant and ambitious julia project that is in danger of stalling out. In this talk, I want to discuss what made it so special, the challenges involved in maintaining it today, and our plans for how to breathe new life into the package. juliacon2024-44286-what-s-next-for-transducers-jl General Mason Protter en [Transducers.jl](https://github.com/JuliaFolds2/Transducers.jl) is a package concerned with decoupling the traversal of a piece of data from various transformations one might apply to that data, and provides a more efficient, composable, and reusable alternative to things like `Iterators` or simple `for` loops. While Transducers.jl is based heavily off of the concepts [pioneered and implemented in Clojure](https://clojure.org/reference/transducers), Transducers.jl has a lot of ideas of it's own, including a very powerful and general approach to parallelism, and inventing a lot of useful techniques in preserving type stability in very difficult circumstances. Today, maintaining Transducers.jl is a very difficult task, namely because the current maintainers are not the original authors of the majority of the code, and the project is not only quite large, but it contains a lot of highly non-obvious techniques. In this talk, I want to give users an introduction to using Transducers.jl, as well as show a bit about our plans for the next generation of transducers in Julia. false https://pretalx.com/juliacon2024/talk/FJMTXH/ https://pretalx.com/juliacon2024/talk/FJMTXH/feedback/ Function (4.1) Lightning talk 2024-07-12T10:10:00+02:00 10:10 00:10 This talk will introduce the OpenPolicyAgent.jl package, which makes integrating OPA (Open Policy Agent), a general purpose policy engine, with any Julia application easy. OPA provides a high-level declarative language that allows policy to be specified as code, and an engine that can offload policy decision-making over API calls to the OPA engine. It is the industry standard in open source policy agents, and has a wide range of tools and integrations available for use. juliacon2024-44131-policy-enforcement-in-julia-enterprise-applications-with-opa General Tanmay Mohapatra en OPA is a general purpose open source policy engine that unifies policy enforcement across the application stack. OPA provides a high-level declarative language that allows policy to be specified as code, and an engine that can offload policy decision-making over API calls to the OPA engine. OPA can be used to enforce policies in microservices, Kubernetes, CI/CD pipelines, API gateways, and more. This talk will introduce the OpenPolicyAgent.jl package, which makes integrating OPA with any Julia application easy. It will demonstrate how to use the packaged server module to run the OPA engine as a sidecar, and how to use the Julia client APIs to interface with the engine. OPA also allows partial evaluation of policy rules, resulting in a simplified AST that can be used for further processing in applications. OpenPolicyAgent.jl exposes a generic way to walk over the AST, and allows code to be plugged into that. For example the AST resulting from partially evaluating policies related to database tables can be used to generate SQL query conditions. OpenPolicyAgent.jl includes a plugin that can generate such SQL query conditions from partially evaluated policies. Durnig the talk we shall walk through examples that use this too. false https://pretalx.com/juliacon2024/talk/GMVY9N/ https://pretalx.com/juliacon2024/talk/GMVY9N/feedback/ Function (4.1) Lightning talk 2024-07-12T10:20:00+02:00 10:20 00:10 `ExponentialFamilyManifolds.jl` efficiently tackles non-conjugate inference in probabilistic models by projecting distributions onto exponential families using Kullback-Leibler divergence optimization. Integrating with `Manifolds.jl`, `Manopt.jl`, and `RxInfer.jl`, it enhances scalability and inference efficiency, especially in models with conjugate and non-conjugate elements. This makes inference with exponential family priors both efficient and flexible. juliacon2024-43882-exponentialfamilymanifolds-jl-advancing-probabilistic-modeling General Mykola LukashchukBert de Vries en Probabilistic modeling (also known as Bayesian modeling) is a vital tool for contemporary data scientists, enabling them to process information about complex real-world processes accurately. A significant computational challenge in this field is the use of non-conjugate priors. While these priors may increase model accuracy in principle, they also complicate the inference process. For example, we may choose to model consumption as a log-linear function of household income for a household consumption model. In a Bayesian context, this function is known as the likelihood function, which needs to be paired with a prior distribution for the income. The conjugate prior distribution is a log-normal distribution over income. Bayesian inference with conjugate distributions leads analytically to the same distribution for both the prior and posterior. The Julia package `RxInfer.jl`, based on message passing in a factor graph, is a fast-executing inference toolbox that excels at inference for models with conjugate distribution pairs. However, given the high variability and possible uncertainties about personal data such as income, a gamma distribution prior might be a more suitable prior for income data. Unfortunately, the gamma prior is non-conjugated with the log-linear likelihood function. This leads to a posterior that is not Gamma-distributed and consequently to a computationally (much) more complex inference problem. In those cases, the general-purpose inference package `Turing.jl`, based on black-box variational inference and Monte Carlo sampling, will likely be able to handle the inference task. Still, scalability issues often arise, particularly for large datasets and/or large models. Thus, we have a computational trade-off at the heart of Bayesian modeling: we want both accurate model assumptions and a tractable inference process, but these preferences often conflict. The `ExponentialFamilyManifolds.jl` (EFM) package addresses this limitation by significantly extending the range of tractable models for message passing-based inference protocols as implemented by `RxInfer.jl`. Due to the modularity of message passing-based inference, EFM-enhanced `RxInfer.jl` inherits all the efficiencies of analytical closed-form message update rules for conjugate distribution pairs. EFM tackles the issue of local non-conjugate distribution pairs by projecting the product of the likelihood (e.g., log-normal) and the non-conjugate prior (e.g., gamma) in a manner that preserves conjugacy with other model components (gamma in our scenario). Technically, EFM efficiently projects generic distributions onto a specified exponential family distribution through Kullback-Leibler divergence optimization. This process is enhanced through the use of `Manifolds.jl` and `Manopt.jl`, both robust Julia ecosystem packages. In short, the proposed EFM-enhanced Bayesian inference approach leads to a much wider usable range of tractable models in probabilistic modeling problems. false GitHub https://pretalx.com/juliacon2024/talk/9JHYJE/ https://pretalx.com/juliacon2024/talk/9JHYJE/feedback/ Function (4.1) Talk 2024-07-12T10:30:00+02:00 10:30 00:30 Over the past years, Enzyme.jl has developed into a popular and fast tool for automatic differentiation (AD) in Julia. Basic Linear Algebra Subroutines (BLAS) on the other hand have been around for decades, are highly optimized, and are automatically called by Julia to handle your Matrix and Vector operations. Sounds like Enzyme and BLAS would be an awesome combination, right? Except when things fall apart. In this talk, we show what went wrong and how we fixed it. juliacon2024-44317-blasphemy General Manuel Sebastian Drehwald en BLAS and Lapack routines have been optimized for decades, and are widely used in numerical and machine learning code throughout the Julia ecosystem. Unfortunately, Enzyme.jl can’t handle their black-box implementations — so we just replaced their implementation with a generic openBLAS fallback, we hope you don’t mind! And since we are already at it, we also hardcoded the number of threads for this BLAS implementation to one, since multithreading is complex and we want to protect you from race conditions. Speaking about correctness, when differentiating our fallback we noticed that gradients could be wrong, but at least only for irrelevant scalars like 0.0 or 1.0 — nobody cares about those, right? Although this approach “works”, it feels like there must be something faster and more reliable to do here. In this talk, we showcase improvements to Enzyme’s BLAS handling using LLVM’s code-generation capabilities (tablegen) to generate efficient differentiation rules for low-level BLAS calls while leveraging Enzyme’s ability to work within the compiler. These improvements increase BLAS AD performance by up to 64x, avoid crashes with large matrices, and allow supporting your favorite hardware-specific, multithreaded BLAS libraries. We also discuss ongoing work to improve performance even further via tricks such as memory management optimization, and the benefit of these improvements on downstream Julia applications. false https://pretalx.com/juliacon2024/talk/QJM9NT/ https://pretalx.com/juliacon2024/talk/QJM9NT/feedback/ Function (4.1) Talk 2024-07-12T11:00:00+02:00 11:00 00:30 We describe the role of Julia in the TU Delft master course EE4375 entitled “Finite Element Method in Electrical Engineering Applications”. We furthermore describe how in two project-based assignments of EE4375 we talk to industrial partners. In the first project, we collaborate with the distribution system operator STEDIN Rotterdam to investigate the aging on transformer substations. In the second project, we join forces with TNO to model the magnetic signature of naval ships. juliacon2024-44291-finite-element-modeling-of-magnetic-fields-in-julia Physics & Quantum Chemistry Domenico Lahaye en We describe the TU Delft master course EE4375 entitled “Finite Element Method in Electrical Engineering Applications”. The course material is available at github.com/ziolai/finite_element_electrical_engineering . The course is spread over seven weeks. Each week, the students attend two hours of lectures and take part of four hours of lab sessions. The lectures introduce a set of mathematical models for electric and magnetic fields. The lab sessions allow the students to implement these models in Julia. We also discuss two project-based assignments of EE4375 in which we collaborate with industrial partners. In the first student project, we collaborate with the distribution system operator STEDIN Rotterdam to model the effect of new components in the infrastructure for energy distribution. Examples of such components are solar panels, electrical vehicles and batteries. These new components are expected to generate harmonics at larger frequency than the base frequency of 50 Hz. Without proper counter measures, these higher frequencies are expected to cause damage to the existing infracstructure. The goal of the project is to predict the effect of higher harmonics on the aging of distribution substations. This will allow to design suitable counter-measures. In the second student project, we join forces with TNO to solve integro-differential equations to describe the magnetic signature of naval ships. This information will allow to design a system of current-carrying coils on board the ship that renders the ship neutral for disturbances in the earth magnetic field. false Presentation slides https://pretalx.com/juliacon2024/talk/XBDF7H/ https://pretalx.com/juliacon2024/talk/XBDF7H/feedback/ Function (4.1) Lightning talk 2024-07-12T11:40:00+02:00 11:40 00:10 RayTraceHeatTransfer.jl enables the user to quickly quantify radiative heat transfer in a user defined enclosure containing a gas which scatters, emits and absorbs radiation. The package implements a combination of two approaches: 1) Several photon bundles are traced throughout the domain to quantify the 'connectivity' of the enclosure. 2) Matrix algebra allows for subsequent quick solution of heat transfer problems yielding the temperature distribution and heat fluxes of the domain. juliacon2024-44447-raytraceheattransfer-jl-2d-enclosure-radiative-heat-transfer Physics & Quantum Chemistry /media/juliacon2024/submissions/NLAD8B/temperaturedistribution_random_noise_tnNj509.png Nikolaj Maack Bielefeld en Radiation occurs everywhere at all times. In high temperature environments it can be the dominant mode of heat transfer. It is highly relevant to climate sciences. In engineering it is especially relevant to aerospace and space exploration for propulsion while also being crucial in power generation and boiler design. Solving heat transfer problems involving combustion is notoriously difficult, partly because the combustion products participate in the radiative heat transfer. The added complexity of a participating medium is described by the Radiative Transfer Equation (RTE) which is an integro-differential equation in seven independent variables: three spatial, one temporal, two directional and one spectral. RayTraceHeatTransfer.jl solves the RTE (neglecting temporal and spectral dependencies) in a user defined geometry. As the first step the user specifies the bounding geometry. The geometry is then meshed into the desired resolution. Next, Monte Carlo ray tracing is performed by sampling ray emissions from every zone in the geometry and following the ray bundles throughout the domain. The points of emission and absorption are recorded in four Exchange Factor matrices. These matrices describe the 'connectivity' of the domain for the specified properties of the participating medium. Using the Exchange Factor matrices heat transfer problems can be solved efficiently using a variation of the Zonal Method, without the need for repeated ray tracing in the same geometry. In order to solve the heat transfer problem, either a temperature or a heat flux must be specified for each element in the geometry (surface or volume). Then the solution to the heat transfer problem returns the remaining temperatures and heat fluxes. As a last feature of the package the user can automatically measure the validity of the solution in a square domain against the analytical solution of the RTE of Crosbie and Schrenker (1982). false RayTraceHeatTransfer.jl GitHub Slides https://pretalx.com/juliacon2024/talk/NLAD8B/ https://pretalx.com/juliacon2024/talk/NLAD8B/feedback/ Function (4.1) Lightning talk 2024-07-12T11:50:00+02:00 11:50 00:10 The sixth annual Julia User & Developer Survey will survey 1,000+ Julia users and developers about their reasons for choosing Julia, how and why they use Julia, barriers to wider adoption, favorite packages, demographics and more. juliacon2024-39779-julia-user-developer-survey-2024 Community Andrew Claster en The sixth annual Julia User & Developer Survey will survey 1,000+ Julia users and developers about their reasons for choosing Julia, how and why they use Julia, barriers to wider adoption, favorite packages, demographics and more. false https://pretalx.com/juliacon2024/talk/RDL3SE/ https://pretalx.com/juliacon2024/talk/RDL3SE/feedback/ Function (4.1) Talk 2024-07-12T12:00:00+02:00 12:00 00:30 This is an update on the [density-functional toolkit (DFTK)](https://dftk.org), a density-functional theory code modelling the electronic properties of materials. Since our 2021 talk substantial progress has been made to enhance the code's features and integrations both within the Julia ecosystem as well as key domain-specific packages such as the [AiiDA](https://www.aiida.net/) workflow engine. Examples illustrate the code's use as a platform supporting researches from multiple disciplines. juliacon2024-43222-dftk-jl-5-years-of-a-multidisciplinary-electronic-structure-cod Physics & Quantum Chemistry Michael F. Herbst en Simulating the electronic structure of matter using density-functional theory (DFT) is an established approach in the chemical and physical sciences. On major supercomputers about 30% of the computational time are spent just on DFT simulations. At this scale the importance to improve efficiency and robustness of simulation algorithms cannot be overstated. This frequently requires a multidisciplinary effort involving fields such as mathematics, computer science, physics and materials science. With DFTK we aim to provide a software platform exactly to foster such cross-disciplinary research. In this talk we look back to 5 years of DFTK with over 30 contributors. We sketch the design of our package and illustrate our integration with both the Julia ecosystem (CUDA, ForwardDiff, AtomsBase) as well as standard high-throughput workflow engines from the application domain. In the past this has been used both to propose novel numerical schemes with strong mathematical guarantees as well as perform in-depth verification testing of DFTK against other more established packages of the field, such as QuantumESPRESSO. Both mathematical exploration on simplified models as well as state-of-the-art application simulations can thus be performed with DFTK, making it the ideal code for prototyping novel first-principle simulation approaches. false GitHub Code (Notebook) Slides https://pretalx.com/juliacon2024/talk/WRQE3H/ https://pretalx.com/juliacon2024/talk/WRQE3H/feedback/ Function (4.1) Talk 2024-07-12T14:00:00+02:00 14:00 00:22 The rapidly increasing amount of data in the geosciences requires new tools and workflows to processing them, along with software to modelling the physics of the governing processes. Julia offers a great basis for this by combining the benefits of a high-level language, such as ease of use and interactivity, with the features of a low-level language, including speed, efficiency, scalability, and native GPU support. juliacon2024-50341-developing-supercomputing-geoscience-applications-using-julia Julia for High-Performance Computing Ludovic RässBoris Kaus en Here, we will present recent efforts to accelerate geocomputing using Julia at scale. These efforts are supported by the PASC-funded [GPU4GEO project](https://ptsolvers.github.io/GPU4GEO/), in collaboration with the Swiss National Supercomputing Centre CSCS. Rather then creating a single monolithic code, we developed a modular approach creating packages, such as [GeophysicalModelGenerator.jl](https://github.com/JuliaGeodynamics/GeophysicalModelGenerator.jl) which can be used to create initial model configuration from a range of datasets, [GeoParams.jl](https://github.com/JuliaGeodynamics/GeoParams.jl) which includes expressions for material parameters and constitutive relationships and [JustPIC.jl](https://github.com/JuliaGeodynamics/JustPIC.jl), which provides a particle-in-cell advection framework on (multi-) GPUs. The advantage is a composable framework where, for example, new material parameters only have to be added in a single location and can immediately be employed in a range of codes. This greatly lowers the barrier of new users to contribute to the open source packages, compared to much larger monolithic code bases. Application codes that use part of this functionality are [MagmaThermoKinematics.jl](https://github.com/boriskaus/MagmaThermoKinematics.jl), which simulate the thermal evolution of magmatic systems, [JustRelax.jl](https://github.com/PTsolvers/JustRelax.jl) which provides a number of examples of geodynamic applications such as mantle convection or subduction of tectonics plates, and [FastIce.jl](https://github.com/PTsolvers/FastIce.jl) which is a 3D ice flow code. We will showcase how these HPC building blocks enables geoscientists to write high-performance stencil codes that can scale from their laptops to the largest GPU-accelerated supercomputers. We will also demonstrate preliminary results on using automatic differentiation to perform inverse modelling and discuss how these recent developments, along with future ones, will accelerate geocomputing and enable the education of the next generation of geoscientists. false https://pretalx.com/juliacon2024/talk/GTGCH7/ https://pretalx.com/juliacon2024/talk/GTGCH7/feedback/ Function (4.1) Talk 2024-07-12T14:22:00+02:00 14:22 00:22 CliMA's Earth System Model (ESM) is designed to automatically learn from diverse data sources, such as global observations and targeted high-resolution simulations, to reduce and quantify uncertainties in climate predictions. The components of the ESM software stack include an atmosphere model, a radiation model, a land model, a coupler, among others. juliacon2024-50471-portable-communications-interface-for-earth-system-model Julia for High-Performance Computing Sriharsha Kandala en CliMA's Earth System Model (ESM) is designed to automatically learn from diverse data sources, such as global observations and targeted high-resolution simulations, to reduce and quantify uncertainties in climate predictions. The components of the ESM software stack include an atmosphere model, a radiation model, a land model, a coupler, among others. [ClimaComms.jl](https://github.com/CliMA/ClimaComms.jl) provides the high-level communications interface and computational backend for various components of the ESM software stack. This talk describes some of the most expensive communication patterns encountered in the atmospheric solver (Direct Stiffness Summation), and how the communication interface is implemented to provide support for various computational backends (single-threaded/multi-threaded CPUs, GPUs) and transports (Serial, MPI), thereby enabling the user to run distributed simulations on a wide range of architectures. false https://pretalx.com/juliacon2024/talk/ZP8E9H/ https://pretalx.com/juliacon2024/talk/ZP8E9H/feedback/ Function (4.1) Talk 2024-07-12T14:44:00+02:00 14:44 00:22 We present a new approach to transition seamlessly and with unprecedented effectiveness from a single-CPU-core Python prototype to a Julia application that is deployable on distributed GPUs. During porting of the Python prototype to Julia, the approach enables concurrent interactive stepwise execution of both codes and systematic verification almost line by line. juliacon2024-50340-seamless-transition-from-single-core-python-to-julia-multi-gpu Julia for High-Performance Computing Samuel Omlin en Check points for correctness can be straightforwardly defined for ported and verified code blocks in order to later automatically signal potential issues that manifest due to refactoring work or consideration of new input classes. We have demonstrated the approach's effectiveness in a real-world use case, a collaboration between domain scientists and HPC experts in the scope of Europe's Human Brain Project (HBP). Based on a single-CPU-core Python prototype developed by the domain scientists, we have jointly created a Julia application for Bayesian optimization of hyper-parameters of a neurological network that is deployable on the world's largest GPU supercomputers and achieves near optimal performance and scaling. Furthermore, as a result of the automatic correctness verification, the domain scientists - with no previous Julia experience - could quickly gain confidence in the ported Julia application, which is an important aspect in HPC collaboration projects as the presented one. The Julia application serves the domain scientists now also for further prototyping: leveraging [ParallelStencil.jl](https://github.com/omlins/ParallelStencil.jl) has made it feasible to fully unify prototyping and production in a single code that is deployable on a single CPU core or thousands of GPUs. false https://pretalx.com/juliacon2024/talk/N779AY/ https://pretalx.com/juliacon2024/talk/N779AY/feedback/ Function (4.1) Talk 2024-07-12T15:06:00+02:00 15:06 00:22 In this talk we will discuss recent changes in the [CUDA.jl](https://github.com/JuliaGPU/CUDA.jl) and [oneAPI.jl](https://github.com/JuliaGPU/oneAPI.jl) packages, which provide GPU programming capabilities in Julia. juliacon2024-50342-updates-and-advances-in-cuda-jl-and-oneapi-jl Julia for High-Performance Computing Tim Besard en We will cover the latest features, performance improvements, and future directions for these packages. false GitHub GitHub Slide deck https://pretalx.com/juliacon2024/talk/GGQFJR/ https://pretalx.com/juliacon2024/talk/GGQFJR/feedback/ Function (4.1) Talk 2024-07-12T15:40:00+02:00 15:40 00:22 Task parallelism is a simple but powerful method to make programs and libraries scalable, but which task parallel library you choose greatly affects how well and far your code can scale. In this talk, we will discuss the [Dagger.jl](https://github.com/JuliaParallel/Dagger.jl) package, which implements a variety of powerful abstractions on top of a high-performance, heterogeneous task parallel core. juliacon2024-50348-applications-of-distributed-task-parallelism Julia for High-Performance Computing Julian P Samaroo en We will compare Dagger to other task parallel frameworks (like Dask, Kokkos, Legion, etc.), as well as to libraries which express parallelism in other ways ([ImplicitGlobalGrid.jl](https://github.com/eth-cscs/ImplicitGlobalGrid.jl), [JACC.jl](https://github.com/JuliaORNL/JACC.jl), etc.), to see the similarities and differences. Finally, we will discuss why these differences, and the features and abstractions that only Dagger provides, makes Dagger a great choice for scaling code efficiently and in a more maintainable manner. false https://pretalx.com/juliacon2024/talk/XJFGYJ/ https://pretalx.com/juliacon2024/talk/XJFGYJ/feedback/ Function (4.1) Talk 2024-07-12T16:02:00+02:00 16:02 00:22 With [libtrixi](https://github.com/trixi-framework/libtrixi) we present a blueprint for connecting established research codes to modern software packages written in Julia without sacrificing performance. Specifically, [libtrixi](https://github.com/trixi-framework/libtrixi) provides an API to [Trixi.jl](https://github.com/trixi-framework/Trixi.jl), a Julia package for adaptive numerical simulations of conservation laws. juliacon2024-50343-libtrixi-serving-legacy-fortran-codes-with-simulations-in-julia Julia for High-Performance Computing Benedict Geihe en In computational fluid dynamics a broad range of spatial and temporal length scales has to be considered, rendering finely resolved computational grids indispensable and calling for high-performance computing techniques. Consequently, many simulation libraries are written in traditional HPC languages, which offer high performance, but are complex to learn and maintain. Julia often acts as a glue code to enable the reuse of such libraries. With [libtrixi](https://github.com/trixi-framework/libtrixi), we reverse this workflow: The computational fluid dynamics (CFD) solver [Trixi.jl](https://github.com/trixi-framework/Trixi.jl) is controlled from a main program written in C, C++, or Fortran. This allows one to take advantage of Julia's rapid prototyping capabilities and its performance. In this talk, we will provide some insights into the Julia C API and the [PackageCompiler.jl](https://github.com/JuliaLang/PackageCompiler.jl) project. We will show numerical applications in earth system modeling, controlled by a Fortran code and running in parallel using MPI. false libtrixi slides https://pretalx.com/juliacon2024/talk/SXC7LA/ https://pretalx.com/juliacon2024/talk/SXC7LA/feedback/ Function (4.1) Talk 2024-07-12T16:24:00+02:00 16:24 00:22 We present [SeismicWaves.jl](https://gitlab.com/JuliaGeoph/SeismicWaves.jl), a package for 1D, 2D, and 3D wave simulations on multi-xPUs. [SeismicWaves.jl](https://gitlab.com/JuliaGeoph/SeismicWaves.jl) supports forward and adjoint simulations to compute gradients with respect to model parameters for Full-Waveform Inversion (FWI) methods used in seismic tomography. juliacon2024-50346-seismicwaves-jl-a-wave-simulation-package-for-fwi-on-multi-xpus Julia for High-Performance Computing /media/juliacon2024/submissions/TGQYQX/SWlogo_eYbY2uq.svg Giacomo Aloisi en The package is based on finite-difference methods for solving the wave equation in parallel and distributed systems using [ParallelStencil.jl](https://github.com/omlins/ParallelStencil.jl) and [ImplicitGlobalGrid.jl](https://github.com/eth-cscs/ImplicitGlobalGrid.jl), enabling seamless multi-xPU computing. Rigorous benchmarks and synthetic inversions validate the solvers' correctness while achieving high memory throughput (up to 90% of peak) on modern GPUs and exhibiting good weak scaling on distributed systems. In conclusion, [SeismicWaves.jl](https://gitlab.com/JuliaGeoph/SeismicWaves.jl) provides easy-to-use and efficient solvers to bridge the gap between theory and practice for a variety of FWI applications and use cases, from fast prototyping on a laptop to high-resolution, large-scale simulations on supercomputing clusters. false Presentation Slides https://pretalx.com/juliacon2024/talk/TGQYQX/ https://pretalx.com/juliacon2024/talk/TGQYQX/feedback/ Function (4.1) Talk 2024-07-12T16:46:00+02:00 16:46 00:22 The growth of computational power driven by novel accelerator architectures has pushed physics solvers to transition from their traditional multi-CPU approach to GPU-ready codebases. Moreover, the integration of data-driven models, and in particular machine learning (ML), into physics solvers limits the choice of programming languages that can natively offer both speed and such high-level libraries. juliacon2024-50347-a-fast-and-flexible-cfd-solver-with-heterogeneous-execution Julia for High-Performance Computing /media/juliacon2024/submissions/8HJNAQ/monarch_70Evnzh.gif Gabriel WeymouthBernat Font en In this talk, we will review how [WaterLily.jl](https://github.com/weymouth/WaterLily.jl), a computational fluid dynamics Julia solver, has been ported from its original serial-CPU implementation to a backend-agnostic solver that can be seamlessly executed using multi-threading in CPUs or in GPUs of different vendors. The transition has been accomplished using a meta-programming approach that generalizes the implementation of array iterators while also relying on [KernelAbstractions.jl](https://github.com/JuliaGPU/KernelAbstractions.jl) to specialize each kernel on the target architecture. In single-GPU tests, we show that [WaterLily.jl](https://github.com/weymouth/WaterLily.jl) is as fast as state-of-the-art CFD solvers written C++ or Fortran. Finally, we also discuss the potential of integrating ML models and differentiability into the solver. false GitHub https://pretalx.com/juliacon2024/talk/8HJNAQ/ https://pretalx.com/juliacon2024/talk/8HJNAQ/feedback/ While Loop (4.2) Lightning talk 2024-07-12T10:10:00+02:00 10:10 00:10 There is no native Julia geometry package equivalent to Python’s Shapely or R’s sf. The driving idea behind GeometryOps.jl is to unify existing native geometry packages, develop functionalities that only exist in non-native wrapper packages, and make algorithms usable with various geometric representations through GeoInterface.jl. Initial benchmarks show speedups over widely used wrapper library LibGEOS.jl: 2x for polygon area, 7x for polygon intersection, and 10x for point-to-polygon distance. juliacon2024-44387-geometryops-jl-building-a-comprehensive-native-geometry-package General /media/juliacon2024/submissions/B89G9K/logo_yotuxC3.png Rafael SchoutenSkylar GeringAnshul Singhvi en Julia’s Geo and Geometry ecosystems lack a comprehensive, native package for standard geometric algorithms for spatial data. The most comprehensive option is LibGEOS.jl, the Julia wrapper of C library GEOS. However, use of LibGEOS.jl comes with performance drawbacks when calling C functions and creating C objects. On the other hand, the native Julia ecosystem is made up of a collection of disparate packages, many focusing on implementing specific geometric algorithms to solve targeted questions rather than general functionality. Additionally, there are numerous Julia representations of common geometries, with many of the native algorithms only working with specific representations. To address these problems, we have created GeometryOps.jl, which seeks to unify the disparate packages and algorithms for geometric calculations in Julia and make them GeoInterface.jl-compatible. In time, this package could come to replace LibGEOS.jl. For implemented algorithms, GeometryOps.jl already provides substantial performance improvements over LibGEOS.jl when using native geometry objects. false Slides https://pretalx.com/juliacon2024/talk/B89G9K/ https://pretalx.com/juliacon2024/talk/B89G9K/feedback/ While Loop (4.2) Lightning talk 2024-07-12T10:20:00+02:00 10:20 00:10 EverySingleStreet.jl is a project to track your exploration status of your city of choice. Discovering new parts of a city can expand your horizon. To keep track of this endeavour EverySingleStreet.jl is helping out behind the scenes such that you don't miss a single street. In this talk I'll tell you about how to map GPS data points to actual streets as well as using a small web server to communicate with Strava all done to creating an art project of your progress. juliacon2024-44333-everysinglestreet-jl-explore-your-city-using-julia General /media/juliacon2024/submissions/UWWKWQ/ESS_YmuhDUq.jpg Ole Kröger en Living in a city for a while with the same home and same workplace often results in taking the same route to work and having only a couple of different routes for a sunny weekend walk. Why not explore more of the area you live in? Maybe even take it to the extreme and walk all of it. That's how this project came to be over a year ago. Exploring the whole of Hamburg, Germany on foot. A project that needs to be well planned and tracked. Software exists for everything so of course there are projects that help you out already. Though they all didn't meet my personal needs and maybe I just wanted to learn even more how to set up something like this myself. That's why I created the EverySingleStreet.jl project to apply map matching to the GPS points I get via the Strava app, create my own map and display it using the OSMAnd app and much more. The attached image shows my progress plotted by a pen plotter after one year of trying to walk every single street of Hamburg, Germany. So far 28% done! false GitHub Presentation https://pretalx.com/juliacon2024/talk/UWWKWQ/ https://pretalx.com/juliacon2024/talk/UWWKWQ/feedback/ While Loop (4.2) Talk 2024-07-12T10:30:00+02:00 10:30 00:30 BestieTemplate.jl is a template for creating packages following opinionated package development practices. It can be used via Julia or as a Copier template. The main advantages of a Copier template are that it allows applying a template to an existing repository and reapplying a template in order to get the updates since that last template application. The template serves as a snapshot of what are the current package development best practices, and will be updated when more tools are avaiable. juliacon2024-44274-best-practices-for-package-development-using-bestietemplate-jl Julia Internals and Tooling /media/juliacon2024/submissions/9AMPUD/logo_hpK8u8b.png Abel Soares Siqueira en BestieTemplate.jl is a template for the engine Copier (https://copier.readthedocs.io/en/stable/). It contains opinionated software development best practices that we adopt in some of our packages. These include traditional Julia package requirements, such as a src, test and docs folder structure, README and LICENSE files, GitHub workflows for testing, documentation, CompatHelper and TagBot. However, it also includes other best practices, such as linting and formatting specification files, pre-commit hooks, and CITATION.cff files. BestieTemplate.jl can be applied and reapplied to existing packages, as supported by Copier. This means that the best practices can be updated in the template and propagated to packages using it. This solves issues with outdated practices and also allows older packages to improve their package very quickly. BestieTemplate.jl is also a Julia package. As a package, it wraps some functionalities of Copier to allow users to use the template without having to install Copier directly. false GitHub Slides https://pretalx.com/juliacon2024/talk/9AMPUD/ https://pretalx.com/juliacon2024/talk/9AMPUD/feedback/ While Loop (4.2) Talk 2024-07-12T11:00:00+02:00 11:00 00:30 Computer algorithms interacting with the physical world around them give rise to what is referred to as a sampled-data system, a system with both parts that evolve continuously in time and processes that have a discrete time evolution. In this talk, we detail a new tool for modeling and simulation of such systems. juliacon2024-40412-modeling-and-simulation-of-sampled-data-systems SciML Fredrik Bagge Carlson en Computers are inherently discrete, both in terms of how they represent numbers and in how they perform computations over time and thus update their state. Computers interacting with the environment often do so in an interval-based or event-based fashion, i.e., they compute and communicate in response to either an event or the tick of a clock. Examples of sampled-data systems include control systems, like the autopilot in an airplane, and digital signal-processing pipelines, like the acoustic noise-cancellation feature in a pair of headphones. Sampled-data systems occurring in complex engineering systems, like an airplane or a factory, may contain several distinct discrete-time partitions, each operating in response to its own event source, e.g., using different sample rates. Examples include hierarchical control systems such as a heat pump, where a fast “inner” controller operates the compressor at 1000Hz, while a slower “outer” controller provides commands to the compressor once every minute in order to maintain the desired temperature etc. Accurate analysis of such systems require simulation tools that can handle their mixed continuous-discrete nature. Differential-equation solvers often include mechanisms that allow simulation of sampled-data systems. However, manually modeling large such systems becomes intractable without support of a modeling tool. ModelingToolkit has proven a competent tool for the modeling of continuous-time systems, and here, we detail new capabilities to also model discrete-time processes. The extension of ModelingToolkit developed to support sampled-data systems introduces the notion of a clock, the source of events that triggers the execution of a discrete time partition. A model may contain one or several clocks operating at different periodic or aperiodic rates. Upon the tick of a clock, all associated discrete-time partitions are executed and the variables governing their interaction with the continuous-time world are updated. The interaction between discrete and continuous partitions is governed by new operators, such as `sample` and `hold`. The ability of ModelingToolkit to generate separate code for discrete-time partitions is also added to facilitate deployment of control algorithms onto a different computing platform. false GitHub Presentation slides https://pretalx.com/juliacon2024/talk/KGAKA8/ https://pretalx.com/juliacon2024/talk/KGAKA8/feedback/ While Loop (4.2) Lightning talk 2024-07-12T11:40:00+02:00 11:40 00:10 Practical identifiabilty based on Profile Likelihood is a crucial step in determining how well the parameters of a mechanistic model can be recovered from the experimental data. What packages are available to address this problem in Julia and what does Julia SciML community lack? How Profile likelihood-based methods can be applied to predictability analysis? The talk will cover the packages LikelihoodProfiler.jl, ProfileLikelihood.jl and the desirable improvements to Julia SciML ecosystem. juliacon2024-44261-profile-likelihood-based-practical-identifiability-in-julia SciML Ivan Borisov en Practical identifiability of Systems Biology models has received a lot of attention in recent scientific research. It addresses the crucial question of models’ reliability: how accurately can the parameters of the model be recovered from the available experimental data. Noisy or incomplete data result in uncertainty in parameters estimations typically described by confidence intervals and confidence regions. The methods based on profiling the likelihood function are among the most reliable and widely used approaches to estimate parameters’ confidence intervals and state their practical identifiability. The application of Profile Likelihood-based methods can also be extended to predictability analysis and confidence bands estimation. With the growing interest of Systems Biology community to Julia and SciML package ecosystem it is fair to ask what methods are available to address the problem of practical identifiability and predictability in Julia. The talk will present the problem of practical identifiability and propose an overview of available packages (LikelihoodProfiler.jl and ProfileLikelihood.jl) and the desirable improvements to Julia SciML ecosystem. false GitHub https://pretalx.com/juliacon2024/talk/MVFTEK/ https://pretalx.com/juliacon2024/talk/MVFTEK/feedback/ While Loop (4.2) Lightning talk 2024-07-12T11:50:00+02:00 11:50 00:10 It turns out that Julia tooling is very good at predicting thin-walled structure behavior, especially those packages in the SciML ecosystem. In this presentation, examples will be provided that show how Julia’s speedy, reliable, and accessible computational tools are advancing structural design capabilities and practices when it comes to bread-and-butter steel building systems that employ thin-walled structural components. juliacon2024-44470-steel-thin-walled-structural-analysis-and-design-with-julia SciML Cris Moen en It turns out that Julia tooling is very good at predicting thin-walled structure behavior, especially those packages in the SciML ecosystem. Most low and mid-rise buildings around the world have steel thin-walled structural components, in the roofs and walls and floors of hotels and condos and data centers. Thin-walled structures gain their strength and stiffness by being bent into complex shapes, and their behavior, including buckling deformation, are defined by systems of ordinary and partial differential equations. In this presentation, examples will be provided that show how Julia’s speedy, reliable, and accessible computational tools are advancing structural design capabilities and practices when it comes to bread-and-butter steel building systems that employ thin-walled structural components. false https://pretalx.com/juliacon2024/talk/CFAJWL/ https://pretalx.com/juliacon2024/talk/CFAJWL/feedback/ While Loop (4.2) Talk 2024-07-12T12:00:00+02:00 12:00 00:30 How does a population of interacting individuals evolve over time? This puzzling question has been a central focus across various disciplines, ranging from ecology to economics. In this presentation, I introduce the main approaches to model population dynamics and demonstrate how they can be easily implemented and analysed using existing Julia packages. juliacon2024-39899-modelling-population-dynamics-with-julia General Alejandra Ramirez en During the presentation, I demonstrate how DynamicalSystems.jl can be used to describe and analyse the evolution of populations through differential equations and time series analysis. Additionally, I explain how to model populations using an agent-based approach with Agents.jl, a versatile and robust framework for agent-based modelling. Overall, I showcase how to apply tools from existing Julia packages to understand the complex dynamics emerging from populations composed of interacting individuals. false https://pretalx.com/juliacon2024/talk/FZR3DL/ https://pretalx.com/juliacon2024/talk/FZR3DL/feedback/ While Loop (4.2) Minisymposium 2024-07-12T14:00:00+02:00 14:00 00:10 Using Julia for Earth and climate science has the potential to combine the best of both worlds: The speed of Fortran and the interactivity and productivity of Python, empowering users to be developers and developers to be users. In this minisymposium speakers will present software projects both from a user and a developer perspective. Talks are encouraged to discuss both use cases of existing software as well as the development of user-friendly software. juliacon2024-40445-earth-and-climate-science-in-julia-power-to-the-user Earth and climate science in Julia: Power to the user /media/juliacon2024/submissions/YXSPPR/precipitation2_g8w3VT9.png Milan KlöwerFrancesco MartinuzziSkylar GeringJordi Bolibar en Solving the two-language problem, Julia blurs the line between users and developers. Julia software in Earth and climate science often spans multiple aspects including models and their development, preparing and running simulations, data post-processing, analysis and visualisation. Users can easily extend packages, increasing the number of contributors, while developers enhance the user interface and experience within a unified language framework. At the same time, developers start to support other software packages and tools directly given the single language framework, further growing the ecosystem. Traditionally, Earth and climate science relied on Fortran for performance-critical software and, more recently, on Python for data analysis and visualisation. Unfortunately, this puts a divide between developers and users, at least partially counteracting the gained productivity through Python. Julia as an emerging language framework has allowed this community to rethink how to build software with and for users, of which we want to highlight efforts from both the developer but especially the user perspective. Overall we want to accelerate research on Earth and climate science, which not just depends on high-performance computing but particularly on the user interface being accessible, intuitive, interactive and extensible. We invite both developers and users, as well as individuals who bridge these roles, to discuss software projects and their impact on user empowerment. We also welcome talks by developer-user pairs highlighting the co-benefits from a combined perspective. For this minisymposium, we accept abstracts on every field in and adjacent to Earth and climate sciences, including but not limited to - Atmospheric sciences, including atmospheric dynamics, physics, chemistry and climatology - Oceanography including sea ice and ocean biogeochemistry - Earth science including land surface processes, hydrology and glaciology - Land vegetation and interactions of ecosystems with the climate - Geodynamics, seismology, geodesy and geochemistry - Human and physical geography - Climate policy and economics including integrated assessment models Talks can focus on software that solves equations, analyses or visualises data, processes measurements and especially software with any combination of the above. Talks on planetary sciences are equally welcome especially when they parallel the issues and opportunities to the fields mentioned. Schedule and confirmed talks (last updated 1 July) - 14:00 [Introduction](https://pretalx.com/juliacon2024/talk/YXSPPR/) - 14:10 [Hydrological modelling in Julia with Wflow.jl and Ribasim.jl](https://pretalx.com/juliacon2024/talk/MXMMSW/) - 14:20 [Multiobjective stochastic storage design of rainwater harvesting](https://pretalx.com/juliacon2024/talk/SXAMDV/) - 14:30 [High Resolution Flux Estimation with TurbulenceFlux.jl](https://pretalx.com/juliacon2024/talk/7LAYTN/) - 14:40 [SpeedyWeather.jl: Reinventing atmospheric models](https://pretalx.com/juliacon2024/talk/EP99CX/) - 14:50 [Oceananigans.jl: An ocean-flavoured fluid dynamics library](https://pretalx.com/juliacon2024/talk/BYQWXK/) - 15:00 [Subzero.jl Fast and Flexible Sea Ice Physics](https://pretalx.com/juliacon2024/talk/NC7JPQ/) - 15:10 [Subglacial water flow simulations on GPUs](https://pretalx.com/juliacon2024/talk/VKCYEK/) - 15:20 [ODINN.jl: Multi-language Geoscientific Machine Learning](https://pretalx.com/juliacon2024/talk/EPUXXU/) - 15:30 (10min break) - 15:40 [Strategies to Integrate Data and Biogeochemical models](https://pretalx.com/juliacon2024/talk/MZTRMN) - 15:50 [SpeciesDistributionModels.jl: an SDM workflow](https://pretalx.com/juliacon2024/talk/P88SPE/) - 16:00 [How Climate Economics Domain Experts Use an Embedded DSL](https://pretalx.com/juliacon2024/talk/9UWCXV/) - 16:10 [Visualization and analysis of 3D Lightning Mapping Array data](https://pretalx.com/juliacon2024/talk/79BGUS/) - 16:20 [Supporting development and operation of Scatterometers](https://pretalx.com/juliacon2024/talk/BPZJPP/) - 16:30 [Julia Community Reshapes Computation in Geosciences](https://pretalx.com/juliacon2024/talk/VHPZ7Z/) - 16:40 [Concluding discussion](https://pretalx.com/juliacon2024/talk/HSN88L/) until 17:00. Chairs - Skylar Gering (Caltech) - Francesco Martinuzzi (Leipzig) - Jordi Bolibar (Grenoble) - Milan Klöwer (MIT) false https://pretalx.com/juliacon2024/talk/YXSPPR/ https://pretalx.com/juliacon2024/talk/YXSPPR/feedback/ While Loop (4.2) Lightning talk 2024-07-12T14:10:00+02:00 14:10 00:10 We introduce two hydrological numerical models in Julia, developed at Deltares. Wflow is a distributed hydrological modelling platform, including different vertical and lateral concepts. Ribasim is a water resources model, solving the water balance equation for regional surface waters, allowing users to solve water allocation questions. We explain why we (re)wrote Wflow and Ribasim, which were originally coded in respectively Python and Fortran and discuss why we keep most processing in Python. juliacon2024-44386-hydrological-modelling-in-julia-with-wflow-jl-and-ribasim-jl Earth and climate science in Julia: Power to the user Martijn VisserMaarten Pronk en At Deltares, an applied research institute in the Netherlands, we (re)developed two open-source hydrological numerical models. Wflow is Deltares’ solution for modelling hydrological processes, allowing users to account for precipitation, interception, snow accumulation and melt, evapotranspiration, soil water, surface water and groundwater recharge in a fully distributed environment. Ribasim is a water resources model. It allows users to model basins under current and changing conditions to evaluate and design the water system. Julia solved the two-language problem for us. Wflow was originally written in Python, linked to an external C++ library (PCRaster). Rewriting in Julia yielded more freedom and performance. Ribasim was originally written in Fortran, and the move to Julia resulted in clearer, faster and less code, especially because we use the existing solvers from DifferentialEquations.jl and JuMP.jl. However, while Julia solved the two-language problem for numerical simulation software for us, bridging hydrologists and software-engineers, we find that most end-users/modellers stick to Python for scripting. We therefore decided to write most of the pre- and post-processing code in Python for now. We discuss what’s still needed in the Julia ecosystem to also take this hurdle. false GitHub GitHub Slides https://pretalx.com/juliacon2024/talk/MXMMSW/ https://pretalx.com/juliacon2024/talk/MXMMSW/feedback/ While Loop (4.2) Lightning talk 2024-07-12T14:20:00+02:00 14:20 00:10 A multi-objective stochastic optimization approach for sizing the storage of a rainwater harvesting system is presented, considering climate and demand uncertainty. The aim is to maximize system efficiency and minimize cost while satisfying all flow equations, besides incorporating a risk measure to hedge against dry years and high demand. Julia's JuMP and MultiObjectiveAlgorithms packages are used for modeling and solving the problem. The model is verified by data from a garden in Amsterdam. juliacon2024-44376-multiobjective-stochastic-storage-design-of-rainwater-harvesting Earth and climate science in Julia: Power to the user Alireza Shefaei en The optimal design of rainwater harvesting systems requires sizing storage and catchment areas to optimize cost, self-sufficiency, and water quality indicators under climate and demand uncertainty. In this work, we formulate and solve a multi-objective stochastic optimization problem that allows for explicit trade-off under uncertainty, maximizing system efficiency and minimizing deployment cost, which includes required materials and construction. For this, we use the yield after spillage (YAS) concept to incorporate the physical and operational constraints and the big-M method to reformulate the nonlinear min\max rules of this approach as a mixed-integer linear programming (MILP) problem. After that, two sources of uncertainty, including water demand and amount of rainfall, are considered, and the problem is formulated as a stochastic programming. In addition, utilization of the conditional value at risk measure allows for the consideration of risk. It guarantees the designer against the highest demand and driest weather conditions. The problem optimizes the efficiency and cost over demand and rainfall scenarios. The JuMP package is used for modeling the resulting stochastic multi-objective quadratic constraint MILP problem. Also, the Gurobi solver and the MultiObjectiveAlgorithms package are utilized to solve this problem. The results are verified with historical data from a botanical garden as a case study in Amsterdam. false https://pretalx.com/juliacon2024/talk/SXAMDV/ https://pretalx.com/juliacon2024/talk/SXAMDV/feedback/ While Loop (4.2) Lightning talk 2024-07-12T14:30:00+02:00 14:30 00:10 We present a new methodology implemented in the Julia package TurbulenceFlux.jl to compute high time resolution flux from flux tower measurements. Through wavelet analysis, it operates in the time-scale domain to identify times and scales at which turbulence is sufficiently developed to integrate a flux. juliacon2024-43551-high-resolution-flux-estimation-with-turbulenceflux-jl Earth and climate science in Julia: Power to the user Gabriel Destouet en Flux estimation from eddy-covariance flux tower measurements faces the problem of integrating fluxes only in the case of fully developed turbulence and in non-stationary environments with advective components. The standard eddy-covariance method operates on fixed-length signals, requiring the knowledge of a maximum correlation time-length as well as post-processing steps assessing the suitability and quality of the data. One important disadvantage of these statistical tests is that they discard whole time intervals such as half an hour if they detect failure. Time-scale (time-frequency) analyses have been used as an alternative to the standard time-analysis approach to estimate ecosystem fluxes. In particular, wavelet analysis, which is well adapted to the study of non-stationary and scale invariant processes such as turbulence, has been used in previous works. It presents the ability of separating the different components of the flux in time-scale space and as such could be an efficient alternative for flux estimation. In a new Julia package TurbulenceFlux.jl, we implement a general framework for analysing fluxes in time-scale space, and propose a new method for identifying and extracting turbulent transport. The Julia language and its package ecosystem made this implementation easy and natural. In particular, it allowed our code match the speed of the standard approach implemented in Fortran. It also helped us make our code differentiable, which hints to further investigations, such as the study of flux ecosystem response times, or sensitivity analysis against wavelet and averaging window parameters. false Slidesv2 https://pretalx.com/juliacon2024/talk/7LAYTN/ https://pretalx.com/juliacon2024/talk/7LAYTN/feedback/ While Loop (4.2) Lightning talk 2024-07-12T14:40:00+02:00 14:40 00:10 SpeedyWeather.jl is a library to simulate and analyse the global atmospheric circulation. It implements several 2D and 3D models, as well as packages to analyse and visualise gridded data on the sphere. Running and analysing simulations can be interactively combined, enhancing user experience and productivity. To change, for example, how precipitation or surface mixing is simulated, SpeedyWeather.jl is easily extensible with new components that can be introduced interactively. juliacon2024-44466-speedyweather-jl-reinventing-atmospheric-models Earth and climate science in Julia: Power to the user /media/juliacon2024/submissions/EP99CX/primitive_overview_foKefge.png Milan Klöwer en SpeedyWeather.jl is a fresh approach to atmospheric models that have been very influential in many areas of scientific and high-performance computing as well as climate change mitigation and adaptation. Most weather, ocean, and climate models are written in Fortran and have been developed over decades. From this tradition follows a specific programming style and associated user interface. SpeedyWeather.jl aims to overcome constraints of traditional Fortran-based models. The modern trend sees simulations in Fortran and data analysis in Python, making it virtually impossible to interact with various model components directly. In SpeedyWeather.jl, interfaces to the model components are exposed to the user. A model in SpeedyWeather.jl is constructed bottom-up by first defining the discretization and any non-default model components with their respective parameters. All components are then collected into a single model object, which, once initialised, returns a simulation object. A simulation can be run, but also accessed and altered in all its components before and after to analyse or visualise the current variables or individual terms of the equations. One can also adjust some parameters before resuming the simulation, putting the user at the centre of the interaction with the model. With SpeedyWeather.jl we hope to provide a platform for atmospheric modelling and in general an interactive model that makes difficult problems easy to simulate. Climate models that are user-friendly and easily extensible will suddenly make many complex research ideas possible. false https://pretalx.com/juliacon2024/talk/EP99CX/ https://pretalx.com/juliacon2024/talk/EP99CX/feedback/ While Loop (4.2) Lightning talk 2024-07-12T14:50:00+02:00 14:50 00:10 Oceananigans is a Julia fluid dynamics library focused on oceanic settings that underpins the ocean component of the CliMA's Earth System Model. We describe the implementation strategy with particular attention to flexibility, usability, and performance on GPU architectures. We explain how our approach gives rise to a generalized framework that can be easily extended to encompass different physical parameterization and model components. juliacon2024-51645-oceananigans-an-ocean-flavoured-fluid-dynamics-library Earth and climate science in Julia: Power to the user /media/juliacon2024/submissions/BYQWXK/Screenshot_2024-07-12_at_08.06.14_AzcOhcO.png Navid Constantinou en We present [Oceananigans](https://github.com/CliMA/Oceananigans.jl), a Julia fluid dynamics library focused on oceanic settings. Oceananigans underpins the ocean component of the [CliMA](https://clima.caltech.edu)'s Earth System Model. Using a library for fluid dynamics modeling deviates from the typical approach of having a statically compiled code because it allows users to develop their custom equations by leveraging Oceananigans' predefined functions. We describe the implementation strategy with particular attention to flexibility, usability, and performance on GPU architectures. We explain how our approach gives rise to a generalized framework that can be easily extended to encompass different physical parameterization and model components. As specific examples, we illustrate the implementation of a sea-ice component and a biogeochemistry component and if time allows we showcase the ease of use by illustrating how to include a neural network in Oceananigans' hydrostatic model. false Slides https://pretalx.com/juliacon2024/talk/BYQWXK/ https://pretalx.com/juliacon2024/talk/BYQWXK/feedback/ While Loop (4.2) Lightning talk 2024-07-12T15:00:00+02:00 15:00 00:10 Julia’s speed and extensibility allow fast and iterative exploration of fine-scale sea ice dynamics. Performance improvements of 15-20x over similar MATLAB code enable simulations over climate-relevant scales. Furthermore, the model’s modular design, enhanced by Julia’s multiple dispatch, encourages users to test novel experiment configurations. These improvements uncovered physical properties not captured by traditional models, which in turn continue to inform Subzero’s development. juliacon2024-44392-subzero-jl-fast-and-flexible-sea-ice-physics Earth and climate science in Julia: Power to the user Skylar GeringMukund Gupta en Julia’s speed and flexibility promise advances in efficient and accessible climate modeling. For example, through the combination of Julia and GPUs, Oceananigans.jl has allowed mesoscale-resolving large ensemble ocean runs, the likes of which have previously been restricted to atmospheric models. As a developer-researcher team, we plan to adapt these computational advances to discrete-element sea ice modeling, where individual ice floes are represented as distinct elements that interact with other floes, the ocean, and the atmosphere. Towards this goal, we have translated the discrete-element sea ice model Subzero.jl from MATLAB to Julia to explore the physics of fine-grained sea ice dynamics while addressing the computational challenges posed by a sea ice field that constantly evolves in both size and shape. In this translation, we focus on performance and ease of use. We have realized, and engineered, large performance improvements that now allow larger and faster simulations. Some of these speedups have resulted from our contributions to various Julia geometry libraries, highlighting the experience of developers becoming contributors to other Julia packages. Additionally, we have designed the code base in such a way that it is easily extended and customizable for users. This modularity takes advantage of multiple dispatch and has inspired new additions to the model as users request new features. Finally, we have achieved coupling with Oceanaigans.jl, furthering our research agenda and the usefulness of Subzero.jl within the field. We have used the new model to investigate the transfer of momentum through sea ice packs and the ocean in various scenarios, including sea ice packs of various concentrations and sizes. Recently, we have collaborated with users interested in modeling the effects of storms on the ice pack, as well as the formation of cracks within the ice. We are excited to assist new users to extend and develop Subzero.jl independently as a way to increase both the developer and user base, highlighting the interplay between users and developers. false https://pretalx.com/juliacon2024/talk/NC7JPQ/ https://pretalx.com/juliacon2024/talk/NC7JPQ/feedback/ While Loop (4.2) Lightning talk 2024-07-12T15:10:00+02:00 15:10 00:10 Modeling subglacial water flow and its link to ice dynamics is necessary for accurate predictions of ice sheet response to a warming climate. Here we present a re-implementation of the widely used GlaDS model to run on GPUs. We show-case the matrix free implementation which leverages the full capabilities of the GPU, present model runs of test cases, show the model's scalability and provide an outlook towards inversion schemes and high-resolution continental-scale applications. juliacon2024-44135-subglacial-water-flow-simulations-on-gpus Earth and climate science in Julia: Power to the user Ludovic RässMauro WerderIvan UtkinAnnegret Pohle en Subglacial water flow plays an important role in the dynamic of a glacier or ice sheet by impacting the conditions at their base and thus the sliding. Understanding subglacial drainage and its links to ice flow is necessary to predict sea level rise due to the ice sheets' evolution in a warming climate. The Glacier Drainage System Model (GlaDS), one of the most widely used such models, simulates both channelised and distributed drainage at the ice-bed interface. Here we present a re-implementation of GlaDS running on Graphical Processing Units (GPUs). The aim is for the model to run on meshes larger than 10,000² grid points, which would allow, for instance, to simulate Antarctica at 500m resolution. Unlike the original GlaDS implementation, this is based on a finite difference scheme on a structured grid. Together with a matrix-free solver, this allows us to leverage the full performance capabilities of GPUs. We present model runs of test cases, show the model's scalability and provide an outlook towards inversion schemes and higher-resolution continental-scale applications. false https://pretalx.com/juliacon2024/talk/VKCYEK/ https://pretalx.com/juliacon2024/talk/VKCYEK/feedback/ While Loop (4.2) Lightning talk 2024-07-12T15:20:00+02:00 15:20 00:10 We introduce ODINN.jl, a new global glacier evolution model in Julia, leveraging SciML for functional inversions of geophysical processes from heterogenous observations. PyCall.jl enables us to build on top of key Python packages, combining each communities' strengths. ODINN.jl showcases flexible geoscientific modeling, combining domain knowledge of mechanistic models with machine learning, facilitated by Julia's differentiable programming and multi-language support. juliacon2024-43729-odinn-jl-multi-language-geoscientific-machine-learning Earth and climate science in Julia: Power to the user /media/juliacon2024/submissions/EPUXXU/ODINN_overview_9Ajcr10.png Jordi Bolibar en We present ODINN.jl, a global glacier evolution model leveraging the Scientific machine learning and foreign language calling capabilities of Julia. We developed a modelling framework capable of handling Universal Differential Equations of glacier ice flow, solving hundreds of thousands of ODEs in parallel. By exploiting Julia’s SciML differentiable programming capabilities, we demonstrate how we can perform functional inversions to learn underlying physical laws of geophysical processes, while assimilating heterogenous, noisy and sparse observations. Moreover, thanks to the use of PyCall.jl, we can do so by re-using data processing and management tools from the Open Global Glacier Model and Xarray in Python. Furthermore, the use of these tools allows us to recycle existing mass balance models (i.e. a source in a differential equation) previously calibrated in Python that are incorporated in the numerical solver. This enables us to build complex hybrid models on top of currently existing infrastructure in Python, leveraging each ecosystem’s strengths. With ODINN.jl, we show how the future of geoscientific models will gravitate towards flexible modelling frameworks, exploiting mechanistic models based on domain knowledge with machine learning models capable of learning from new massive Earth observations. Moreover, the multi-language capabilities of Julia enable a smooth interoperability of these new tools with already established frameworks, providing a faster track to new methods, while enabling existing communities to benefit from them. false https://pretalx.com/juliacon2024/talk/EPUXXU/ https://pretalx.com/juliacon2024/talk/EPUXXU/feedback/ While Loop (4.2) Lightning talk 2024-07-12T15:40:00+02:00 15:40 00:10 **Sindbad.jl** currently serves as an internal modular framework for model-data integration at the Max Planck Institute for Biogeochemistry. It supports various methods for water-carbon coupling and vegetation dynamics. All definitions are compatible with automatic differentiation, enabling hybrid modeling approaches. Specifically, these approaches preserve the physics-based models while utilizing neural networks to optimize quantities of interest. juliacon2024-44335-strategies-to-integrate-data-and-biogeochemical-models Earth and climate science in Julia: Power to the user Felix CremerLazaro AlonsoNuno Carvalhais en Co-authors / developers: Sujan Koirala, Fabian Gans, Bernhard Ahrens, Felix Cremer, Thomas Wutzler, Mohammed Ayoub, Markus Reichstein, Nuno Carvalhais The application of automatic differentiation and deep learning approaches to tackle current challenges is now a widespread practice, and the biogeosciences community is no stranger to this trend. In this talk, we showcase the **Sindbad.jl** framework for modelling the ecosystem dynamics of vegetation, water, and carbon cycles. Our goal is to simulate targeted observations through physics-based models while employing a feedforward neural network to learn the spatial variability of their parameters. These models historically posed challenges due to their complex process representations, varied spatial scales, and parameterizations. Our results demonstrate that the hybrid approach effectively predicts model parameters using a single neural network, compared to a site-level optimized set of parameters. This approach proves its capability to generate predictions consistent with in-situ parameter calibrations across various spatial locations, showcasing its versatility and reliability in modeling coupled systems. This study illustrates that incorporating neural networks into a diverse collection of physics-based models holds significant promise. This integration has the potential to leverage the abundance of current Earth observations, enabling the application of these methods on a larger scale. In addition to addressing scientific questions, we will also present technical challenges and the approaches taken. This includes dealing with mutation and automatic differentiation, scaling up forward runs with **YAXArrays.jl**, and ensuring documentation is user-friendly, or at least as user-friendly as possible. false https://pretalx.com/juliacon2024/talk/MZTRMN/ https://pretalx.com/juliacon2024/talk/MZTRMN/feedback/ While Loop (4.2) Lightning talk 2024-07-12T15:50:00+02:00 15:50 00:10 Species distribution modelling is the ecological discipline of predicting species occurrence in time and space. SDMs are used for biodiversity conservation, predicting invasions, and anticipating the effects of climate change. This talk will present a species distribution modelling workflow in Julia, using SpeciesDistributionModels.jl and packages from the EcoJulia and JuliaGeo ecosystems to extract data, fit a model ensemble, and predict distributions in just a few lines of code. juliacon2024-44430-speciesdistributionmodels-jl-an-sdm-workflow Earth and climate science in Julia: Power to the user Rafael SchoutenTiem van der Deure en The accessibility of species distribution modelling techniques through R packages such as sdm and biomod2 has hugely contributed to their popularity. The paper that introduces maxent (https://doi.org/10.1016/j.ecolmodel.2005.03.026), one of the most popular algorithms for species distribution modelling, has been cited over 18 thousand times. SpeciesDistributionModels.jl is designed to be as user-friendly as existing R-based platforms, but with the power of Julia. It builds on the MLJ ecosystem can be extended with any MLJ-compatible model that accepts a binary response variable. It also integrates with Rasters.jl and Makie.jl to predict with geospatial inputs and outputs and for easy visualisation of model evaluation. The speed-up provided by Julia opens up new possibilities to explore and visualise SDMs, like using Shapley values for more adequately explain the contributions of predictor variables and interactive plotting. This talk will show a typical SDM workflow using SpeciesDistributionModels.jl and discuss the advantages of using Julia for SDMs. false https://pretalx.com/juliacon2024/talk/P88SPE/ https://pretalx.com/juliacon2024/talk/P88SPE/feedback/ While Loop (4.2) Lightning talk 2024-07-12T16:00:00+02:00 16:00 00:10 Programming tools are increasingly integral to research and analysis in myriad domains, including specialized areas with no formal relation to computer science. Embedded domain-specific languages have the potential to serve these programmers while placing light implementation burdens on language designers. We e aim to deepen our understanding of how programmers use eDSLs and identify user needs to inform future eDSL designs, focusing on Mimi.jl, an EDSL for climate economics research and policy. juliacon2024-43705-how-climate-economics-domain-experts-use-an-embedded-dsl Earth and climate science in Julia: Power to the user Lisa Rennels en Programming tools are increasingly integral to research and analysis in myriad domains, including specialized areas with no formal relation to computer science. Embedded domain-specific languages (eDSLs) have the potential to serve these programmers while placing relatively light implementation burdens on language designers. However, barriers to eDSL use reduce their practical value and adoption. In this paper, we aim to deepen our understanding of how programmers use eDSLs and identify user needs to inform future eDSL designs. We performed a contextual inquiry (9 participants) with domain experts using Mimi, an eDSL for climate change economics modeling. A thematic analysis identified five key themes, including: the interaction between the eDSL and the host language has significant and sometimes unexpected impacts on eDSL user experience, and users preferentially engage with domain-specific communities and code templates rather than host language resources. The needs uncovered in our study offer design considerations for future eDSLs and suggest directions for future DSL usability research. false Github Repo FinalSlidesPPTX https://pretalx.com/juliacon2024/talk/9UWCXV/ https://pretalx.com/juliacon2024/talk/9UWCXV/feedback/ While Loop (4.2) Lightning talk 2024-07-12T16:10:00+02:00 16:10 00:10 A 3D Lightning Mapping Array (LMA) is a regional network of VHF sensors locating lightning channels within the cloud with high precision. An interactive visualization & analysis tool is developed using Julia and Makie to study the features of lightning flashes, the charge structure of thunderstorms and the evolution of 3D storm activity, and network performance. This talk will explain how Julia is used in the lightning data processing, its visualization, and performance lessons. juliacon2024-44512-visualization-and-analysis-of-3d-lightning-mapping-array-data Earth and climate science in Julia: Power to the user /media/juliacon2024/submissions/79BGUS/Screenshot_2024-02-01_022556_pMQR9oj.png Oscar van der Velde en The 3D Lightning Mapping Array (LMA) is a regional network for the detection of lightning channels as they propagate through the cloud. Designed 25 years ago by New Mexico Tech, more than a dozen LMAs are now being operated across the globe. This talk will explain how I use Julia for processing LMA data processing, the visualization, and performance considerations. The power of Julia allows additional (novel) data analysis to be done while allowing a responsive interactive data browsing experience. The functionality of the LMA visualizer is already rich, and it is my intention to create a package for release to the greater community within a year or so. Background An LMA is a regional network of VHF antenna stations spaced 5-50 km apart that detect lightning pulses, typically in the 60-66 MHz band. The pulses are timed by GPS. Time-of-arrival reconstruction results in 3D pulse locations, revealing the lightning leader channels (of negative polarity) inside the cloud and toward ground. The detection range of a sensitive network can reach over 250 km from the center. More than a dozen LMAs are now operational world wide. They are used for lightning science, nowcasting of severe weather and airspace safety. In 2011, the Ebro 3D Lightning Mapping Array in Spain was the first LMA to be installed outside the USA, consisting of 12 stations in 2012-2014 and was subsequently split in half in 2015 to facilitate a LMA in Colombia. In 2023 and 2024, the system was upgraded to 15 stations spread out mostly across western Catalonia. It has detected very interesting cases of supercell storms with rising bubbles of lightning activity and even a “lightning hole” in hailstorms, as well as very large horizontal flashes that lasted for 6 seconds before they ceased, spanning 130 km. More information on the Ebro LMA, real-time monitoring and the eLMA services can be found at https://elma.upc.edu. An interactive lightning visualization and analysis tool for the LMA is being developed using Julia and Makie. It is a suite of tools that focus on (a) lightning flash analysis and general browsing of activity, (b) storm activity evolution analysis, and (c) network performance analysis based on the data. An automated leader speed tool was previously programmed in Scilab, using Theil-Sen slope estimator of points, which has been successfully implemented in Julia, reducing waiting times from many minutes to generally less than 10 seconds. Leader speed turns out to be the best tool for diagnosing the overall electrical charge structure of a thunderstorm. New tools include a flash grouping algorithm based on DBSCAN. Noisy points that do not belong to lightning leaders are filtered out, and these themselves can hold information which is subsequently going through another DBSCAN with different settings, to isolate sparse, local, but continuous activity such as sparks near the cloud top and sparks at wind turbines. Another DBSCAN setting allows to isolate the leader branches within flashes. The tool also can read cloud-to-ground stroke data from other networks, and Meteosat Third Generation Lightning Imager or GOES Geostationary Lightning Mapper (GLM) to be compared with LMA. A grid-based storm activity analysis tool has now been designed. It is based on local 3D flash density and its evolution in time visualizes trends in 3D activity, rather than the ubiquitously used general flash rate. It uses sparse arrays to manage memory issues, with certain performance considerations. Lightning leader speed, polarity and the repetition rate of leaders in flashes may hold new information that could turn out to be useful in monitoring the thunderstorm state and potential for severe weather. false https://pretalx.com/juliacon2024/talk/79BGUS/ https://pretalx.com/juliacon2024/talk/79BGUS/feedback/ While Loop (4.2) Lightning talk 2024-07-12T16:20:00+02:00 16:20 00:10 Explore how Julia empowers scatterometer operations at EUMETSAT. From visualizing data to calibrating operational instruments and planning future missions, Julia is becoming an important tool. Spaceborne scatterometers are vital for monitoring ocean wind speeds, essential for numerical weather models. Additionally, they measure soil moisture, contributing to our understanding of climate dynamics. juliacon2024-44385-supporting-development-and-operation-of-scatterometers Earth and climate science in Julia: Power to the user Simon Kok Lupemba en The Scatterometry team at EUMETSAT has embarked on a gradual transition to Julia over the past few years, and now, it’s an integral part of our daily workflow. In this talk, we’ll delve into key aspects of how Julia is used to support our scatterometer operations. We will share our experiences and give concrete examples of how we use Julia to support the current ASCAT mission. This ranges from data visualization to instrument calibration and quality monitoring. We will also describe how we use Julia in the preparation for the future SCA mission. While Julia is not directly used in the operational processing chain, we will discuss its potential and the associated challenges. We have not released any Julia packages yet, but we hope to do so in the future. We will reflect on how this can help empower the end users. false GitLab Presentation https://pretalx.com/juliacon2024/talk/BPZJPP/ https://pretalx.com/juliacon2024/talk/BPZJPP/feedback/ While Loop (4.2) Lightning talk 2024-07-12T16:30:00+02:00 16:30 00:10 What happens when Julia developers meet users? Our group is leading capacity-building projects focused on applying the Julia programming language in Earth observation. This talk provides the context and motivation behind organizing JuliaEO - Global Workshop on Earth Observation with Julia (in 2023 and 2024) and the Julia-focused project on harnessing space technological applications for sustainable urban development. juliacon2024-43716-julia-community-reshapes-computation-in-geosciences Earth and climate science in Julia: Power to the user /media/juliacon2024/submissions/VHPZ7Z/JuliaEO24Logo_1cZz0xr.png Iga SzczesniakJoao Pinelo en With a low entry barrier to a large ecosystem of tools and libraries that enable quick prototyping, Julia holds great potential for development. Julia’s native use of hardware accelerators has the potential to greatly impact data processing in the geosciences due to the heavy reliance on matrixes. In this talk, we will discuss the theoretical possibilities of a computational revolution in the geosciences, and the outcomes, overview, and impact of two initiatives centred around Julia, focusing on Earth observation concepts and software development. Both initiatives have facilitated genuine knowledge sharing and fostered new collaborations between developers and users across diverse fields. The diverse range of topics covered various phases of the process, spanning the creation of libraries and packages to the replication of tools. A total of 120 people registered online, with 44 attendees present in person. All major aspects were addressed, including the acquisition, processing, visualization, and classification of geospatial data. The discussion extended to parallel computing and machine learning. false Presentation https://pretalx.com/juliacon2024/talk/VHPZ7Z/ https://pretalx.com/juliacon2024/talk/VHPZ7Z/feedback/ While Loop (4.2) Talk 2024-07-12T16:40:00+02:00 16:40 00:20 Using Julia for Earth and climate science has the potential to combine the best of both worlds: The speed of Fortran and the interactivity and productivity of Python, empowering users to be developers and developers to be users. In this minisymposium speakers will present software projects both from a user and a developer perspective. Talks are encouraged to discuss both use cases of existing software as well as the development of user-friendly software. juliacon2024-50043-discussion-earth-and-climate-science-in-julia Earth and climate science in Julia: Power to the user Milan KlöwerFrancesco MartinuzziSkylar GeringJordi Bolibar en Using Julia for Earth and climate science has the potential to combine the best of both worlds: The speed of Fortran and the interactivity and productivity of Python, empowering users to be developers and developers to be users. In this minisymposium speakers will present software projects both from a user and a developer perspective. Talks are encouraged to discuss both use cases of existing software as well as the development of user-friendly software. false https://pretalx.com/juliacon2024/talk/HSN88L/ https://pretalx.com/juliacon2024/talk/HSN88L/feedback/