Juliacon 2024
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.
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.
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.
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.
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.
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.
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.
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!
Opening the first day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer.
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.
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.
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.
"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!
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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
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.
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.
BiochemicalAlgorithms.jl is a redesign of the popular Biochemical Algorithms Library (BALL), the largest open source C++-framework of its kind. We focused on three main design goals: efficiency, ease of use and rapid application development (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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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?
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.
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!
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.
We present Entangled, 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
, simulating the formation of carbonate reef platforms and their produced limestone stratigraphy.
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.
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).
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.
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.
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
JuliaScript.jl provides juliascript
runner with which you really just do juliascript yourscript.jl
.
Enjoy speed for julia scripts!
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.
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.
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.
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.
I will discuss efficient chunk access in HDF5, Zarr shards, and TIFF tiles
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.
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.
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.
ScopedValues are a new language feature in Julia 1.11, in this talk I will discuss their uses and some implementation details.
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.
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.
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.
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.
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.
A deep dive into dependency management processes, associated tooling, and lessons learned integrating with Julia’s package management system from a different technology stack.
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.
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.
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.
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 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).
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!
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!
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.
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.
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.
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.
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).
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.
We introduce 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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
It's the JuliaCon 2024 poster session! Come by to see the posters, chat with the presenters, and organize into groups for dinner.
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.
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.
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.
Closing the first day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer.
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.
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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!
Opening the second day of JuliaCon Global 2024 and PyData Eindhoven 2024 with organizing committee member Koen de Raad.
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.
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.
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.
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.
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.
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.
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.
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.
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!
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.
In this talk, we will introduce our new package, MuJoCo.jl, bringing the advanced physics simulator 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.
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.
The Computational Thinking in Julia 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, showing step by step how everyone can build a website like the computational thinking in a few easy steps.
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).
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.
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.
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.
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.
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
Taija is a growing ecosystem of packages geared towards Trustworthy Artificial Intelligence in Julia. 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.
In this talk, we present QuantileMatching.jl, 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.
Infiltrator.jl is a small utility package for interactively debugging performance sensitive Julia code with minimal runtime cost.
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.
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.
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.
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.
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.
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
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.
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.
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.
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!
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.
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.
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
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!
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.
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."
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.
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!
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.
We present a package for Recursive Causal Discovery 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.
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.
TrillionDollarWorlds.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.
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.
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
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.
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.
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.
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.
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.
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.
Effect analysis, exception types, escape analysis, effect preconditions, non-standard specialization, optimized generics - the compiler team has been busy. What is this all about?
Rust keeps gaining ground across the software world! How can we best learn and exchange algorithms and best practices?
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.
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.
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.
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.
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.
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.
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.
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.
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.
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?
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.
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
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.
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.
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.
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.
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.
The JuliaGPU community welcomes both long-standing contributors and newcomers to a birth-of-the feather event on the state of the JuliaGPU ecosystem.
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.
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.
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.
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.
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.
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.
“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.
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
.
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.
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.
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.
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.
Closing the second day of JuliaCon Global 2024 and PyData Eindhoven 2024.
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.
Opening the last day of JuliaCon Global 2024 at Eindhoven with organizing committee chair Raye Kimmerer.
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.
CodeEvaluation.jl and its companion 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.
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.
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.
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!
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.
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.
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.
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.
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.
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!
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.
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.
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.
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.
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!
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.
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.
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.
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.
A get together of all the people interested in the current state and the future of Plots.jl
The Ray compute framework is widely used for distributed computing, supporting multiple compute environments and client languages.
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.
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.
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.
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.
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.
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.
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.
Quarto 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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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!).
In this talk, we update on the developments of the 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.
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.
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.
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.
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.
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.
Taija is a growing ecosystem of packages geared towards Trustworthy Artificial Intelligence in Julia. 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: Taija's recent venture into supercomputing.
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.
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.
This is an update on the density-functional toolkit (DFTK), 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 workflow engine. Examples illustrate the code's use as a platform supporting researches from multiple disciplines.
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.
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.
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
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.
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.
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.
How to create and deploy interactive Dashboards with Makie and Bonito.
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.
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.
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.
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.
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!
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
In this talk we will discuss recent changes in the CUDA.jl and oneAPI.jl packages, which provide GPU programming capabilities in Julia.
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.
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.
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 package, which implements a variety of powerful abstractions on top of a high-performance, heterogeneous task parallel core.
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.
HumanEval and 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
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.
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.
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.
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.
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.
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, which highlights the steps and tools required to create one of these packages.
Prometheus 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 which is Prometheus client library written in Julia.
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.
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.
One of the options to build a GUI in Julia is the 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.
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.
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
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.
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.
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
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.
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.
With libtrixi we present a blueprint for connecting established research codes to modern software packages written in Julia without sacrificing performance. Specifically, libtrixi provides an API to Trixi.jl, a Julia package for adaptive numerical simulations of conservation laws.
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.
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.
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.
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.
We present SeismicWaves.jl, a package for 1D, 2D, and 3D wave simulations on multi-xPUs. 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Closing the final day of JuliaCon 2024.