2.0 -//Pentabarf//Schedule//EN PUBLISH LSNEWV@@pretalx.com -LSNEWV Learn Julia via epidemic modelling en en 20200724T140000 20200724T173000 033000 Learn Julia via epidemic modelling We will explore more advanced features of Julia, in particular Julia’s type system. To do so we will build up simple models for the spread of an epidemic through a population of individuals. Some topics that we will cover include: - Why Julia? - Small functions as building blocks - Multiple dispatch - User-defined types - Abstract types and type hierarchies - Generic programming Materials and installation instructions are available at https://github.com/dpsanders/LearnJulia2020 PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/LSNEWV/ Red Track David P. Sanders PUBLISH GQATHR@@pretalx.com -GQATHR Building and analyzing graphs at scale with LightGraphs en en 20200724T140000 20200724T173000 033000 Building and analyzing graphs at scale with LightGraphs 1. Introduction Setting up a project, logistics, where to get help, quick tour of the JuliaGraphs ecosystem 2. First steps with SimpleGraphs Building a graph, querying basic information, modifying a graph, constructing a graph iteratively, visualization using GraphPlot, generating standard graphs, getting large graphs from the Graph500.jl and SNAPDatasets.jl datasets. 3. More types, more fun The graph abstraction, why? Two graph variants, with SimpleWeightedGraphs & MetaGraphs. Dot format for visualization of small graphs 4. Applications Discrete optimization (spanning trees, mincut, flows, matching), web & network analysis (pagerank, analysis of the Julia packages), spectral analysis. Target audience: we assume the audience is familiar with the basics of Julia syntax (functions, dispatch) and have already encountered graphs before. PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/GQATHR/ Green Track James Fairbanks Mathieu Besançon Simon Schoelly PUBLISH Y3H7FG@@pretalx.com -Y3H7FG Building microservices and applications in Julia en en 20200725T140000 20200725T173000 033000 Building microservices and applications in Julia This workshop will have three phases: * General overview of microservices and their architecture; what are the purposes and goals of a microservice; need for web, service, and persistence layers; which layer takes care of which pieces of functionality; how does the object model definitions relate to each layer. Included will be a discussion of why a microservice can be more general purpose and accessible than a script, and how one could move a script computation into the framework of a full microservice. * How does the rubber meet the road; step-by-step walk-through of building a simple Julia microservice; implementation of object model definitions and packages that help in customizing object representations; implementing web, service, and persistence layers and packages available to aid in layer-to-layer object transfer; how to run the service and writing a simple client to test; quick example of "packaging" the service as a docker container for maximum portability and flexibility * Advanced topics in building microservices; solutions to common problems like logging, context setting and management, middleware setup, authentication, caching, connection pooling, config management, threaded worker task execution, docker container considerations, and using PackageCompiler. Every microservice is unique and will always require customization and tooling, but with a set of high quality swiss-army packages and best practices, more time can be focused on domain logic instead of service setup and tooling. PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/Y3H7FG/ Red Track Jacob Quinn PUBLISH 9WMAVU@@pretalx.com -9WMAVU BinaryBuilder.jl — The Subtle Art of Binaries that "Just Work" en en 20200725T140000 20200725T173000 033000 BinaryBuilder.jl — The Subtle Art of Binaries that "Just Work" In a perfect world, all interesting code would be written in Julia and there would be no need to worry about anything else. Of course, we do not live in that world, and we must jump through hoops to ensure that code written in other languages is easily accessible from Julia. BinaryBuilder.jl makes it easy to take software written in compiled languages such as C, C++, Fortran, Go or Rust, and build precompiled artifacts that can be used from Julia packages with ease. In the first part of this workshop you will learn about the motivations for this package and how it solves the issues of provinding the needed binaries, but also the issue it creates! In the second part we will guide you through the process of crafting a build recipe using `BinaryBuilder.jl`; we will demonstrate using the wizard which will guide you through the process of constructing a `build_tarballs.jl` script, then show how advanced users can write their own scripts in case they need more power or flexibility. Finally, in the hands-on section of the workshop you will have the opportunity to write a new recipe and submit your first pull request to Yggdrasil, the mythical collector of all `BinaryBuilder.jl` scripts, with the support of the presenters. PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/9WMAVU/ Green Track Elliot Saba Mosè Giordano PUBLISH C9FGPP@@pretalx.com -C9FGPP Doing Scientific Machine Learning (SciML) With Julia en en 20200726T140000 20200726T173000 033000 Doing Scientific Machine Learning (SciML) With Julia In this workshop we'll dive into some of the latest techniques in scientific machine learning, including Universal Differential Equations ([Universal Differential Equations for Scientific Machine Learning](https://arxiv.org/abs/2001.04385)), Physics-Informed Neural Networks ([Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations](https://www.sciencedirect.com/science/article/pii/S0021999118307125)), and Sparse Identification of Nonlinear Dynamics (SInDy, [Discovering governing equations from data by sparse identification of nonlinear dynamical systems](https://www.pnas.org/content/113/15/3932)). The goal is to get those in the workshop familiar with what these methods are, what kinds of problems they solve, and know how to use Julia packages to implement them. The workshop will jump right into how to model the missing part of a physical simulation, describe how universal approximators (neural networks) can be used in this context, and show how to transform such problems into an optimization problem which is then accelerated by specializing automatic differentiation. The set of packages that is involved in this is somewhat intense, using many tools from JuliaDiffEq ([DiffEqFlux.jl](https://diffeqflux.sciml.ai/dev/), DifferentialEquations.jl, DiffEqSensitivity.jl, ModelingToolkit.jl, [NeuralPDE.jl](https://neuralpde.sciml.ai/dev/), DataDrivenDiffEq.jl, Surrogates.jl, etc.) combined with machine learning tools (Flux.jl), differentiation tooling (SparseDiffTools.jl, Zygote.jl, ForwardDiff.jl, ReverseDiff.jl, etc.), and optimization tooling (JuMP, Optim.jl, Flux.jl, NLopt.jl, etc.) all spun together in a glorious soup that automatically discovers physical laws at the end of the day. Thus this workshop has something different to offer for everyone: new users of Julia will get a nice overview of the unique composibility of the Julia package ecosystem, while experienced Julia users will learn how to bridge some area that they are comfortable with (such as machine learning) to a whole new set of phenomena. Meanwhile, even though who are only knee deep in coding can gain a lot from learning these new mathematical advances, meaning that even a casual observer likely has a lot to learn! PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/C9FGPP/ Red Track Chris Rackauckas PUBLISH NNVQQF@@pretalx.com -NNVQQF Wrapping a C++ library using CxxWrap.jl en en 20200726T140000 20200726T173000 033000 Wrapping a C++ library using CxxWrap.jl The prerequisites for following this workshop are a working C++17 compiler and a Julia installation, details are given at the [workshop github repository](https://github.com/barche/cxxwrap-juliacon2020) The workshop is built up around exercises that can be followed along on your own machine. We start off with some generic tutorials about compiling a very simple shared library and using that directly from Julia using `ccall`, and then build up more complex cases using CxxWrap to tackle proper C++ constructs such as classes and templates. Exercises are as follows: 1. Shared libraries: build and use `libfoo` from the BinaryBuilder tests, using CMake. This will gently introduce everyone to the manual compilation of a shared library, which is required for package development with CxxWrap. 2. Setting up CxxWrap for development: Compile CxxWrap itself using your system compiler and set it up using Overrides.toml. This is needed on most platforms, since the distributed CxxWrap binaries are cross-compiled and usually incompatible with the installed compiler. 3. Make a CxxWrap wrapper package for `libfoo` 4. Wrapping the [Eigen C++ matrix library](http://eigen.tuxfamily.org/) 5. Smart pointers 6. Using and extending the STL support 7. Distributing your package using BinaryBuilder: this will focus on the attention points when using BinaryBuilder, for example it is necessary to download Julia itself to compile a CxxWrap package. PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/NNVQQF/ Green Track Bart Janssens PUBLISH 8SFYHK@@pretalx.com -8SFYHK A deep dive into DataFrames.jl indexing en en 20200727T140000 20200727T173000 033000 A deep dive into DataFrames.jl indexing Making a `DataFrame` consistent with all indexing functionalities provided by Base Julia (`getindex`, `setindex!`, `view`, `broadcast` and `broadcast!`) is a challenge as it can contain heterogeneous columns that can dynamically change their element type and be added/removed/resized. The first part of the workshop is aimed at a general audience and explains the `DataFrame` indexing rules. The second part explains how to implement indexing for a custom type in the Julia language. The workshop materials will be made available at https://github.com/bkamins/JuliaCon2020-DataFrames-Tutorial. PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/8SFYHK/ Red Track Bogumił Kamiński PUBLISH QT3S9U@@pretalx.com -QT3S9U Calculating with sets: Interval methods in Julia en en 20200727T140000 20200727T173000 033000 Calculating with sets: Interval methods in Julia We will give a hands-on tutorial introduction to the powerful numerical methods for calculating with sets that become available by using interval arithmetic and associated methods, including for approximating functions, root finding, global optimization and solving ODEs, all with guaranteed error bounds. We will explore the suite of packages in the JuliaIntervals organization and how they interact with other packages in the Julia ecosystem, in particular LinearAlgebra and ForwardDiff. We will show how they may be used interactively to calculate ranges of functions, exclude and prove uniqueness of roots. We will also show how to build branch-and-prune algorithms for global optimization and discuss the use of constraint propagation. We will also discuss how to build rigorous approximations of functions as polynomials with interval remainders, and how these may be used for solving ordinary differential equations with guaranteed error bounds (tubes). Materials are available at https://github.com/dpsanders/IntervalsJuliaCon2020 PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/QT3S9U/ Green Track David P. Sanders PUBLISH CRYCPR@@pretalx.com -CRYCPR Gather Town Social en en 20200727T173000 20200727T181500 004500 Gather Town Social PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/CRYCPR/ BoF PUBLISH DMHZCC@@pretalx.com -DMHZCC MLJ: a machine learning toolbox for Julia en en 20200728T140000 20200728T173000 033000 MLJ: a machine learning toolbox for Julia In this workshop we intend to demonstrate how MLJ can be used on a few "real" examples demonstrating how to interpret and preprocess data, how to train models and tune hyperparameters and how to evaluate and compare the quality of predictive models. We will also discuss briefly how MLJ positions itself with respect to the Julia ML/Stats ecosystem and what's on the roadmap for future developments. Workshop repo: https://github.com/ablaom/MachineLearningInJulia2020 PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/DMHZCC/ Red Track Anthony Blaom Thibaut Lienart PUBLISH 7MALUA@@pretalx.com -7MALUA Make your Julia code faster and compatible with non-Julia code. en en 20200728T140000 20200728T173000 033000 Make your Julia code faster and compatible with non-Julia code. PUBLIC CONFIRMED Workshop (half day) https://pretalx.com/juliacon2020/talk/7MALUA/ Green Track Huda Nassar PUBLISH SA8M93@@pretalx.com -SA8M93 Gather Towns Social en en 20200728T173000 20200728T181500 004500 Gather Towns Social PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/SA8M93/ BoF PUBLISH YY9QEJ@@pretalx.com -YY9QEJ KernelFunctions.jl, machine learning kernels for Julia en en 20200729T123000 20200729T124000 001000 KernelFunctions.jl, machine learning kernels for Julia Realising that every package requiring kernels was having his own implementation and that `MLKernels.jl`, the last standard, had a lot of imcompabilities, William Tebbutt and I decided to work on a common project usable by all. `KernelFunctions` allows to process arbitrary transformations on the input data allowing for example to use a neural net or to construct kernel sums and product to create complex kernel structures. A series of standard kernels are available and more and more are added but creating a custom kernel is extremely straight-forward. The package needs only a few dependencies and is very light-weight. I will give a brief introduction to the kernel methods followed by a few concrete examples such as deep kernel learning or automatic kernel selection. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/YY9QEJ/ Red Track Théo Galy-Fajou PUBLISH DSXCMZ@@pretalx.com -DSXCMZ Fast Gaussian processes for time series en en 20200729T124000 20200729T125000 001000 Fast Gaussian processes for time series Gaussian processes (GPs) are flexible probabilistic models for real-valued functions, and are standard tool for nonlinear regression. Their default implementation involves a costly Cholesky decompostion, yielding cubic computational costs in N (dataset size). There is an increasingly-broad literature on a collection of techniques that cast certain classes of GPs for time-series (almost-exactly) as linear stochastic differential equations. This exposes a Markov structure that can be exploited to make the complexity of inference scale linearly in N. TemporalGPs.jl implements the above techniques, and provides a function that takes a Stheno.jl GP and constructs an (almost) equivalent linear SDE, which in turn exposes the same API as a Stheno.jl GP (modulo some restrictions). The only other publicly available implementation of these techniques is available in the famous GPML Matlab package. Moreover, at the time of writing there isn't a publicly available implementation on these techniques that can be used in conjunction with reverse-mode algorithmic differentiation (to the best of the author's knowledge). In this talk I'll present the user-facing API, show some basic benchmarking / empirical results, briefly discuss some technical challenges, and conclude with the package's future direct. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/DSXCMZ/ Red Track Will Tebbutt PUBLISH CE7FZA@@pretalx.com -CE7FZA AugmentedGaussianProcesses.jl, a full Gaussian Process toolkit en en 20200729T125000 20200729T130000 001000 AugmentedGaussianProcesses.jl, a full Gaussian Process toolkit Started as a very specific research project, [`AugmentedGaussianProcesses.jl`](https://github.com/theogf/AugmentedGaussianProcesses.jl) (AGP) is now a package with a much broader range of tools. A large class of different of problems are implemented such as Student-T likelihood, heterogeneous multi-output GP, heteroscedastic regression. Are also implemented various type of inference like variational inference, Gibbs sampling, Hamilton Monte-Carlo or even variational streaming! In this sense AGP aims at being a competitor with general GP toolbox such as [`GPFlow`](https://github.com/GPflow/GPflow) or [`GPytorch`](https://gpytorch.ai/) with better or same training and prediction performance. However one of the additional strength of AGP is to convert problems which start as being intractable into easy ones via latent variable augmentations with a method based on my academic work. It is done so far case by case but current work will aim at being able to treat any problem. In this talk I will showcase all the potential of AGP, and compare its performance with other Julia and Python solutions. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/CE7FZA/ Red Track Théo Galy-Fajou PUBLISH AA8CQU@@pretalx.com -AA8CQU Modeling non-Gaussian time series with ScoreDrivenModels.jl en en 20200729T130000 20200729T131000 001000 Modeling non-Gaussian time series with ScoreDrivenModels.jl In this talk, we will first provide a brief overview of score-driven models, also known as generalized autoregressive models, based on the paper “Generalized Autoregressive Score Models With Applications” by D. Creal et al. This class of models represents a powerful and flexible tool for dealing with time-series data under non-Gaussian distributions and different autoregressive structures. After a high-level introduction to the theory, we will present the ScoreDrivenModels.jl package, going through all steps that a user would possibly need to do: model specification, estimation, forecasting, and simulation. We will show how the package is built on top of Distributions.jl, thus allowing easy integration of any distribution, including more obscure ones, for example, a non-zero mean Student’s t which employs the `LocationScale` abstraction. The package also has a manual for integrating new distributions with small effort. Finally, we will motivate the use of this class of models by providing examples of applications in different fields, e.g., simulating scenarios for renewable generation and analyzing financial time-series data, while showcasing the use of the package. For more information on score-driven models, we refer the interested reader to http://www.gasmodel.com. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/AA8CQU/ Red Track Guilherme Bodin PUBLISH AD7TQW@@pretalx.com -AD7TQW AutoMLPipeline: A ToolBox for Building ML Pipelines en en 20200729T131000 20200729T134000 003000 AutoMLPipeline: A ToolBox for Building ML Pipelines The typical workflow in machine learning classification or prediction requires some or combination of the following preprocessing steps together with modeling: - feature extraction (e.g. ica, pca, svd) - feature transformation (e.g. normalization, scaling, ohe) - feature selection (anova, correlation) - modeling (rf, adaboost, xgboost, lm, svm, mlp) Each step has several choices of functions to use together with their corresponding parameters. Optimizing the performance of the entire pipeline is a combinatorial search of the proper order and combination of preprocessing steps, optimization of their corresponding parameters, together with searching for the optimal model and its hyper-parameters. Because of close dependencies among various steps, we can consider the entire process to be a pipeline optimization problem (POP). POP requires simultaneous optimization of pipeline structure and parameter adaptation of its elements. As a consequence, having an elegant way to express pipeline structure helps in the analysis and implementation of the optimization routines. ### Package Features - Pipeline API that allows high-level description of processing workflow - Common API wrappers for ML libs including Scikitlearn, DecisionTree, etc - Symbolic pipeline parsing for easy expression of complexed pipeline structures - Easily extensible architecture by overloading just two main interfaces: fit! and transform! - Meta-ensembles that allow composition of ensembles of ensembles (recursively if needed) for robust prediction routines - Categorical and numerical feature selectors for specialized preprocessing routines based on types To illustrate, a typical machine learning workflow that extracts numerical features (numf) for ICA (independent component analysis) and PCA (principal component analysis) transformations, respectively, concatentated with the hot-bit encoding (ohe) of categorical features (catf) of a given data for RF modeling can be expressed in AMLP as: ```julia julia> model = @pipeline (catf |> ohe) + (numf |> pca) + (numf |> ica) |> rf julia> fit!(model,Xtrain,Ytrain) julia> prediction = transform!(model,Xtest) julia> score(:accuracy,prediction,Ytest) ``` PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/AD7TQW/ Red Track Paulito Palmes PUBLISH AKY8V7@@pretalx.com -AKY8V7 EvoTrees for Flexible Gradient Boosting Trees en en 20200729T134000 20200729T135000 001000 EvoTrees for Flexible Gradient Boosting Trees PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/AKY8V7/ Red Track Jeremie Desgagne-Bouchard PUBLISH ACJRET@@pretalx.com -ACJRET Generating automatically labelled ML datasets with Lattice.jl en en 20200729T135000 20200729T140000 001000 Generating automatically labelled ML datasets with Lattice.jl Machine learning datasets are samples taken from a domain and an underlying data generating distribution. For example, the MNIST dataset is a sample from the set of all 28x28 grayscale images (the domain) that are created by humans writing the digits 0-9 (the data generating distribution). The examples in datasets are used to train models to perform machine learning tasks; for MNIST, the task is usually “what digit is this?” but the task could also be “is this digit odd?” or “was this digit written by a left-handed person?” Creating the label for each example--evaluating the task applied to that example--usually requires some sort of human effort. Lattice.jl provides a framework for describing and abstracting domains, data generating distributions, and machine learning tasks for those problems where it is possible for a computer program to automatically generate examples. To explain the usefulness of such a framework, consider generating examples from an image domain. Since Lattice first generates a simple internal representation of the example and then uses the representation to draw the image, it is also possible to automatically create perfect labels for a wide variety of different tasks applied to each image. The labels and generating distributions can be manipulated to simulate many different kinds of labeling error and bias, and these problems can be introduced to completely different datasets in a systematic way. This talk will provide a brief overview of the motivation and use cases for Lattice, and then show how the library relies on Julia’s type system to automatically pair abstract machine learning tasks with all of the domains where the tasks make sense. (For example, the abstract task “is X contained by Y?” can be instantiated and applied to images with at least two polygons, or images with bitmaps of a bird and a cage, but not to images of a single digit. In Lattice, pairs of domains and tasks don't need to be manually specified.) We’ll also show how multiple dispatch in Julia makes the implementation of Lattice--and the addition of new domains and tasks--remarkably simple. Finally, we'll share a few examples of using Lattice datasets with Flux.jl to study representation learning and hyperparameter optimization. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/ACJRET/ Red Track Don March PUBLISH UCQCSN@@pretalx.com -UCQCSN Keynote: Karen Willcox en en 20200729T142000 20200729T150500 004500 Keynote: Karen Willcox Scientific Machine Learning: Where Physics-based Modeling Meets Data-driven Learning PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon2020/talk/UCQCSN/ Red Track Karen Willcox PUBLISH UTGXSH@@pretalx.com -UTGXSH Diversity and Inclusion Efforts in the Julia Community en en 20200729T150500 20200729T151500 001000 Diversity and Inclusion Efforts in the Julia Community PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/UTGXSH/ Red Track Logan Kilpatrick PUBLISH DWCJUK@@pretalx.com -DWCJUK Juno 1.0 en en 20200729T151500 20200729T154500 003000 Juno 1.0 [Juno](https://junolab.org/) is an IDE for Julia which enables an unique, powerful and very interactive development style. It is also the oldest still maintained IDE for Julia and, as such, has undergone drastic changes during the last few years. Due to limitations around the current package infrastructure, there also have been some longstanding and fundamental problems, mostly around installation, updating, activation time, and interference with user's own package environment. In this presentation we are going to present Juno 1.0. We will give examples of both basic workflows and more arcane features as well as explain how we tackled the problems outlined above; as such, the talk will be split in two parts: A showcase of Juno's current state, and a discussion of internals and planned improvements. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/DWCJUK/ Red Track Shuhei Kadowaki Sebastian Pfitzner PUBLISH HZRHEL@@pretalx.com -HZRHEL Julia Computing en en 20200729T154500 20200729T155000 000500 Julia Computing PUBLIC CONFIRMED Sponsor Talk https://pretalx.com/juliacon2020/talk/HZRHEL/ Red Track PUBLISH XW9PNR@@pretalx.com -XW9PNR Using Julia and group theory to describe Molecular Vibrations en en 20200729T161000 20200729T162000 001000 Using Julia and group theory to describe Molecular Vibrations We present an overview of the program for the description and classification of molecular vibrations we have been developing using Julia, along with a systematic and highly effective method derived from applied group theory. This overview emphasizes the computational challenges that this real-time description presents and the solutions offered by Julia. The description of molecular vibrations in real-time implies a series of complex and highly demanding computational tasks that we have implemented in Julia : 1) Given the coordinates of the atoms as input, we determine the point symmetry group of the molecule. Extensive use of matrices and fast calculation of eigenvectors and eigenvalues is a must. 2) Once the point group is determined, we identify the symmetry operations using their matrix representations. Once again, we have relied on Julia's capabilities of matrix diagonalization, this time in the case of asymmetric matrices with complex eigenvalues and eigenvectors. 3) Finally we determine and classify the normal modes of vibration using a matrix representation of invariant subspaces that allow a complete classification of the vibrational modes. Only we have to add that, knowledge of the molecular vibrational modes is a must in many scientific and technological applications. Its importance is out of discussion. Although many programs have been developed, mainly in Fortran, most of them are highly sophisticated and depends upon expensive hardware resources. Julia offers the invaluable opportunity to develop a simple, reliable and low-cost resources program with high standard of quality that requires no more than a simple laptop. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/XW9PNR/ Red Track León Alday Roberto Bernal-Jaquez PUBLISH GALAX8@@pretalx.com -GALAX8 AlgebraicJulia: Applied Category Theory in Julia en en 20200729T162000 20200729T165000 003000 AlgebraicJulia: Applied Category Theory in Julia Applied Category Theory builds on algebraic interpretations of type systems to represent mathematical reasoning in a universal way. This allows the construction of domain specific logics that can capture the reasoning systems employed by programmers, scientists, and engineers in differing applications. The Julia type system is sufficiently sophisticated to support implementations of these domain specific logics, while the metaprogramming facilities support the implementation of domain specific languages for describing systems within these domain specific logics. This talk will illustrate how features of Julia interact to create an ideal environment for implementing such abstract and mathematical structure in code, and feature some specific applications to the technical computing community. Such examples include, reasoning about linear maps graphically, constructing scientific models of chemical or biological systems via model composition, and hierarchical design of complex systems. The algebraic approach used in this ecosystem illustrates how many techniques in computer science that represent processes as graphs with mathematical interpretations are related on a deep level. The generic programming capabilities of julia combined with low cost abstractions allow us to realize this similarity in the structure of our software, which reveals and leverages the similarity between application areas to build cohesive tooling for diverse applications. This talk will present code developed in the Catlab.jl, Petri.jl, and SemanticModels.jl packages. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/GALAX8/ Red Track James Fairbanks Micah Halter PUBLISH XEELRW@@pretalx.com -XEELRW Solving Neuroinformatics' Three Language Problem With Julia en en 20200729T165000 20200729T172000 003000 Solving Neuroinformatics' Three Language Problem With Julia Neuroscience relies on the development of highly technical mathematical and computational techniques. These techniques are subsequently used and empirically validated and interpreted with the assistance of neuroscientists. This dynamic results in an additional step to the classic two-language problem, communication between fields that often have a very different knowledge base. Often this communication gap is managed by a common coding language. However, the increasing demand for incorporating multiple modalities and larger sample sizes into data analyses is incompatible with most languages used by neuroscientists (e.g., Matlab, R, Python). Consequently, neuroscientists are often using outdated techniques and those developing newer techniques struggle to reach broader adoption for empirically testing and improving their work. We will show how Julia can help solve the three-language problem through a common programmatic language and the interaction between generic code bases across different fields by introducing the [NeuroCore]( https://github.com/JuliaNeuroscience/NeuroCore.jl) package and related resources. We will begin by providing a high-level overview of how NeuroCore provides a generic API and access to flexible types. We will provide examples illustrating how this design can be easily extended and incorporated by others. We will then provide brief examples of current and planned uses of NeuroCore, including plotting, graph theory, file format access, and data wrangling. Finally, we will show how this design will facilitate natural integration into other components of the Julia ecosystem. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/XEELRW/ Red Track Zachary P Christensen PUBLISH CUMDLK@@pretalx.com -CUMDLK Whole-brain systems neuroscience with Julia en en 20200729T172000 20200729T173000 001000 Whole-brain systems neuroscience with Julia For analysing imaging and behavioral data I am developing two packages: Calcium.jl - for extraction of lower-dimensional neuronal signals from dense, volumentric imaging data. It provides non-negative matrix factorization or local correlation-based methods as well as visualization, pre- and postprocessing tools. Fishyfits.jl - defining interfaces and providing methods for simple models that can be fit and compared across behavioral data and neural activity, building on Julia's extensive model fitting and optimization toolkit. I will discuss some challanges on developing codebases that have to interoperate with Python pipelines, as Julia is not yet widespread in our lab or the wider neuroscience community. Finally, I will showcase [examples from our publications](https://github.com/portugueslab/Dragomir-et-al-2019-modelfit) on using Binder for sharing reproducible analyses. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/CUMDLK/ Red Track Vilim Štih PUBLISH 7MYVV3@@pretalx.com -7MYVV3 Computational tools for designing modular biosystems en en 20200729T173000 20200729T174000 001000 Computational tools for designing modular biosystems Biological systems are intrinsically modular: proteins contain functional units, pathways are formed by linking enzymatic steps and, at the highest level, different species form a functional ecosystem. This property allows for engineering those biosystems, from designing new proteins and pathways to selecting organisms to optimize ecosystem function. In our work, we combine tools from machine learning, optimization and bioinformatics to create novel biological entities. We found Julia an excellent language that allows us to rapidly explore ideas while still maintaining computational efficiency. In this talk, we will discuss some case studies, including selecting optimal bacterial co-cultures for BAM demineralization and the design of enzybiotic proteins using Bayesian optimization. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/7MYVV3/ Red Track Michiel Stock PUBLISH PARPJU@@pretalx.com -PARPJU NeuralProcesses.jl: Composing Neural Processes with Flux en en 20200729T180000 20200729T181000 001000 NeuralProcesses.jl: Composing Neural Processes with Flux (Conditional) Neural Processes ((C)NPs) [^1] [^2] are a rich class of models that parametrise the predictive distribution through an encoding of the observed data. Their flexibility allows them to be deployed in a myriad of applications, such as image completion and generation, time series modelling, and spatio-temporal applications. Neural Processes have enjoyed much interest recently, resulting in the development of several well-performing members of the Neural Process family. As an effort to accelerate the development and evaluation of NP architectures, we present NeuralProcesses.jl [^3], a framework for NPs built on top of Flux.jl. NeuralProcesses.jl provides basic building blocks that can be flexibly composed and mixed and matched to reconstruct many (conditional) neural process architectures from the literature, as well as expand to novel architectures. A recently introduced new member of the neural process family, called the Convolutional Conditional Neural Process (ConvCNP) [^4], proposes to account for _translation equivariance_ in the data: if the observations are shifted, then the predictions should be shifted accordingly. Translation equivariance is an important inductive bias for many learning problems, such as time series, spatial data, and images. The ConvCNP has been demonstrated to achieve state-of-the-art performance on several established NP benchmarks. In this talk, we give a brief introduction to meta-learning, the neural process family, and NeuralProcesses.jl. To demonstrate the abstractions of NeuralProcess.jl, we walk through an implementation of the ConvCNP. We will then use the ConvCNP to predict a sawtooth wave, an otherwise challenging task due to the wave's discontinuous nature. We conclude with a brief demonstration of how the building blocks of NeuralProcess.jl can be used to construct several prominent NP architectures. [^1] https://arxiv.org/abs/1807.01613 [^2] https://arxiv.org/abs/1807.01622 [^3] https://github.com/wesselb/NeuralProcesses.jl [^4] https://openreview.net/forum?id=Skey4eBYPS PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/PARPJU/ Red Track Wessel Bruinsma PUBLISH PUHBMG@@pretalx.com -PUHBMG Applying Differentiable Programming to the Dark Channel Prior en en 20200729T181000 20200729T182000 001000 Applying Differentiable Programming to the Dark Channel Prior This talk will briefly discuss the Dark Channel Prior implementation and will emphasize how it is possible to parameterize the algorithm and replace key portions with small neural networks. It will also cover gathering useful data and defining a meaningful loss function for measuring the performance of the dehaze algorithm. The hope is that others will see how programming in Julia can allow for easy application of differentiable programming in variety of scientific domains. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/PUHBMG/ Red Track Vandy Tombs PUBLISH MR9QWA@@pretalx.com -MR9QWA Exploring Disease Vector Dynamics Under Environmental Change en en 20200729T182000 20200729T183000 001000 Exploring Disease Vector Dynamics Under Environmental Change Improved knowledge of mosquito population dynamics can help control the spread of the diseases they carry. However, the interactions that inform such dynamics are complex. Computational models furnish an effective means for scientists to probe the environmental sensitivities of disease vectors. I use DifferentialEquations.jl to develop a metapopulation model parameterized with empirical data, with which I explore the effect of various environmental scenarios on the population dynamics of malarial mosquitos. I briefly distill the entomological and public health implications of my results, and then explicate my approach to applying the DifferentialEquations.jl platform to this scientific question. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/MR9QWA/ Red Track Valeri Vasquez PUBLISH RYFMY9@@pretalx.com -RYFMY9 SciML: Automatic Discovery of droplet fragmentation Physics en en 20200729T183000 20200729T190000 003000 SciML: Automatic Discovery of droplet fragmentation Physics In this study, we consider a canonical fragmentation problem in fluid mechanics: splash of a drop on a liquid layer. Although this phenomena occurs in the twinkling of an eye (20 - 30 ms), it is an exquisitely regulated phenomena. The splash is typically accompanied by the formation of a thin cylindrical liquid sheet rising upwards, which resembles a crown. The crown sheet dynamics is typically characterized by a coupled set of mass and momentum balance equations. The thickness of the sheet is of the order of microns. In addition, the crown sheet thickness is found to have a spatial and temporal dependence, making it a dynamically changing quantity and difficult to probe experimentally. The sheet thickness has only recently been experimentally measured and theoretically validated in prior studies. In the present work, we use a neural architecture to approximate the sheet thickness profile and use it in combination with the crown mass and momentum balance equations. We show that the thickness profile predicted by the trained neural architecture matches well with the experimentally measured thickness profile. In addition, the trained neural network is also able to recover the spatial and temporal dependence of the thickness profile, which matches well with the theoretically derived dependencies. This augmentation of scientific modeling with neural networks is thus shown to play a major role in speeding experimentally driven inquiries, especially when studying dynamically varying quantities which are difficult to measure; such as the sheet thickness in this system. In addition, such augmentation paves way to make neural architectures more interpretable even when working with small datasets. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/RYFMY9/ Red Track Raj Dandekar PUBLISH RRNYRW@@pretalx.com -RRNYRW On the State of Flux en en 20200729T190000 20200729T193000 003000 On the State of Flux [Flux.jl](https://github.com/FluxML/Flux.jl) has been evolving with a host of improvements from the ground up. A major change from last year is that we have officially launched a stable release that uses [Zygote.jl](https://github.com/FluxML/Zygote.jl) as its AD package, opening up a lot more of the ecosystem to take advantage of it. We will show how well it plays with Julia’s existing state-of-the-art packages enabling more kinds of modelling than ever, and show how the community is taking advantage of it. We will also showcase Flux’s new APIs and features that open up the awesome open-source community to express more complex ideas and bring domain skills into their ML stories. We will show how we’ve worked on improving performance through a myriad changes across the ecosystem, while keeping it easy to use as ever. We would also discuss the design patterns that enable users to write elegant and performant Julian code that can best take advantage of the powerful automatic differentiation capabilities that we have built over time. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/RRNYRW/ Red Track Dhairya Gandhi PUBLISH WGAHCK@@pretalx.com -WGAHCK When compiler technology meets Market Risk Management en en 20200729T123000 20200729T130000 003000 When compiler technology meets Market Risk Management This talk tackles the main issue regarding the development of solutions for market risk management: given a financial contract, one must know how to price it, but it is also required to understand how the pricing formula reacts to changes in the market prices. This project was heavily inspired by Julia Computing's [Miletus.jl](https://github.com/JuliaComputing/Miletus.jl), but goes one step further: given a financial contract, it is now possible to automatically map its risk factors. A general solution is based on [ForwardDiff.jl](https://github.com/JuliaDiff/ForwardDiff.jl). Alternative methods can be included in the system by making use of Julia's multiple-dispatch. Compiler algorithms were used on top of Julia's [JIT compiler](https://en.wikipedia.org/wiki/Just-in-time_compilation) to generate pricing formulas. Using a customized [IR](https://en.wikipedia.org/wiki/Intermediate_representation) defined in [OptimizingIR.jl](https://github.com/felipenoris/OptimizingIR.jl) it is possible to represent a pricing function that would require a billion nodes on an [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) with just a few thousand instructions in the optimized IR. With this setting, this solution provides: * Scalability: compile millions of pricing functions without breaking Julia. * Automated Auditing: automatically generate documentation on how the calculation is performed, as often required by market regulators and auditing firms. * Cashflow projection: given that functions are not restricted to return a single number, it is possible to compile pricing functions that also return intermediate results. * Take advantage of context: compile a whole portfolio to a single pricing function, and all repeated intermediate steps in the calculation are done only once, without losing detail on pricing results for each contract in the portfolio. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/WGAHCK/ Green Track Felipe Noronha Tavares Lucas Processi PUBLISH FW7W9D@@pretalx.com -FW7W9D Jusdl.jl - Julia Based System Description Language en en 20200729T130000 20200729T133000 003000 Jusdl.jl - Julia Based System Description Language Numerical simulations can be expressed as solving the mathematical equations--derived from the modeling--and/or processing the data obtained from those equations. Based on the properties of the system at hand and the level of abstraction in the modeling, the mathematical equations may be ordinary, stochastic, delay differential or difference equations. Although different simulation environments have been developed for numerical simulations of systems, they are able to simulate mostly the models represented by ordinary differential or differential-algebraic equations. This is restrictive when considering the diversity of mathematical models that can be encountered. In Jusdl.jl, it is possible to simulate discrete-time and continuous-time, static or dynamical systems. In particular, it is possible to simulate dynamical systems modeled by different types of differential equations such as ODE(Ordinary Differential Equation), Random Ordinary Differential Equation(RODE), SDE(Stochastic Differential Equation), DDE(Delay Differential Equation) and DAE(Differential-Algebraic Equation), and discrete difference equations. During the simulation, the data flowing through the links of the model can be processed online and specialized analyzes can be performed. These analyses can also be enriched with plugins that can be defined using the standard Julia library or various Julia packages. The simulation is performed by evolving model components individually and in parallel in sampling time intervals. The individual evolution of the components allows the simulation of the models including the components that are represented by different kinds of mathematical equations. Key features of Jusdl.jl includes * Simulation of a large class of systems: * Static systems (whose input, output relation is represented by a functional relation) * Dynamical systems (whose input, state and output relation is represented by difference or differential equations) * Dynamical systems modelled by continuous time differential equations: ODE, DAE, RODE, SDE, DDE * Dynamics systems modelled by discrete time difference equations. * Simulation of models consisting of components that are represented by different type mathematical equations * Individual construction of components, no need to construct a unique equation representing the whole model * Online data analysis through plugins * Flexibility to enrich the data analysis scope through user-defined plugins PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/FW7W9D/ Green Track Zekeriya SARI PUBLISH DBGWXK@@pretalx.com -DBGWXK Salsa.jl: A framework for on-demand, incremental computation en en 20200729T133000 20200729T140000 003000 Salsa.jl: A framework for on-demand, incremental computation Incremental computation reframes the way we build responsive systems such as databases, compilers, ML applications, spreadsheets, and web apps. Performing the minimal amount of computation needed to update a result means avoiding re-running a full computation, boosting performance. Modern compilers are one such challenging responsive system. Programmers expect tools (Atom, VSCode) to understand their programs _while typing_, and to provide syntax highlighting, cross-linking, error indicators, auto-completion and documentation. IDEs essentially need a full-blown compiler front-end. To facilitate this, modern compilers are no longer designed as batch compilers consisting of distinct passes, but rather with on-demand usage as a primary use case (eg by allowing cheaply type-checking a function while accepting errors). To meet this challenge, state-of-the-art compilers employ generic frameworks for incremental computing. Rust uses the [salsa](https://github.com/salsa-rs/salsa) framework (see this [PLISS 2019 recording](https://youtu.be/N6b44kMS6OM) for an in-depth discussion). In this talk, we introduce [Salsa.jl](https://github.com/RelationalAI-oss/Salsa.jl), which is inspired by Rust's salsa. Salsa.jl (like incremental computing frameworks in general) takes away the guesswork in building efficient incremental systems through its automatic dependency tracking and cache invalidation via versioning. Salsa.jl also introduces novel incremental computation features such as _maintaining_ computations, recursion, and improved dependency analysis. For example, thanks to Julia, Salsa is extensible and supports using existing automatic differentiation tools to maintain computations. We use Salsa in production to build a declarative programming language and database system with fast incremental evaluation and immediate feedback. As a novel use-case, we show how Salsa makes it easy to implement a multi-stage language where compilation and evaluation are interleaved. We show how to use Salsa to build a small on-demand compiler and an incremental spreadsheet that is correct by construction. Salsa takes advantage of Julia's meta-programming features and design choices, such as macros, dynamic computation, multiple dispatch, excellent performance, and bias towards immutable data structures. This talk demonstrates that Julia is a remarkably pleasant and productive language for implementing compilers and for incremental computation more broadly. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/DBGWXK/ Green Track Nathan Daly PUBLISH MCQHT3@@pretalx.com -MCQHT3 Estimation of Macroeconomic Models en en 20200729T161000 20200729T162000 001000 Estimation of Macroeconomic Models I will present on new features of DSGE.jl. Tentatively, they will be DSGEVARs and HMC. Dynamic Stochastic General Equilibrium (DSGE) models are workhorse tools at central banks. DSGEVAR methods allow economists to assess misspecification of DSGEs by comparing them to atheoretic vector autoregressions (VAR). The idea is to use DSGEs as priors for VARs in a Bayesian framework. These priors can be implemented by creating pseudo-data from a DSGE. The weight on the prior is determined by a hyperparameter. Larger values of the hyperparameter imply stronger belief that the DSGE explains the data. By finding the hyperparameter which maximizes the marginal data density of a DSGEVAR, we can evaluate misspecification relative to VARs. We build a simple user interface for DSGEVARs on top of DSGE.jl’s modeling approach, allowing users to easily estimate DSGEVARs and apply them in economic analysis. Hamiltonian Monte Carlo (HMC) improves sampling efficiency during estimation of DSGEs because DSGEs have large sets of parameters. MCMC methods face a trade-off between exploring the parameter space and sampling from high-probability regions. This trade-off worsens in high dimensions. By using information from the gradient of the likelihood, HMC handles this trade-off better than other algorithms like Metropolis-Hastings. Applying HMC to DSGEs is difficult, however, because DSGEs have complex likelihood functions. Autodifferentiation is not immediately possible since calls to LAPACK are made during the likelihood calculation. We use the implicit function theorem to avoid calling LAPACK, which allows us to apply ForwardDiff.jl’s autodifferentiation for fast, accurate, and user-friendly gradient computation. We then write wrappers for the likelihood function and gradient to make it compatible with DynamicHMC.jl’s interface. Depending on research progress, I may also discuss tools to estimate nonlinear models. Unless Monte Carlo methods like particle filters are applied, it is difficult to compute the likelihoods of nonlinear models. Parallelization is required to effectively use these methods, but for most computing environments, this restriction forces users to use sequential Bayesian estimation algorithms, which are slow. In Julia, however, we can run nested parallel for loops. We combine SMC.jl’s Sequential Monte Carlo estimation algorithm with StateSpaceRoutines.jl’s Tempered Particle Filter to perform a “double-parallel” estimation of nonlinear economic models. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/MCQHT3/ Green Track William Chen PUBLISH LQLP9P@@pretalx.com -LQLP9P Convex.jl: where are we and where do we want to go? en en 20200729T163000 20200729T164000 001000 Convex.jl: where are we and where do we want to go? Convex.jl is a modelling language for solving convex optimization problems. This is a class of problem that, when modelled correctly, can be efficiently and accurately solved to global optimality. Convex.jl provides a simple and convenient modelling language that transforms user-entered problems into a structured form which, via the intermediary layer MathOptInterface.jl, is passed to solvers which can then exploit the structure to efficiently solve the problem. We will discuss Convex.jl’s recent update from using the deprecated MathProgBase as an intermediary layer to instead using the actively developed MathOptInterface (which also powers JuMP). Among other things, this enables Convex.jl to formulate problems specified using generic numeric types and send problems to high-precision solvers in order to accurately calculate optimal values of optimization problems to many decimal places. We will also see how to build domain-specific abstractions on top of Convex.jl to provide convenient interfaces for formulating problems in field-specific contexts by using custom variable types and a new feature that allows variables to carry around their own constraints. We will also see some new tooling: a library of end-to-end tests for MathOptInterface-compatible optimization solvers, and infrastructure to run the tests in parallel on GitHub Actions and display the results on a convenient webpage. Lastly, we will discuss plans for Convex.jl’s next steps, to make it more efficient and even easier to extend, and invite the audience to help build that future. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/LQLP9P/ Green Track Eric P. Hanson PUBLISH RXAN8F@@pretalx.com -RXAN8F What's new in Pkg: artifacts, binaries & the Pkg protocol en en 20200729T164000 20200729T171000 003000 What's new in Pkg: artifacts, binaries & the Pkg protocol This talk will go over the high-level design of the artifact system, how BinaryBuilder lets you easily build binaries for dozens of platforms and get them in the hands of Julia users with unprecedented ease. The bottom line: no client-side build step means no client-side build failures. The new Pkg protocol makes it faster and easier to use the package manager behind a firewall or in countries that don't happen to be close to GitHub's servers. No more libgit2/proxy woes. In Julia 1.5 the Pkg protocol will be the default way that Julia clients get packages and artifacts, making it easier for Julia users everywhere to get packages. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/RXAN8F/ Green Track Elliot Saba Stefan Karpinski PUBLISH KTDY7J@@pretalx.com -KTDY7J Probabilistic Optimization with the Koopman Operator en en 20200729T171000 20200729T172000 001000 Probabilistic Optimization with the Koopman Operator The probabilistic optimization of dynamical systems is often framed to minimize the expectation of a given loss function. For non-linear systems, the evaluation of such a loss function and its gradient can be expensive. Often times practitioners rely on implicit methods, such a Monte Carlo simulation, for this calculation due to ease of implementation and understanding. Alternatively, explicit methods such as the Frobenious-Perron Operator can be leveraged to directly evolve probability densities through non-linear systems. Furthermore, the adjoint to the Frobenious-Perron Operator, the Koopman Operator, can be leveraged to the same ends. In this work we will demonstrate how the adjoint property of the Koopman Operator provides significant computational advantages over alternative methods for calculating expectations. We also demonstrate how this Koopman-based approach is AD-compatible. Building on Julia's differential equation ecosystem, this Koopman-based approach is available in [DiffEqUncertainty.jl](https://github.com/JuliaDiffEq/DiffEqUncertainty.jl) PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/KTDY7J/ Green Track Adam R. Gerlach PUBLISH YDSABY@@pretalx.com -YDSABY Multi-Physics 3-D Inversion on GPU Supercomputers with Julia en en 20200729T172000 20200729T173000 001000 Multi-Physics 3-D Inversion on GPU Supercomputers with Julia The adjoint-based multi-physics inversion framework we present enables the development of efficient and massively scalable 3-D multi-GPU solvers with **application to optimisation problems**. We use an **iterative matrix-free pseudo-transient approach** and the finite difference method to solve the forward and the adjoint coupled two-phase flow equations. We achieve efficient calculations of the pointwise gradients of the flow solution with respect to the porosity. We then use the gradients in a gradient descent method to reconstruct the pointwise porosity in 3-D. We assess the performance of the 3-D memory-bounded solvers using a **simple effective memory throughput metric**. We finally discuss how the **overlap of computations with MPI communications** permits us to achieve a close to optimal parallel efficiency. We rely on the `ParallelStencil` and `ImplicitGobalGrid` packages for high-performance stencil-based calculations and optimal distributed memory parallelisation. **Co-authors** - Georg Reuber, Samuel Omlin PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/YDSABY/ Green Track Ludovic Räss Georg Samuel Omlin PUBLISH SD8PSC@@pretalx.com -SD8PSC Terminal User Interfaces in Julia en en 20200729T173000 20200729T174000 001000 Terminal User Interfaces in Julia Terminal User Interfaces can be developed using in-band ANSI escape and control sequences. Using the various escape and control sequences we can move the cursor to any position, erase lines or part of the screen, set formatting options such as bold, italic, foreground color, background color, change the cursor shape, etc. In this lightning talk I will go over some examples of building terminal user interfaces in Julia. The presentation will feature ANSI escape sequences; TERMIOS settings, such as cooked, raw and cbreak modes; reading stdin and write to stdout while in these various modes, etc. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/SD8PSC/ Green Track Dheepak Krishnamurthy PUBLISH JQLXBK@@pretalx.com -JQLXBK Loop Analysis in Julia en en 20200729T180000 20200729T183000 003000 Loop Analysis in Julia I will give a brief introduction to loop vectorization in Julia, discussing practical issues such as the benefit of contiguous loads and stores and how they relate to data layout decisions such as arrays of structs versus struct of arrays. The emphasis of the low level discussion will be the extreme level of parallelism within a single modern CPU core (a single AVX512 core can have up to 128 concurrent double precision floating point operations: 8 Float64 per vector * 2 operations / fma * 2 instructions executed / cycle * 4 cycles latency), emphasizing the need for parallel programming paradigms like SPMD. LoopVecorization.jl can be thought of as treating loops like a familiar DSL for specifying dependencies between operations (such as arithmetic and loads or stores) and loops, without regard to any order aside from that inherent in the dependency chains. The library has infrastructure for modeling the cost of evaluating a loop nest using different orders of the constituent loops, and different unrolling and blocking factors of the loops. The advantage is demonstrated in allowing writing high performance code that is generic with respect to the data layout of the underlying arrays, with the order of evaluated loops and data access pattern shifting in response to transposed arrays without any change in the user's code. Next, the advantage of the simple representation of loops as dependencies between operations and loops for automatic differentiation is demonstrated. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/JQLXBK/ Green Track Chris Elrod PUBLISH XKG7TT@@pretalx.com -XKG7TT SymbolicTensors.jl -- high-level tensor manipulation in Julia en en 20200729T183000 20200729T184000 001000 SymbolicTensors.jl -- high-level tensor manipulation in Julia Many numerical tensor manipulation packages exist (e.g. `Einsum.jl`), but treating tensors at a purely numeric level throws away a lot of potential optimizations. Often, it's possible to exploit the symmetries of a problem to dramatically reduce the calculation steps necessary, or perform some tensor contractions symbolically rather than numerically. `SymbolicTensors.jl` is designed to exploit these simplifications to generate more efficient input into numeric tensor packages than you would write by hand. It based on `SymPy.jl`, `sympy.tensor.tensor`, and `ITensors.jl`. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/XKG7TT/ Green Track Robert Rosati PUBLISH 3JSMMG@@pretalx.com -3JSMMG Concatenation and Kronecker products of abstract linear maps en en 20200729T184000 20200729T185000 001000 Concatenation and Kronecker products of abstract linear maps Linear maps (or operators) are ubiquitous in the mathematical sciences, modeling and scientific computing. In many problems, linear maps are not necessarily given by some matrix representation, but as programs that transform vectors in a linear fashion. Such linear programs can be used, for instance, in iterative linear algebra methods synonymously to usual matrices by wrapping them with the `LinearMaps.jl` package. With this package, more complicated linear maps can be constructed lazily from simple linear function maps or wrapped matrices via scaling, addition, multiplication, transposition and taking the adjoint. Recently, two further classes of such operator algebraic operations have been added to the aforementioned traditional set of operations in `LinearMaps.jl`: horizontal, vertical and diagonal (block) concatenation and Kronecker products, sums, and powers. These operations feature prominently in applications like structured optimization and image reconstruction. Their implementation in `LinearMaps.jl` facilitates top performance even in the classic matrix context due to their laziness and type-stable usage of specialized multiplication methods. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/3JSMMG/ Green Track Daniel Karrasch PUBLISH NMGTD9@@pretalx.com -NMGTD9 SIMD in Julia - Automatic and explicit en en 20200729T185000 20200729T190000 001000 SIMD in Julia - Automatic and explicit SIMD (Single Instruction, Multiple Data) is a term for when the processor executes the same operation (like addition) on multiple numbers (data) in one instruction. Recent processor architectures come with the capability of running these SIMD instructions on even larger batches of data, making it more important to make sure that SIMD is used when possible, for best performance. Fortunately, in many cases, Julia can automatically make code use SIMD. Often this comes from optimizations made by LLVM, the code generation library Julia uses. Some cases of this are in: - Loops, where the LLVM Loop Vectorizer can identify patterns where the loop can be unrolled so that multiple iterations can be done When there is a reduction involved, like when summing the elements of an array, the `@simd` macro might be needed. - Different patterns of scalar operations that can be combined into one SIMD instructions, like when adding two tuples. This is vectorized by the LLVM SLP (Superword-Level Parallelism) vectorizer. There are however cases where auto-vectorization like above doesn’t happen. This can be when LLVM does not recognize the opportunity to use SIMD or when it isn’t valid to do so because it could change the result slightly. In cases like this, it is possible to: - Use a “SIMD vector library” like SIMD.jl. This allows one to create a “SIMD Vector” that works similarly to a number but operations on it will work elementwise using SIMD instructions. - Explicitly call machine instructions specific for a certain CPU architecture. This gives the most control but has the drawback of tying the code the CPU architecture, making it less generic. This talk will show discuss and show examples of the above SIMD cases, giving insight into how to leverage SIMD for greater performance. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/NMGTD9/ Green Track Kristoffer Carlsson PUBLISH LEADQ7@@pretalx.com -LEADQ7 Accurate and Efficiently Vectorized Sums and Dot Products en en 20200729T190000 20200729T193000 003000 Accurate and Efficiently Vectorized Sums and Dot Products Computing the dot product of two vectors and, perhaps to a lesser extent, summing the elements of a vector, are two very common basic building blocks for more complex linear algebra algorithms. As such, any change in their performance is likely to affect the overall performance of scientific computing codes; any change in their accuracy is likely to induce a loss of reproducibility in overall computed results. However, both the performance and accuracy of these algorithms is affected by the use of Floating-Point (FP) arithmetic: on the one hand, using smaller FP numbers tends to increase the performance of the computation (through increased memory bandwidth and wider SIMD registers). On the other hand, decreasing the precision of FP numbers also tends to decrease the accuracy if the results. The work presented in this talk tries to address this issue by efficiently implementing [accurate summation and dot product algorithms in Julia](https://hal.archives-ouvertes.fr/hal-02265534). These implementations are available under an open source license in the [AccurateArithmetic.jl](https://github.com/JuliaMath/AccurateArithmetic.jl) package, and aim at high performance by leveraging the SIMD capabilities of modern hardware (esp. AVX-2 & AVX-512). Besides naive algorithms, compensated algorithms are implemented: the Kahan-Babuška-Neumaier summation algorithm, and the [Ogita-Rump-Oishi](http://dx.doi.org/10.1137/030601818) simply compensated summation and dot product algorithms. These algorithms effectively double the working precision, producing much more accurate results while incurring little to no overhead, especially for large input vectors. This talk also tries to build upon this example to make a case for a more widespread use of Julia in the HPC community. Although the vectorization of compensated algorithms is no particularly simple task, Julia makes it relatively easy and straightforward, particularly thanks to existing building blocks in the eco-system such as [SIMDPirates.jl](https://github.com/chriselrod/SIMDPirates.jl). Relying on generic functions and multiple dispatch also allows structuring the code in small, composable building blocks, closely matching textbook algorithms yet efficiently compiled. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/LEADQ7/ Green Track François Févotte Chris Elrod PUBLISH 8VUMUA@@pretalx.com -8VUMUA Parallelization, Random Numbers and Reproducibility en en 20200729T123000 20200729T124000 001000 Parallelization, Random Numbers and Reproducibility Random-number generators present a special problem for both thread- and process-based parallelism, especially when guaranteeing a reproducible, unbiased stream that is independent of the number of concurrent workers. In other words, we require the ability to parallelize a replicated, stochastic operation in such a way that we will get the same result as the serial computation with the same RNG and seed. For thread-based parallelism, this can easily be achieved via a shared RNG with appropriate locking. We demonstrate this with the implementation of the parametric bootstrap in MixedModels. The parametric bootstrap is embarrassingly parallel computation, yet depends on a stochastic element and thus random-number generation. In particular, we examine how the granularity of locking impacts the 'striping' of random numbers across threads and thus reproducibility. We finish by contrasting our approach to the use of 'fast-forwarding' and copying the RNG and discussing issues with generalizing these approaches to process-based parallelism. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/8VUMUA/ Purple Track Phillip Alday PUBLISH L3FYJW@@pretalx.com -L3FYJW DrWatson - The perfect sidekick to your scientific inquiries en en 20200729T124000 20200729T125000 001000 DrWatson - The perfect sidekick to your scientific inquiries DrWatson is the first-of-its-kind scientific project assistant software. It was born out of the frustration about the hardships of managing scientific projects, and constantly re-creating the same functionalities. DrWatson offers several ways to help you manage your project: consistent & universal project structure & navigation, naming schemes, saving tools and simulation management. This talk will introduce and motivate DrWatson and showcase its features in real scientific projects. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/L3FYJW/ Purple Track George Datseris PUBLISH KCP9NT@@pretalx.com -KCP9NT Reproducible environments with Singularity en en 20200729T125000 20200729T130000 001000 Reproducible environments with Singularity As the use of computing in science grows, more scientists are running ever larger computations. However, while the importance and use of a lab notebook is taught in many science degrees, the corresponding best practices for computer use often are not. From personal experience, I can tell that this leads to a growing number of random scripts and result files that after a week can’t be matched anymore. Alternatively, the code is sent to a server, and after requiring some small tweaks, the local and the remote version look different. A google search shows that this is not an uncommon problem, and there is an increasing number of blogs and papers addressing various aspects. In general, there are three aspect to a numerical result: the parameters, the code, and the environment. Specifically in Julia, the first two can be addressed by the combination of DrWatson.jl and Git, which makes it very easy to store the parameters used and the git hash of the commit with the code. This also includes the Manifest file, meaning that one can recreate the exact package environment, which is a major feature of Julia. However, this does not cover the binaries used by many packages. Examples include an NLopt algorithm throwing a segfault only on a specific version of Ubuntu, or a binary that only on Mac clashes with MKL. On the surface, containerization is the solution to these problems, but in practice the group doing the science and the group understanding containers seem mostly disjunct. After being in the first group until a few months ago, I now would like to present my approach and the small package [1] I wrote to facilitate it. It uses the scientific container software Singularity, which is less popular but more specialized than the widely known Docker (like Julia compared to Python). Differing from Docker, Singularity containers support various HPC hardware and software, do not require root to run, and integrate well into resource managers like SLURM. In this talk, I would like to introduce my workflow based on DrWatson.jl and my own measures to create very minimal containers that enable results that are fully reproducible on any machine with the Singularity runtime. This will include general aspects about Singularity and specific one related to incorporating Julia. [1] https://github.com/Crown421/Singularity.jl PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/KCP9NT/ Purple Track Steffen Ridderbusch PUBLISH Z8TE39@@pretalx.com -Z8TE39 Shippable apps and custom sysimages with PackageCompiler.jl en en 20200729T130000 20200729T133000 003000 Shippable apps and custom sysimages with PackageCompiler.jl When a function is to be executed for the first time in Julia there are several steps that need to happen. The code needs to be parsed, type inference has to run, LLVM has to compile it to machine code etc. Depending on the function, this can take some time giving a bit of a latency to the first call of a function. When packages are loaded, there is a precompilation step that takes place that tries to cache some of this work, but even with that the latency before the function actually runs can be significant. Julia comes with a few packages that are already installed and available without having to explicitly add them like normal packages. These are called “standard libraries” and the Julia REPL is one of them. You might have noticed that the Julia REPL loads almost instantly (significantly faster than a “normal” package) even though it is a quite complex package. This is because it is compiled into what is called a “sysimage” which allows more extensive caching of compiled code than the normal package precompilation system. PackageCompiler.jl (which recently had its 1.0 release) is a package that makes it easy to create custom sysimages which can include other packages than the default standard libraries. This can be used in cases where a commonly used package is slow to load or has functions with high overhead for the first call. In addition, PackageCompiler.jl can create apps that can be downloaded and directly run on a machine that doesn’t have Julia installed. It works together with [the artifact system](https://julialang.org/blog/2019/11/artifacts/) allowing automatic bundling of external binaries and libraries. This allows one to ship quite sophisticated apps written in Julia in a simple manner. This talk will expand on the points above and show the API of PackageCompiler.jl v1.0. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/Z8TE39/ Purple Track Kristoffer Carlsson PUBLISH GVFYUF@@pretalx.com -GVFYUF Project Binder and the Julia Community: How can we help each oth en en 20200729T133000 20200729T134000 001000 Project Binder and the Julia Community: How can we help each oth The Binder Project is a collection of tools that rewards best practices in reproducible data science and provides an easy method of sharing computing environments with anyone via a single clickable link. The free and public Binder service, hosted at https://mybinder.org, serves around 100,000 launches per week from over 10,000 individual git repositories in a variety of programming languages, including Julia. Binder is a community-driven project, taking the lead from community-developed standards of reproducibility and input from its users via the mybinder.org user survey. The user survey was last conducted at the beginning of 2020 and a summary of the results will be presented during the lightning talk. There are so many fantastic ideas and features the Binder project team (https://jupyterhub-team-compass.readthedocs.io/en/latest/team.html#binder-team) would like to develop but - like many open source projects - we face time restrictions, a low bus factor (https://en.wikipedia.org/wiki/Bus_factor), and often lack domain expertise when developing language-specific features. Sarah Gibson would like to introduce the Binder Project to the Julia community as an opportunity to shape a tool that would be most useful to them and provide guidance on how to get started with contributing to or joining the project. This lightning talk will (hopefully!) be accompanied by a Birds of a Feather session and/or a drop-in table where Sarah will be available for more in-depth discussions about Binder. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/GVFYUF/ Purple Track Sarah Gibson PUBLISH 87JCMX@@pretalx.com -87JCMX Dependency-Aware Jupyter Notebooks en en 20200729T134000 20200729T135000 001000 Dependency-Aware Jupyter Notebooks The current method for sharing dependency information with Jupyter is simply to send TOML files along with the notebook. This can be difficult (e.g. for students, who may struggle with Julia environments), and generally hampers mobility. The QuantEcon Julia course uses InstantiateFromURL.jl to have notebooks download (version-controlled) TOML from GitHub. We demonstrate its support for both local machines and JupyterHubs. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/87JCMX/ Purple Track Arnav Sood PUBLISH N39HSX@@pretalx.com -N39HSX Julia for scripting en en 20200729T135000 20200729T140000 001000 Julia for scripting The "scripting workflow", i.e. starting Julia, execute a code snippet, and then exit, is often not the recommended method for Julia code. One reason for this is that Julia is a just-in-time (JIT) compiled language, and the first call to a function is usually a lot slower than subsequent calls due to compilation. In a setting such as scripting there might only be one call to a function before exiting Julia. Spending time compiling the function might not be worth it in such a case, unless the faster runtime makes up for it. A simple example is a script that defines a single function, calls it, and then exits. The recommended Julia workflow is instead to keep a single Julia session alive for as long as possible, and reuse it for multiple tasks. Even though two tasks A and B are not be directly related, they may both use, for example, arrays. Thus, after performing task A we have already compiled some array methods, and task B will benefit from that, with reduced compilation time as the result. This interaction is something that scripting can not take advantage of, since compiled methods are forgotten when exiting Julia. The problems presented above have two obvious possible solutions: (i) spend less time compiling and (ii) store compiled methods and make them available in future sessions. For the first option we can use Julias interpreter and only compile whats necessary. This is often a great solution for very short-running tasks, and requires nothing extra, just some command line flags to Julia. The second option is a bit more involved (although nowadays pretty easy using the PackageCompiler.jl package), however, it can completely elimitate runtime compilation. The downside is that the compiled and cached methods live in a separate file that needs to be bundled with the script. This talk will discuss how Julia can be used for scripting, present some tips and tricks on how to make scripting more viable, and show some succesful examples of the two solutions presented above. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/N39HSX/ Purple Track Fredrik Ekre PUBLISH 9BNNMD@@pretalx.com -9BNNMD Poster Session 1 en en 20200729T161000 20200729T174000 013000 Poster Session 1 - ["Calling a parallel simulation code from Julia" by Marc Fuentes](https://pretalx.com/juliacon2020/talk/review/N8LZSTA9TXYJ87F7YV8AMHCWJHLCDWXU) - ["Fast global optimization on the GPU" by David P. Sanders](https://pretalx.com/juliacon2020/talk/review/WWDA9KCPBAPBAYXBKTBP8DDKCXRTRSHP) - ["Simple Layers for Species Distributions Modelling in Julia" by Gabriel Dansereau](https://pretalx.com/juliacon2020/talk/review/7GFU7NSWMXTTEABSZKQZNCUD8K3SXHAT) - ["TrackMatcher – A tool for finding intersections in trajectories" by Peter Bräuer](https://pretalx.com/juliacon2020/talk/review/KMBEMX3UBTXDWWMLPWD7PTFEA3HKJHLQ) - ["Automatic gradient and scale for high dimensional optimization" by Tim Holy](https://pretalx.com/juliacon2020/talk/review/FNVSDEDMJ9VULYDA9PD73NKADEWNUSPP) - ["Supercharging your data science workflows using GitHub Actions" by Chidubem Iddianozie](https://pretalx.com/juliacon2020/talk/review/V8ZUTHUMARTWVH89XCT8EV3KFC7WXGRY) - ["Visual Biology with Makie" by Daniel Kool](https://pretalx.com/juliacon2020/talk/review/RGFUVV9RY393B8GAS7AXWLXYJKFCAPDY) - ["Why we need reversible computing?" by JinGuo Liu](https://pretalx.com/juliacon2020/talk/review/RFDXUXMBWB9PZLBMTXHWXYEQXDY9YPPR) - ["What can imply behind a special weather profile" by Shiqi XIAO](https://pretalx.com/juliacon2020/talk/review/XYNSHG3EPJ7UELFYQQZCKBRAS9V9CUSS) - ["Taylor-Mode for Higher Order Automatic Differentiation" by Jesse Bettencourt](https://pretalx.com/juliacon2020/talk/review/GQCSE3Z7RQ3NJCCAV3UCPQAPWWN9MMRH) - ["Fantastic beasts and how to show them" by Joris Kraak](https://pretalx.com/juliacon2020/talk/review/QFVVVEFEEBYTMVBUDCB7T9LSSDWE8LPH) - ["Deferred Acceptance with Allocation Rules" by Minyoung Rho](https://pretalx.com/juliacon2020/talk/review/EUAAJACBH38FSUGJYASEGZ9FCXNSU9RZ) - ["Large-scale environmental flow simulations with Julia" by Martijn Russcher (Deltares, Delft, the Netherlands) and Frank Platzek (Deltares, Delft, the Netherlands)](https://pretalx.com/juliacon2020/talk/review/SVBMCZWWHFS8GMFYUC7E3DQZ8XGMJPVL) - ["Squaring the circle: polyhedral approximation of convex sets" by Maxim Demenkov](https://pretalx.com/juliacon2020/talk/review/FQUTPSUBADDTFJWLLH3LWXM9FL7GFB9G) - ["CombinatorFormatting.jl: Polymorphic, composable text formatting" by Kusti Skytén](https://pretalx.com/juliacon2020/talk/review/YLGMVPYLRV83DJLERGZEAEEE8CK9TQBC) - ["Vehicle's crew survivability using Julia" by Irene Ndindabahizi](https://pretalx.com/juliacon2020/talk/review/QDZMDQ3WSPZVQCKWYJM9BS3FEYZ8DAU7) - ["Julia for Good Old-Fashioned (Symbolic) Artificial Intelligence" by Johann-Tobias Schäg](https://pretalx.com/juliacon2020/talk/review/3YSBZLVYVSDU7HWF33SSLXFLMHGSABAL) - ["Julia, From a Programming Language Theory Perspective" by Harrison Grodin](https://pretalx.com/juliacon2020/talk/review/AVRZTRDN7LJWNUSXXHJTQXYLS3JWTDJE) - ["BinaryTraits - traits made easy" by Tom Kwong](https://pretalx.com/juliacon2020/talk/review/APB7LSLLDFYNXKBEDY8GNZFEA3FTXSJC) - ["Extending Distributions with Expectations.jl" by Arnav Sood](https://pretalx.com/juliacon2020/talk/review/G3BQVHGVA7VH8LUR7Y83QSTBWEZVTLM3) - ["Machine Learning in Graphs" by Ollin D. Langle-Chimal](https://pretalx.com/juliacon2020/talk/review/GVLJB7AZ9W3XDZ7UQQ9AUU8FVUJG9JF8) - ["Parallel face recognition algorithms using Julia + CUDAnative.jl" by Oscar A. Esquivel-Flores and Óscar Alvarado](https://pretalx.com/juliacon2020/talk/review/KF93SREHJCZSZWYGR7ALLBMAUJYCHKJW) PUBLIC CONFIRMED Minisymposia https://pretalx.com/juliacon2020/talk/9BNNMD/ Purple Track JuliaCon Committee PUBLISH JEWE93@@pretalx.com -JEWE93 A Cloud Relational Database System for Knowledge Graphs in Julia en en 20200729T180000 20200729T183000 003000 A Cloud Relational Database System for Knowledge Graphs in Julia After a brief overview of knowledge graphs and the relational paradigm we describe the foundational design principles and implementation philosophy of the RelationalAI system: - Leverage: how we use cloud computers and modern compilers to reduce engineering effort - Brains and brawn: how we improve the asymptotic performance of our system with new algorithms that exploit problem structure - Aggressive simplification and consolidation: how we build on 5 core capabilities that compose elegantly in ways that cover a broad range of use cases. We then review the first 3 of these 5 core capabilities (the query compiler, incremental maintenance, immutable structures) and touch on the remaining 2 (worst-case optimal joins and semantic optimization) PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/JEWE93/ Purple Track Molham Aref PUBLISH 3NXGGJ@@pretalx.com -3NXGGJ MPI.jl: Julia meets classic HPC en en 20200729T184000 20200729T185000 001000 MPI.jl: Julia meets classic HPC Over 25 years old, MPI is the stalwart of high-performance computing, supported on everything from single machines to billion-dollar supercomputers. Despite its age, it supports several different modes of communication, and lots of engineering effort goes into optimizing bandwidth and reducing latency. However its use with a dynamic language such as Julia presents certain challenges. I’ll start with some simple examples on how its single program, multiple data (SPMD) programming model can be used with Julia. Then I will discuss some implementation details, and highlight some of the unique challenges in supporting this package, from a lack of a standardised application binary interface (ABI), supporting optional CUDA-aware interfaces, and working with specific Julia features, like custom data types and reduction operators. Finally, I’ll describe some additional features and future plans to improve the usability of this venerable library. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/3NXGGJ/ Purple Track Simon Byrne PUBLISH JHCWQA@@pretalx.com -JHCWQA Effectively Using GR en en 20200729T185000 20200729T190000 001000 Effectively Using GR GR is a plotting package for the creation of two- and three-dimensional graphics in Julia and other languages, offering basic MATLAB-like plotting functions to visualize static or dynamic data with minimal overhead. GR is now available for all major platforms and can be easily installed with pre-built binary packages. Using quick practical examples, this talk is going to present the important improvements and features provided by the GR framework for high-performance graphics, in particular when being used for publication-quality Plots in interactive notebooks (Jupyter), development environments (Atom) or terminal programs (iTerm2). One of the often requested innovations in the current GR version is the integrated renderer for scientific formulas in LaTeX format. The presentation also introduces a new meta layer, which provides an interface to interactive backends based on Qt5 or JavaScript. In this context, the improvements in the structure of the GR framework are presented with respect to a more efficient integration into existing plot environments (such as Plots.jl). PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/JHCWQA/ Purple Track Josef Heinen PUBLISH X8LY73@@pretalx.com -X8LY73 DFTK: A Julian approach for simulating electrons in solids en en 20200729T190000 20200729T193000 003000 DFTK: A Julian approach for simulating electrons in solids The quantum-chemical simulation of electronic structures is an established approach in materials reseach. The desire to tackle even bigger systems and more involved materials, however, keeps posing challenges with respect to physical models, reliablity and performance of methods such as DFT. With DFTK (https://dftk.org) we provide a Julia package for DFT, which aims to be fast enough for practical calculations, but also flexible to support toy problems for mathematical development in the field. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/X8LY73/ Purple Track Michael F. Herbst PUBLISH UD7AGC@@pretalx.com -UD7AGC Fancy Array Indexing en en 20200729T161000 20200729T165500 004500 Fancy Array Indexing PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/UD7AGC/ BoF Frames Catherine White PUBLISH F7DKF8@@pretalx.com -F7DKF8 Moving forward on diversity&inclusion in the Julia community en en 20200729T165500 20200729T174000 004500 Moving forward on diversity&inclusion in the Julia community This BoF (and all others) will be on Discord. Please join Discord by clicking on the following link: https://live.juliacon.org/discord/join . To join Discord, you will need the registration ID that you recieved when you signed up for the conference. You will find it in the confirmation email you get from Eventbrite. If you haven't yet registered, please do so immediately at https://juliacon.org/2020/tickets/ PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/F7DKF8/ BoF Huda Nassar August Guang PUBLISH QF8BC7@@pretalx.com -QF8BC7 Project Binder and the Julia Community: Planning for the Future en en 20200729T180000 20200729T184500 004500 Project Binder and the Julia Community: Planning for the Future The Binder Project is a collection of tools that rewards best practices in reproducible data science and provides an easy method of sharing computing environments with anyone via a single clickable link. The free and public Binder service, hosted at https://mybinder.org, serves around 100,000 launches per week from over 10,000 individual git repositories in a variety of programming languages, including Julia. Binder is a community-driven project, taking the lead from community-developed standards of reproducibility and input from its users via the mybinder.org user survey. The user survey was last conducted at the beginning of 2020 and a summary of the results, both general and specific to the Julia community, will be presented. There are so many fantastic ideas and features the Binder project team (https://jupyterhub-team-compass.readthedocs.io/en/latest/team.html#binder-team) would like to develop but - like many open source projects - we face time restrictions, a low bus factor (https://en.wikipedia.org/wiki/Bus_factor), and often lack domain expertise when developing language-specific features. Sarah Gibson would like to introduce the Binder Project to the Julia community as an opportunity to shape a tool that would be most useful to them and provide guidance on how to get started with contributing to or joining the project. PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/QF8BC7/ BoF Sarah Gibson PUBLISH R7EPKS@@pretalx.com -R7EPKS Probabilistic Programming in Julia en en 20200729T184500 20200729T193000 004500 Probabilistic Programming in Julia Possible topics (just a starting point really): - Standardizing output data structures for samplers - Making distributions extensible, and AD- and GPU-friendly - Interop across PPLs - Connecting with non-PPL libraries (e.g. Flux) - What existing (Python, etc) capabilities is Julia PPL missing? - What's next for Julia PPL? - What's next for PPL in general? PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/R7EPKS/ BoF Chad Scherrer PUBLISH RGXHMF@@pretalx.com -RGXHMF Gather Town Social en en 20200729T193000 20200729T201500 004500 Gather Town Social PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/RGXHMF/ BoF PUBLISH GX8QCX@@pretalx.com -GX8QCX Complex graphs in transportation networks with OpenStreetMapX.jl en en 20200730T123000 20200730T124000 001000 Complex graphs in transportation networks with OpenStreetMapX.jl A transportation system or even an entire city can be represented as a complex directed graph embedded in an Euclidean space. Such graph can model real world in 1:1 scale and be used to perform various numerical experiments. The [`OpenStreetMapX.jl`](https://github.com/pszufe/OpenStreetMapX.jl) package makes it possible to load the data from the [OpenStreetMap.org](https://www.openstreetmap.org/) project and processes such graphs with Julia. The package is using [LightGraphs.jl](https://github.com/JuliaGraphs/LightGraphs.jl) to represent the directed graph structure object along with meta related to spatial information. In this talk the following areas will be discussed: - processing of [OpenStreetMap](https://www.openstreetmap.org/) data in Julia to obtain graph structures - visualizing graphs, maps and spatial data with [OpenStreetMapXPlot.jl](https://github.com/pszufe/OpenStreetMapXPlot.jl) (`GR`, `PyPlot` backends) as well as integration with [Leaflet](https://leafletjs.com/) via [folium](https://github.com/python-visualization/folium) and [PyCall](https://github.com/JuliaPy/PyCall.jl) - technical issues and tips for running massive scale agent based simulations (e.g. with 1 million agents) of an entire city with real-world spatial data in 1:1 scale - various examples and scenarios of graph dynamics analysis with simulation models reflecting behavior of people and vehicles in virtual model of a city. This project is co-financed by the Polish National Agency for Academic Exchange. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/GX8QCX/ Red Track Bogumił Kamiński Przemysław Szufel PUBLISH GR9TZH@@pretalx.com -GR9TZH GeoInterface: bringing geospatial packages together en en 20200730T124000 20200730T125000 001000 GeoInterface: bringing geospatial packages together In the Julia documentation, the [example of `Point{T}`](https://docs.julialang.org/en/v1.3/manual/types/#Parametric-Composite-Types-1) is used to introduce parametric types. It is easy to implement your own point type, and many packages have done so. For users, having to convert their points from package A to package B can be bothersome. Besides points, the same applies to other geometries such as lines and polygons, which are commonly used in geospatial workflows. Just agreeing on a single set of types for all uses is unlikely, since the diversity stems from different needs. Some may want to match a particular file format, or wrap pointers through a C API, such as GDAL. Hence, to embrace the diversity and allow smooth workflows involving different geometry representations, we redesigned [GeoInterface.jl](https://github.com/JuliaGeo/GeoInterfaceRFC.jl). It allows you to efficiently convert between any sets of types that implement the interface, without having to know about or depend on the other package. The redesign incorporates many ideas from the Simple Features standard, and was inspired by the success of the [Tables.jl](https://github.com/JuliaData/Tables.jl) interface. Interestingly, we can show examples how these two interfaces can complement each other for tabular data with geometry columns, as seen in [Shapefile.jl](https://github.com/JuliaGeo/Shapefile.jl) and [GeoJSONTables.jl](https://github.com/visr/GeoJSONTables.jl). PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/GR9TZH/ Red Track Martijn Visser PUBLISH GDCEYU@@pretalx.com -GDCEYU Handling large geospatial raster data with the Earth System Data en en 20200730T125000 20200730T130000 001000 Handling large geospatial raster data with the Earth System Data The EarthSystemDataLab.jl allows you to handle geospatial raster data easily and fast. You can load data which is too large for your RAM directly from disk in small enough chunks so that it can be paralllelized without you thinking too much about it. The EarthSystemDataLab establishs a data cube workflow, where low- dimensional functions are applied to higher dimensional cubes by functional extension. This means, that user defined functions can act along a particular subset of the input dimensions and loop then across all other input dimensions to get a new data cube which has the unspecified dimensions as well as the output dimensions of the user defined function. We are going to show how we used the EarthSystemDataLab.jl package for the time series analysis of Sentinel-1 data. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/GDCEYU/ Red Track Felix Cremer PUBLISH YVRWMA@@pretalx.com -YVRWMA NetworkDynamics.jl - Modeling dynamical systems on networks en en 20200730T130000 20200730T133000 003000 NetworkDynamics.jl - Modeling dynamical systems on networks NetworkDynamics.jl is developed at Potsdam Insitut for Climate Impact Research (PIK) to facilitate modeling and analysis of large, inhomogeneous, networked dynamical systems. In such systems local dynamics as well as interactions can be described by differential and/or algebraic equations. ND.jl serves as the technical core of new efforts to develop state of the art power system models in Julia (PowerDynamics.jl). The aim of this package is to provide the user with a convenient interface that allows them to focus on building models rather than to worry about numerical intricacies. This is achieved by combining the network package LightGraphs.jl with the fully-featured solver suite DifferentialEquations.jl. Julia turned out to be the perfect environment for our goal since it can be used like a scripting language for protoyping while matching the speed of FORTRAN and C when writing optimized code. In this talk we introduce the basic constructors of NetworkDynamics.jl and showcase potential applications ranging from neurodynamics to power systems. We conclude with a brief overview of advanced features such as multi-threading, support for stochastic differential equations and integration with the machine learning environment DiffEqFlux.jl. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/YVRWMA/ Red Track Michael Lindner Anton Plietzsch PUBLISH 9A8DCP@@pretalx.com -9A8DCP GeometricFlux.jl: Geometric Deep Learning on Flux en en 20200730T133000 20200730T140000 003000 GeometricFlux.jl: Geometric Deep Learning on Flux Geometric deep learning plays a role in modeling non-Euclidean data with graph structure. I introduce GeometricFlux, a Julia package for geometric deep learning on graph. GeometricFlux relies on Zygote as automatic differentiation engine, accepts graph data structure provided by JuliaGraph. GeometricFlux layers are compatible with Flux layers and supported by CuArrays. It will be a competitive platform against other framework. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/9A8DCP/ Red Track Yueh-Hua Tu PUBLISH MASLPF@@pretalx.com -MASLPF The State of Julia en en 20200730T142000 20200730T150500 004500 The State of Julia In addition to taking stock of the language and ecosystem, we'll review the annual developer survey. That accounts for some portion of the 45 minutes, although it would also be separable if that's easier for scheduling. PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon2020/talk/MASLPF/ Red Track Stefan Karpinski Jeff Bezanson PUBLISH 7RL9UQ@@pretalx.com -7RL9UQ Keynote: Juan Pablo Vielma en en 20200730T151000 20200730T155500 004500 Keynote: Juan Pablo Vielma TBA PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon2020/talk/7RL9UQ/ Red Track Juan Pablo Vielma PUBLISH XGHSWW@@pretalx.com -XGHSWW Julia and C++: a technical overview of CxxWrap.jl en en 20200730T161000 20200730T164000 003000 Julia and C++: a technical overview of CxxWrap.jl Since the previous presentation in 2016, the package has evolved quite a bit, so after a brief recap of the basic functionality the talk will focus on some of the new design choices and their implementation, which will hopefully clarify some aspects that are not easy to convey in documentation. We will start with a short introduction, showing the basic principle of using `ccall` on a C++ function pointer to make calling any kind of C++ function possible. From there, we will explain the mapping of argument and return types, especially focusing on the recent changes for integer number types. Since CxxWrap v0.9 there is also a much more rigorous treatment of pointers, references and values, which all have a distinct type now. We will explain some of the design choices behind these new types, as well as the new `@cxxdereference` macro that simplifies writing Julia functions acting on CxxWrap-generated types. We end the presentation with a discussion of the new C++ standard library functionality and show how to extend this for as yet unsupported container types. Slides are available at https://barche.github.io/juliacon2020-cxxwrap-talk/ PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/XGHSWW/ Red Track Bart Janssens PUBLISH QHRQVF@@pretalx.com -QHRQVF Advanced Metaprogramming Tools en en 20200730T164000 20200730T171000 003000 Advanced Metaprogramming Tools This talk will try to clarify the relationship between Julia's many metaprogramming tools, showing how you should (and shouldn't) use Julia's metaprogramming to create DSLs, build program transformations like differentiation, SPMD or batching, or apply domain-specific optimisations in areas like differential equations or probabilistic programming. We'll also clarify the relationship Julia's tools have to advanced programming tools from other language communities, like staged programming and algebraic effect handlers. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/QHRQVF/ Red Track Mike Innes PUBLISH KKUCBL@@pretalx.com -KKUCBL Beyond Overdubbing: Building a Generic IR Tracker en en 20200730T171000 20200730T172000 001000 Beyond Overdubbing: Building a Generic IR Tracker This talk introduces the design and development goals of [IRTracker](https://github.com/TuringLang/IRTracker.jl), a library for dynamic and recursive tracking of Julia’s intermediate representation (IR) during the execution of any Julia function. I will describe the relative merits of [Cassette](https://github.com/jrevels/Cassette.jl) and [IRTools](https://github.com/MikeInnes/IRTools.jl) for implementing such a project, and discuss some insights about the current metaprogramming infrastructure. Then, I’ll provide an overview of the resulting package, which is designed with the application to probabilistic programming in mind (specifically, its use within [Turing](https://github.com/TuringLang/Turing.jl) for automatic computation of Gibbs conditionals). The code transformation mechanism is currently specialized to insert the necessary tracking statements, but it can be easily abstracted out. This could serve as the basis for the implementation of IR transformations for other abstract interpretation mechanisms, especially such which need access not only to function calls, but also to branches performed during execution. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/KKUCBL/ Red Track Philipp Gabler PUBLISH PHGCKB@@pretalx.com -PHGCKB Integrating Julia in R with the JuliaConnectoR en en 20200730T172000 20200730T173000 001000 Integrating Julia in R with the JuliaConnectoR R and Julia are two languages that complement each other very well: R has many convenient features from a huge number of packages. Julia brings new possibilities for writing fast code and offers new and innovative packages. Integrating functionality of Julia in R is especially promising due to the many commonalities of Julia and R. We take advantage of these in the design of our "JuliaConnectoR" R package (https://github.com/stefan-m-lenz/JuliaConnectoR), which aims at a tight and stable integration of Julia in R. The JuliaConnectoR can import Julia functions, also from whole packages, and make them directly callable in R. Values and data structures are translated between the two languages. Julia objects can be fully translated to R objects or accessed via proxy object that behave like R objects. In addition to directly using features from Julia packages, this also greatly simplifies writing own Julia code for optimizing time critical portions of R code compared to writing C extensions in R. The possibility to pass R functions as arguments to Julia functions makes the JuliaConnectoR a truly functional interface. Such callback functions can, e. g., be used to interactively display the learning process of a neural network in R while it is trained in Julia. This sets the JuliaConnectoR apart from the other R packages for integrating Julia in R, “XRJulia” and “JuliaCall”. Additionally, the JuliaConnectoR offers features that make the interactive use more convenient and stable, such as the redirection of standard (error) output and the ability to interrupt running calls to Julia. These unique features become possible with an optimized communication protocol, based on TCP, which also allows a highly efficient data transfer by leveraging the similarities in the binary representation of values in Julia and R. We show the implementation of the package and demonstrate the features of the JuliaConnectoR with several examples, including deep learning with the Julia package “Flux” in R and analysing large datasets via “JuliaDB”. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/PHGCKB/ Red Track Stefan Lenz PUBLISH 9XN9AW@@pretalx.com -9XN9AW Zapata en en 20200730T173000 20200730T173500 000500 Zapata PUBLIC CONFIRMED Sponsor Talk https://pretalx.com/juliacon2020/talk/9XN9AW/ Red Track PUBLISH M98VVM@@pretalx.com -M98VVM Solving Nonlinear Multi-Physics on GPU Supercomputers with Julia en en 20200730T180000 20200730T183000 003000 Solving Nonlinear Multi-Physics on GPU Supercomputers with Julia The widely applicable approach we present relies on the usage of a powerful **stencil-based iterative method** which enables to efficiently converge to the time-dependent implicit solution for strongly nonlinear problems. The method optimally suits both shared and distributed memory parallelism. The **implementation approach** enables a straightforward development of a single Julia code that can be readily deployed on a single CPU thread or on thousands of GPUs/CPUs. We have instantiated the approach in the Julia packages `ParallelStencil` and `ImplicitGlobalGrid`. `ParallelStencil` empowers domain scientists to write architecture-agnostic high-level code for parallel high-performance stencil computations on GPUs and CPUs. `ParallelStencil` uses `CUDAnative` for computations on GPUs and `Base.Threads` for computations on CPUs. `ImplicitGlobalGrid` renders the distributed parallelization of stencil-based GPU and CPU applications on a regular (staggered) grid nearly trivial. `ImplicitGlobalGrid` relies on the Julia MPI wrapper, `MPI.jl`, to perform halo updates close to hardware limit and leverages CUDA-aware MPI for GPU applications. We have designed both `ParallelStencil` and `ImplicitGlobalGrid` for simplest possible usage by domain-scientists, rendering fast and interactive development of massively scalable high performance Multi-GPU applications readily accessible to them. We conduct the **performance evaluation** with a simple metric for iterative PDE solvers. The metric measures effective memory throughput and is complementary to traditional metrics. We demonstrate the broad applicability of our approach **showcasing multiple 2-D and 3-D Multi-GPU PDE solvers**, as, for instance, a solver for spontaneous nonlinear multi-physics porous flow localization in 3-D. As reference, we ported the latter solver from MPI+CUDA C to Julia and it achieves 95% of the performance of the original solver and a nearly ideal parallel efficiency on thousands of NVIDIA Tesla P100 GPUs on the Piz Daint supercomputer at the Swiss National Supercomputing Centre, CSCS. We evaluate the presented solvers' performance and scalability on Piz Daint. The majority of the presented solvers are being made publicly available as part of the documentation of the packages `ParallelStencil` and `ImplicitGlobalGrid`. Co-authors: Ludovic Räss¹ ², Grzegorz Kwasniewski¹, Benjamin Malvoisin³, Yury Podladchikov³ ¹ ETH Zurich | ² Stanford University | ³ University of Lausanne PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/M98VVM/ Red Track Samuel Omlin PUBLISH DVSD7Q@@pretalx.com -DVSD7Q Solving partial differential equations in Julia with Gridap.jl en en 20200730T183000 20200730T190000 003000 Solving partial differential equations in Julia with Gridap.jl The design of `Gridap` is quite unique for a finite element software package since it is not a simple translation of an existing C/C++ or FORTRAN code. In contrast, the library makes use of lazy-data structures that represent objects (e.g., elemental matrices and vectors) on the entire computational domain. This allows us the library developers to hide assembly loops and other core computations from the user-code leading to a very compact, user-friendly, syntax. `Gridap` is designed both for research and teaching purposes. It is a registered Julia package distributed under a MIT license and it is available at Github (https://github.com/gridap/Gridap.jl) . PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/DVSD7Q/ Red Track Francesc Verdugo PUBLISH HJZXMX@@pretalx.com -HJZXMX Inference of Bifurcations with Differentiable Continuation en en 20200730T190000 20200730T193000 003000 Inference of Bifurcations with Differentiable Continuation This project uses functionality of parameter continuation library BifurcationKit.jl to work with automatic differentiation library Zygote.jl. This talk would be interesting to anyone who infers parameters of differential equation models, users of DifferentialEquations.jl, Flux.jl and FluxDiffEq.jl. Repository: github.com/gszep/FluxContinuation PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/HJZXMX/ Red Track Grisha Szep PUBLISH LHBLF3@@pretalx.com -LHBLF3 State Space Modeling for Macroeconomics with StateSpaceEcon en en 20200730T123000 20200730T124000 001000 State Space Modeling for Macroeconomics with StateSpaceEcon We will give an overview of what the Julia package StateSpaceEcon can do and how it works internally. Macroeconomics typically deals with discrete-time systems of non-linear equations that include expectations of future values of the variables. One way to solve for these expectations is the “rational expectations” hypothesis which posits that expectations should be consistent with the whole system. The package StateSpaceEcon solves these kinds of systems using a stacked-time algorithm. This algorithm builds one large system of equations over all time periods and solves it using a root-finding algorithm such as Newton-Raphson. This approach works very well for large discrete-time systems of non-linear equations simulated with anticipated shocks. When shocks are anticipated, the expectation about the future values of the variables and their realisations are equal. Besides, the StateSpaceEcon package offer functionalities that facilitate working with state space systems in the context of macroeconomic policy analysis. 1. The package dependency TimeSeries supports time series at low frequencies (e.g. integer, monthly, quarterly and yearly). Vectorized operations, indexing and assignments greatly facilitate data manipulations. 2. A plan object allows to perfectly control which variables and shocks are endogenous (i.e. determined by the system) or exogenous (imposed on the system externally), which might change from one time period to the next. 3. On top of anticipated shocks, the package can handle unanticipated shocks. In this case, the expectations and their realizations will differ. 4. The rational expectations solver computes the Jacobian of the system using automatic differentiation. It uses sparse matrices throughout in order to handle the very large, but very sparse, Jacobian resulting from the stacked-time algorithm. 5. The steady state of the system can be computed and analysed using QR decomposition to report states that are left undetermined. Functionalities allow for adding steady state equations and assumptions, in order to close the steady state system. 6. Finally, the package StateSpaceEcon can linearize the system around the steady state or any other solution and use the linearized system for simulations. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/LHBLF3/ Green Track Nicholas L. St-Pierre Boyan Bejanov Atai Akunov PUBLISH ALMRKK@@pretalx.com -ALMRKK Parallel Implementation of Monte Carlo-Markov Chain Algorithm en en 20200730T124000 20200730T125000 001000 Parallel Implementation of Monte Carlo-Markov Chain Algorithm During the last 5 years we have been working on the iterative methods for solving systems of linear algebraic equations. Recently our work has focused on estimates inverse matrix of the system and an efficient condicioner in order to obtain a good approximate solution. We use for this task **Markov Chain-Monte Carlo** (MCMC) method as a theoretical basis. Iterative process, convergence, random sampling and calculation of weights and estimators represent an exhaustive computational effort for the MCMC method as the size of the system of linear equations to be solved increases. In order to tackle this problem paralllel implementation using Julia 1.1.0 + CUDAnative is proposed. Julia programming language has captured our attention since it has consolidated, as an excellent development environment for scientific computation. Our contribution to the Julia conference 2020 is to show parallel implementation of the MCMC method highlighting the advantages of CUDAnative.jl as a wrapper of GPU accelerators. Convergence and scaling results are discused at the end of the talk. We would like to thank the financial support of PAPIIT-IA104720. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/ALMRKK/ Green Track Oscar A. Esquivel-Flores Óscar Alvarado PUBLISH J9Q8UR@@pretalx.com -J9Q8UR AMDGPU Computing in Julia en en 20200730T125000 20200730T130000 001000 AMDGPU Computing in Julia NVIDIA's CUDA (Compute Unified Device Architecture) has been the dominant toolkit for general-purpose GPU (GPGPU) computing for many years, and has excellent support in Julia. However, AMD's ROCm (Radeon Open Compute) platform is rising in popularity, and many Julia users wish to use their AMD GPUs in Julia in the same ways that CUDA users can today. I will provide an overview of how to do exactly that, and what pitfalls users need to be aware of. Beyond past basic functionality, the open source nature of the AMDGPU kernel module makes support for advanced features like hostcall and unified memory easy to use, and enables opportunities to unify computations on CPUs and GPUs without much difficulty. I will present some short demos of how these useful features can be used in practice Going forward, a number of innovations in Julia's GPGPU ecosystem are possible. Merging compiler codebases, providing better abstractions for generic kernel programming, integration with distributed computing libraries, and automated GPU-ification of scientific and machine learning codes are all on the table for the future. I will briefly explore what exciting possibilities users and developers have to look forward to, and what work still needs to be done. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/J9Q8UR/ Green Track Julian P Samaroo PUBLISH HVXXZD@@pretalx.com -HVXXZD Optimization Algorithms in Julia for GPUs en en 20200730T130000 20200730T133000 003000 Optimization Algorithms in Julia for GPUs The ExaSGD (Optimizing Stochastic Grid Dynamics at Exascale) application is part of the Department of Energy's Exascale project (ECP). We use Julia and JuMP for large-scale optimization on the current generation of supercomputers. However, the recent switch from CPU to GPU in the upcoming generation of supercomputers poses great challenges for classic optimization algorithms. Sparse algebra and linear solvers are known to have poor performance on GPUs. Our project looks into novel optimization algorithms that are applied to the alternate current optimal power flow (ACOPF) problem. Current solvers supported by JuMP largely rely on sparse linear solvers. Our goal is to find algorithms that rely on denser algebra that scales over the large number of cores that a GPU provides. We present a complete software stack from modeling to the linear solver that is written completely in Julia and provide an end-to-end overview of the challenges met both at the modeling level as well as at the algebra level. We use automatic differentiation to generate the derivative code for the GPUs and show performance results for the power flow problem (PF) that look promising to be extended to OPF. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/HVXXZD/ Green Track Michel Schanen PUBLISH YCGSVY@@pretalx.com -YCGSVY How not to write CPU code -- KernelAbstractions.jl en en 20200730T133000 20200730T140000 003000 How not to write CPU code -- KernelAbstractions.jl Writing performance portable code that targets multiple hardware platforms is challenging. KernelAbstractions.jl allows users to abstract away some of the hardware differences and write one unified code that targets multiple hardware platforms. Despite being able to target multi-threaded CPUs it's design choices are biased towards GPUs and can sometimes be sub-optimal for CPU execution. In this talk I will introduce KernelAbstractions.jl, and explain it's design choices. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/YCGSVY/ Green Track Valentin Churavy PUBLISH Y7ERM9@@pretalx.com -Y7ERM9 Introducing the @ccall macro en en 20200730T161000 20200730T162000 001000 Introducing the @ccall macro As I was learning Julia, I was delighted with the ease and speed with which the language could access C libraries, but I found the specific syntax of `ccall` a bit cumbersome. I created a simple macro to provide what I felt was a more "Julian" syntax `ccall`. What I came up turned out to be very similar to a syntax that Julia's core developers had discussed previously, so I began the process of getting my macro into the language. [PR #32748](https://github.com/JuliaLang/julia/pull/32748) This short talk will cover the new syntax presented by `@ccall`, what new features it has that the original `ccall` doesn't, and also provide some reflections on making my first contribution to the language and the helpful guidance provided by the Julia team. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/Y7ERM9/ Green Track Aaron Christianson PUBLISH 3LUQVT@@pretalx.com -3LUQVT Design documents are great, and here’s why you should consider w en en 20200730T162000 20200730T163000 001000 Design documents are great, and here’s why you should consider w A design document is a written description of a software product, that a software designer writes to give a development team overall guidance to the architecture of the project. They include everything from the general architecture, internal/external dependencies, and in/out of scope tasks, among other things. When an individual or team starts contributing to a new package, it can be overwhelming at first. Finding out which components do what, how they interact with each other, and why certain design decisions were made. A design document can help clarify these general questions and get a new contributor started in understanding the package. Design documents are also helpful in producing an overview of the current architecture, showcasing alternative solutions, and explaining why certain design decisions were made. In this talk, we will discuss what a design document is, why you should consider creating one and what components go into it. By the end, you will know how to create a design document that will capture a snapshot of your package (or future package), outline guiding principles and summarize design decisions that will help lead to improvements in future revisions. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/3LUQVT/ Green Track Matt Brzezinski PUBLISH BSQLL9@@pretalx.com -BSQLL9 Adventures in Avoiding Allocations en en 20200730T163000 20200730T164000 001000 Adventures in Avoiding Allocations Memory allocations can have a significant impact on run-time performance. My research focuses on developing state-of-the-art optimization solvers for doing real-time motion planning on nonlinear robotic systems, where run-time consistency is critical. This talk will discuss some practical considerations of writing non-allocating code in Julia, in the context of TrajectoryOptimization.jl, where we leveraged several techniques to achieve a 100x improvement in speed on many problems. This talk will include tips, tricks, and insights on how to avoid memory allocations and boost performance, as well as some discussion about the shortcomings of Julia with regards to memory management. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/BSQLL9/ Green Track Brian Jackson PUBLISH JYNERU@@pretalx.com -JYNERU Dispatching Design Patterns en en 20200730T164000 20200730T171000 003000 Dispatching Design Patterns A topic which frequently comes up in discussions of Julia is how to solve complex problems without class-based object orientation. We will look at how objects and interfaces are designed in Julia using modules, structs, multiple dispatch and abstract types. We’ll look at how to use generics for more open-ended polymorphism that doesn’t sacrifice performance and how to use the trait pattern to define extensible, overlapping categories of types. We’ll also mention a few anti-patterns that come up in Julia, such as the infamous “type piracy”. We’ll also look at how multiple dispatch can be used as a simple form of pattern matching, similar algebraic data types in functional languages, and how this is useful for traversing recursive data structures like the abstract syntax trees one deals with when writing macros. This talk is for programmers who may be experienced with other languages but are new to Julia and want to see how we design software using Julia’s unique feature set. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/JYNERU/ Green Track Aaron Christianson PUBLISH LRKHWM@@pretalx.com -LRKHWM Continuables.jl: Python yield in Julia in blazingly fast en en 20200730T171000 20200730T172000 001000 Continuables.jl: Python yield in Julia in blazingly fast I want to present you the simple idea behind [Continuables.jl](https://github.com/schlichtanders/Continuables.jl), to interprete `yield` as withhold computation. [Continuables.jl](https://github.com/schlichtanders/Continuables.jl) lets you define a generator with `@cont` and use `cont()` as the new ``yield``. "cont" stands for continue, which hints at the implementation: A continuable simply expects a function which it can use as the ``cont()`` placeholder. With this basic idea (plus some details) you get many of the standard iterable functionalities and the code compiles perfectly. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/LRKHWM/ Green Track Stephan Sahm PUBLISH MGJCGT@@pretalx.com -MGJCGT Computation Techniques for Encrypted Data en en 20200730T172000 20200730T173000 001000 Computation Techniques for Encrypted Data Imagine you have important documents such as credit card statements of expenditure or other financial documents and you want to protect them from illegal entities. You will store them in safe and lock it with a key. This process is known as encryption. Now if you want to analyze your spending habits or process financial accounts related to your business then you need to take the documents out of safe. This process is known as decryption. This step has a problem i.e.; the moment you take out the documents from the safe they become vulnerable to illegal entities. To avoid such situations, we need a mechanism to process documents without taking them out of the safe. It is possible through homomorphic encryption i.e., by performing computations on encrypted data and this talks addresses techniques to perform computations of encrypted data.<br/> <br/> Implementation:<br/> The cryptographic algorithms have been implemented in Julia. Also, the Julia code has been written to verify the homomorphic properties of cryptographic algorithms. Homomorphic encryption techniques are computation intensive. To reduce the number of computations we used the Fast Fourier Transform (FFT) and Karatsuba methods for performing arbitrary computations such as multiplication over large integers. Next to demonstrate the implementation of a secure machine learning model we combined cryptography algorithms implementation in Julia and machine learning toolbox (MLJ.jl). A minimal blockchain was implemented in Julia to perform secure computations in a blockchain environment.<br/><br/> Outline<br/> 1.Introduction to cryptography and homomorphic encryption(02 Minutes)<br/> 2.Introduction to the Internet of Things and problems of homomorphic encryption(03 Minutes)<br/> 3.Techniques to reduce the complexity of computations on encrypted data(04 Minutes)<br/> 4.Recryption for secure computation(04 Minutes)<br/> 5.Homomorphic encryption and Machine Learning(04 Minutes)<br/> 6.Homomorphic encryption and Blockchain(04 Minutes)<br/> 7.Conclusion and Questions(04 Minutes)<br/> PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/MGJCGT/ Green Track Gajendra Deshpande PUBLISH 3YDDAE@@pretalx.com -3YDDAE JuliaLang Survey Results en en 20200730T173000 20200730T174000 001000 JuliaLang Survey Results PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/3YDDAE/ Green Track Viral B. Shah Andrew Claster PUBLISH ELQ8A8@@pretalx.com -ELQ8A8 StatsModels.jl: Mistakes were made/A `@formula` for success en en 20200730T180000 20200730T183000 003000 StatsModels.jl: Mistakes were made/A `@formula` for success Transforming tabular, heterogeneous data into numerical arrays is a critical first step in many data analysis pipelines. [StatsModels.jl](https://github.com/JuliaStats/StatsModels.jl) provides functionality for this through the `@formula` macro. The earliest implementations of `@formula` in Julia were based on R, which has a very different model for metaprogramming and composition across packages. Over the last two years, we re-implemented the `@formula` from the ground up in a more Julian fashion, trying to strike a balance between maintaining a continuous, familiar experience for front-end users while also taking advantage of Julia's many features to create a hackable, flexible, modular, and extensible platform that other packages can build on. In this talk, I'll show you how the current implementation achieves these goals, but more importantly what we *learned* in the process of rewriting this critical piece of data science infrastructure. I'll pay special attention to mistakes we made in initial development, lessons we learned from those mistakes about how to make a flexible, composable package, and issues for current and future development. You'll learn how [StatsModels.jl](https://github.com/JuliaStats/StatsModels.jl) takes advantage of multiple dispatch to allow *other* packages to hook into and extend the `@formula` system while still playing nicely together. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/ELQ8A8/ Green Track Dave Kleinschmidt PUBLISH 8EPG3L@@pretalx.com -8EPG3L The Queryverse en en 20200730T183000 20200730T184000 001000 The Queryverse This talk will briefly introduce users to the Queryverse, what the scope of it is and how one can use it. I will also briefly talk about new features that have been added since last year. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/8EPG3L/ Green Track David Anthoff PUBLISH EVJNMH@@pretalx.com -EVJNMH Julia for Knowledge Mining in Industry 4.0 en en 20200730T184000 20200730T185000 001000 Julia for Knowledge Mining in Industry 4.0 Industry 4.0 engenders and analysis data across the machines in iIndustry to produce high-quality products at low costs, and changes traditional production relationships among suppliers, producers, and customers. Industry 4.0 amalgamates nine technologies to transform industrial production, which includes: (1) Big Data Analytics, (2) Autonomous Robots/ Robotics, (3) Simulation, (4) Horizontal & Vertical System Integration, (5) Industrial Internet of Things (IIoT), (6) Cybersecurity, (7) Cloud Computing, (8) Additive Manufacturing (such as 3-D printing), and (9) Augmented Reality. I4.0 uses Decision Support Systems (DSS) incorporating with knowledge mining techniques to know what actions need to take in future that help manufacturers to optimise their operations quickly. The fourth revolution ameliorates the industries with intelligent computing fuelled by data with Machine Learning (ML) and Data Mining (DM) technologies. In this talk, we have addressed several issues for knowledge mining process in Industry 4.0 using Julia programming language. Knowledge mining is the process of extracting hidden information/patters from Industrial Big Data (iBigData) to lucid market trends, customer preferences and other information that’s useful to businesses. Industrial Big Data is extremely large that we can't store all the data into a single computer/machine; so, we need more scalable and robust learning approach to deal with iBigData. We have collected the data set with 1067371 instances named “Online Retail II” from UCI Machine Learning Repository (https://archive.ics.uci.edu/) and implemented RainForest and BOAT (Bootstrapped Optimistic Algorithm for Tree construction) learning algorithms using Julia. RainForest and BOAT are basically decision tree (DT) based supervised learning algorithms for classifying Big Data. We have presented a new decision tree merging approach that addresses the repetition and replication problems in tree pruning. Industrial Big Data is multivariate, high-dimensional, noisy, and also the characteristics of data can be changed over the time (e.g. concept drifting in data streaming environment). In this talk, we also discussed the how we can handle the noisy and streaming data; find the most informative training instances, so that we can build a learning model with minimum number of instances. For selecting informative training instances, we have used simple partition-based clustering approach and implemented clustering algorithm in Julia. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/EVJNMH/ Green Track Swakkhar Shatabda Dewan Md. Farid Aicha Sekhari Yacine Ouzrout PUBLISH XQ9YQK@@pretalx.com -XQ9YQK Efficient RANSAC in efficient Julia en en 20200730T185000 20200730T190000 001000 Efficient RANSAC in efficient Julia We introduce the RANSAC.jl package that implements the Efficient RANSAC algorithm. It is a widely used tool in the field of digital shape reconstruction to recognize simple geometric primitives (plane, sphere, cylinder, torus, cone) in point clouds. This algorithm can not only be used alone, but also as part of complex reconstruction processes. So far, mostly C++ implementations have been published, and to the best of my knowledge, this is the first one in Julia. The main goal of the implementation is establishing a flexible tool, while maintaining the same level of performance as existing solutions. This way, not only existing functionality is replicated, but also a new research tool is introduced. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/XQ9YQK/ Green Track Tamás Cserteg PUBLISH KFRKCB@@pretalx.com -KFRKCB Inventing Curriculum with Julia and Pointer-Generator Network en en 20200730T190000 20200730T193000 003000 Inventing Curriculum with Julia and Pointer-Generator Network The curriculum in general and undergraduate curriculum, in particular, is one of the most important pillars of an education system. The undergraduate curriculum has two main objectives i.e. employability and higher education. The greatest challenge in designing an undergraduate curriculum is achieving a balance between employability skills and laying the foundation for higher education. Generally, the curriculum is the combination of core technical subjects, professional electives, humanities, and skill-oriented subjects. We used natural language processing and machine learning packages in Julia to build a curriculum design system. The steps to build a curriculum design system are described below: 1. The dataset was built from the job profiles from different job listing websites like indeed.com, linkedin.com, and monster.com. Also from the syllabus of competitive exams and qualifying exams for higher education. 2. On the dataset, we applied natural language processing techniques to identify the subjects and subject content. For natural language processing, we used TextAnalysis.jl package in Julia. 3. To generate syllabus content for a particular subject, a pointer-generator network was used. The pointer generator network is a text summarization technique that combines extractive and abstractive summarization techniques. The extractive summarization technique extracts keywords from the dataset, whereas the abstractive summarization technique generates new text from the existing text. The pointer-generator network was implemented using the MLJ.jl machine learning package in Julia. 4. The generated curriculum was then compared with the existing curriculum to get insights like, how much percent of the curriculum is industry oriented, how much percent of the curriculum is aimed at higher education, and job-oriented skills. 5. The above steps can be repeated with modified parameters to get better insights and curriculum. This also gives us an idea of how we can have an evolving curriculum that can help us bridge the gap between industry and academia. In this talk, attendees will learn about natural language processing techniques using Julia and how it can be combined with machine learning to generate new knowledge from the existing knowledge. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/KFRKCB/ Green Track Gajendra Deshpande PUBLISH KK9S9V@@pretalx.com -KK9S9V Creating a multichannel wireless speaker setup with Julia en en 20200730T123000 20200730T124000 001000 Creating a multichannel wireless speaker setup with Julia Taking advantage of some of the strengths of the Julia package ecosystem and tooling, we will demonstrate the ease with which an advanced wireless speaker system can be developed and deployed across heterogenous architectures. Combining `ZMQ.jl` for easy and fast communication, `DSP.jl` and `PortAudio.jl` for signal processing/audio IO, `Opus.jl` for high-quality compression during transmission and some cheap single-board linux computers, we are able to build a system that performs the kind of realtime audio processing that we crave, all without breaking the bank. This talk will focus on demonstrating the usefulness of having a single language that can deal with signal processing, low-latency network communication, and cross-platform binaries, all at once. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/KK9S9V/ Purple Track Elliot Saba PUBLISH M89V9M@@pretalx.com -M89V9M Boids: Dancing with Friends and Enemies en en 20200730T124000 20200730T125000 001000 Boids: Dancing with Friends and Enemies A Dance with Friends and Enemies is a Boids artificer life program introduced on the [Mathematica Forums](https://community.wolfram.com/groups/-/m/t/122095). In this simulation each "dancer" has a randomly chosen friend and enemy. At each beat of the dance, the dancers 1. Take a step to the center of the dancefloor 2. Take a step to their friend 3. Take a step away from their enemy. Also, at random intervals a dancer will choose new friends and enemies. The sizes of each of these steps, as well as the frequency of partner switches, are parameters which affect the emergent, flocking behaviour. In this talk I will quickly describe a Julia implementation of this simulation, which is performant with large numbers of dancers. Further, I will demonstrate the emergent flocking behaviour with a visualization in Makie.jl. This will highlight some of Makie's features. In particular, the simulation will have sliders allowing us to modify the parameters and see the affect on flock behaviour plotted efficiently in realtime. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/M89V9M/ Purple Track Jesse Bettencourt PUBLISH 8RM33X@@pretalx.com -8RM33X JuliaMusic: doing cool science and becoming a better drummer en en 20200730T130000 20200730T133000 003000 JuliaMusic: doing cool science and becoming a better drummer JuliaMusic contains intuitive and powerful packages for analyzing music data, made for scientific work on the mathematical properties of music. Thus, they contain advanced functionality that does not exist in counterparts in e.g. Python. The flexibility of JuliaMusic allows me to straightforwardly ask and answer questions about the mathematical structure of music. But through some clever use of combinatorics, I can also use them to produce exercises for my drums practice sessions. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/8RM33X/ Purple Track George Datseris PUBLISH 38UTLX@@pretalx.com -38UTLX Rapid Commercialization of Drone Autonomy using Julia en en 20200730T133000 20200730T140000 003000 Rapid Commercialization of Drone Autonomy using Julia There is currently a very large gap from new robotics research to commercial products. The two language problem contributes to this gap, where research and prototyping often occurs in MATLAB or Python and then field testing and commercialization requires porting to C or C++. The development speed, runtime speed, and scientific computing capabilities of Julia offer a promising solution to this challenge. KEF Robotics is developing an attachable autonomy subsystem for small aerial vehicles, allowing us to add navigation, hazard avoidance, and machine learning capabilities to any drone, all with just cameras (no GPS required). Our hazard detection and avoidance module has been developed, tested, fielded, and is now being transitioned into a commercial product, all in Julia. This module combines widely varying components, including image processing, geometric computer vision, splines, and nonlinear optimization, making it a perfect showcase for Julia's unique strength in composability and scientific computing. Another key challenge in robotics is predictable real-time performance, often on embedded computing. These factors are typically not associated with garbage-collected scripting languages. While Julia's tooling and runtime are not perfect for the task, options for allocation management, profiling, and package compilation allow prototype code to be ported to these applications, all in the same language. Also, Julia native CUDA programming is of particular utility for NVIDIA's Jetson products, which are prevalent in robotics research and commercialization. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/38UTLX/ Purple Track Kerry Snyder PUBLISH Q88P8U@@pretalx.com -Q88P8U Integrate Julia and Javascript using Node.js extensions en en 20200730T161000 20200730T162000 001000 Integrate Julia and Javascript using Node.js extensions Julia is a great language for implementing algorithms, and Node.js is a popular platform for writing web services using Javascript. In this talk we will see how to run Julia code in a Node.js application, by using Node.js native extensions. This approach has been used to serve a statistical inference algorithm, written in Julia, through an HTTP API, written in Javascript. The Julia code is simplified since it does not have to handle HTTP requests, and it avoids data serialization costs by directly sharing memory between the runtimes. Furthemore, this makes the integration into an existing Node.js environment easy, since it does not require the installation of Julia on the server. We will show how to use `PackageCompiler.jl` to produce a shared library, and the `node-addon-api` and `node-gyp` packages to build and distribute the extension. We will also discuss the challenges and limitations of this approach, such as garbage collection, exceptions handling, and multithreading. An example extension is available at https://github.com/maxmouchet/julia-node-extension-demo. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/Q88P8U/ Purple Track Maxime Mouchet PUBLISH DTLBM9@@pretalx.com -DTLBM9 Highly productive Julia web development with Genie 1.0 en en 20200730T162000 20200730T163000 001000 Highly productive Julia web development with Genie 1.0 With over 900 stars on GitHub and consistently ranking as one of the top 10 most starred Julia packages, Genie is a testament of Julia's great potential as a language for the web. After 5 years in development, over 1000 commits and 50 releases, Genie reaches the v1 milestone as a mature, stable, performant, and feature-rich Julia web development framework. The talk will touch upon Genie's most important features, providing a starting point for Julia developers interested in the development of web applications. We will go over features like the HTML templating language, JSON rendering capabilities, input handling, caching, built-in Docker integration, the plugins ecosystem (Genie Authentication and Genie Autoreload), and the built-in deployment adapters for the major hosting platforms. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/DTLBM9/ Purple Track Adrian Salceanu PUBLISH GFE3DB@@pretalx.com -GFE3DB JSServe: Websites & Dashboards in Julia en en 20200730T163000 20200730T164000 001000 JSServe: Websites & Dashboards in Julia PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/GFE3DB/ Purple Track Simon Danisch PUBLISH P7EQCK@@pretalx.com -P7EQCK Write a WebApp in Julia with Dash.jl en en 20200730T164000 20200730T165000 001000 Write a WebApp in Julia with Dash.jl [Dash.jl](https://github.com/plotly/Dash.jl) is a Julia interface to the Dash framework developed by the Plotly team. This talk is aimed at demonstrating how easy it is to write a high quality webapp in Julia, without having to write JavaScript, and still have it be really intuitive, almost as if one is writing HTML. Often in large projects, one of the key goals is to deliver a final solution to a large user base. In this talk, we will explore a simple way to deploy your solution behind a web server. We will write a webapp that includes user input, automated HTTP request routing, and displaying analytical results with Plotly graphs. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/P7EQCK/ Purple Track Dhairya Gandhi PUBLISH VP3W33@@pretalx.com -VP3W33 Rocket.jl: A Julia package for reactive programming en en 20200730T170000 20200730T171000 001000 Rocket.jl: A Julia package for reactive programming The reactive programming (RP) paradigm is becoming increasingly popular. RP combines concepts from asynchronous data processing and the observer design pattern. Common applications are online data processing, interactive visualization and responsive user interfacing. The implementation of RP within a reactive framework allows developers to conveniently define relationships between data producers and consumers, and enables developers to build distributed and scalable applications more efficiently. Popular reactive frameworks in languages other than Julia include RxPy, RxJS, RxCpp and RxJava. In areas such as machine learning, reinforcement learning and signal processing, data often arrive asynchronously and at different time scales. In this context, to reduce the developer's effort, RP offers a set of operators for composing, merging, filtering and transforming asynchronous data streams and provides a versatile API for listening for changes in these data streams. In order to support RP in Julia, we have developed Rocket.jl, which is an efficient and flexible reactive extensions package, written in pure Julia. Efficiency is achieved by relying on Julia's type system and advanced optimisation techniques. Rocket.jl introduces additional abstractions that can largely be evaluated and in-lined at compile time, resulting in an efficient implementation of RP with almost zero overhead compared to traditional imperative programs. Comparative performance benchmarks are available on the GitHub repository. At the same time, flexibility is maintained by making use of Julia's multiple dispatch system. A user can readily extend built-in functionality with additional operators and custom observables. The self-contained documentation of Rocket.jl provides a convenient introduction to RP, and offers a collection of examples and use cases that illustrates how users can customize the built-in functionality to their needs. We compared Rocket.jl with two other Julia implementations of the RP, and applied the basic map and filter operators to an asynchronous data stream. In terms of computation time, Rocket.jl outperforms Signals.jl and Reactive.jl on average by a factor of 2 and 4, respectively. Memory usage is similar across these packages. We believe that usability is a key factor when applying the RP to practical problems. Therefore we designed Rocket.jl as a RP package that enables developers to build flexible and efficient reactive systems. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/VP3W33/ Purple Track Dmitry Bagaev PUBLISH WNBYW8@@pretalx.com -WNBYW8 Interactive notebooks ~ Pluto.jl en en 20200730T171000 20200730T174000 003000 Interactive notebooks ~ Pluto.jl Whether you’re a scientist, a finance professional or an engineer, you use notebooks like Jupyter to tell a story. You fiddle a bit with your code, running cells here and there, and when you’re done - you restart the kernel and keep your fingers crossed that it’ll all work together when you press “run all”. 🙋 **In Pluto, things work differently.** When you change a variable, Pluto automatically re-runs the cells that refer to it. And when you delete a cell, the variables, methods and imports from the old code disappear. Unlike Jupyter or Matlab, there is **no mutable workspace**, but rather a _one-to-one correspondence_ between variables and code. 🚨 Reactivity is not just fun for mathematical tricks! It guarantees that the code you see exactly matches the variables you're working with, eliminating bugs before you even knew you had them. ⚡ Your notebook becomes interactive by splitting your code into multiple cells! Changing one cell **instantly shows effects** on all other cells, giving you a fast and fun way to experiment with your model. And to really spice up your notebook, you can use HTML sliders, or even custom JavaScript widgets, to drive your Julia variables. Change `λ = 5` to `@bind λ Slider(1:10)`, and all cells that use `λ` are controlled by a slider. 💾 Notebooks are **saved as pure Julia files** and can be exported as rich documents with cell output to HTML or PDF. By separating source code and output, you can take full advantage of git for version control and you can import Pluto notebooks as if they are written in a regular editor. --- After a live demo, the second part of the talk will unveil some of the tricks that power Pluto. The core concepts are: - **_static code analysis_** to find global definitions and references in cells; - **_directed graph_** of cells, which tells Pluto which cells to run, in which order; - **_managed workspace_** for code to live in, and cleaning the workspace in milliseconds; - **_responsive connection_** between JavaScript clients and Julia. Pluto is **written in pure Julia**, which comes with two benefits: first, it’s easily installable as a package without requiring Python - you only need Julia and a web browser. Second, it is ready to be improved by Julia developers who we hope to inspire at the conference. Pluto is an exciting project to work on, and we are eager to hear your ideas! [https://github.com/fonsp/Pluto.jl](https://github.com/fonsp/Pluto.jl) PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/WNBYW8/ Purple Track Fons van der Plas PUBLISH AQMLUC@@pretalx.com -AQMLUC Enterprise data management with low-rank topic models en en 20200730T180000 20200730T183000 003000 Enterprise data management with low-rank topic models To adopt modern practices for reproducible data science, enterprises need to first know what kinds of data they have. In some industries like financial services, being able to reproduce critical risk calculations is even a regulatory requirement. A necessary first step is for enterprises to build comprehensive data catalogue, before building other infrastructure such as data lakes. Building such a catalogue can be challenging for enterprises with multiple legacy systems, incomplete documentation, and inherited technical debt. The expert knowledge needed to provide and verify subject labels further escalates the cost of building a data catalogue. In this talk, I demonstrate how topic modeling can be used to help build a comprehensive data catalogue from incomplete subject labels and access to metadata such as low-level record types and database table names. By treating such metadata as a sequence of tokens, similar to natural text, I show how to construct semisupervised topic models that allow extrapolation from existing labels. First, I show how a gauge transformation of a standard topic modeling technique, latent semantic indexing (LSI), yields a labelled topic model that is explictly separable. Next, I show how to use generalized low-rank models (GLRMs), as implemented in `GeneralizedLowRankModels.jl`, to explicitly construct a labelled topic model that is a sparse, interpretable, and separable generalization of principal components analysis. I show how to implement a new regularizer in Julia, including an implementation of its corresponding proximal gradient operator. Furthermore, I show how to modify the code of `GeneralizedLowRankModels.jl` to take advantage of the new multithreading model in Julia 1.3 for near-perfect parallel speedup. Additionally, numerical tricks such as low-precision iterative linear algebra, randomized subsampling, and warm starts help to make efficient the training of a GLRM via proximal gradient descent. As an illustration of the technique, I will show how this new topic model performs on predicting subject tags on over 25,000 datasets from Kaggle.com. The GLRM-based topic model can be used for several different semisupervised learning tasks, like extrapolating from known labels, evaluating possible errors in existing labels, and predicting missing metadata. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/AQMLUC/ Purple Track Jiahao Chen PUBLISH HWZ38H@@pretalx.com -HWZ38H DynamicPPL: Stan-like Speed for Dynamic Probabilistic Models en en 20200730T183000 20200730T190000 003000 DynamicPPL: Stan-like Speed for Dynamic Probabilistic Models We present the preliminary high-level design and features of DynamicPPL.jl (https://github.com/TuringLang/DynamicPPL.jl), a modular library providing a lightning-fast infrastructure for probabilistic programming, used as a backend for Turing.jl (https://github.com/TuringLang/Turing.jl). Beside a computational performance that is often close to or better than Stan, DynamicPPL provides an intuitive domain-specific language (DSL) that allows the rapid development of complex dynamic probabilistic programs. Being entirely written in Julia, a high-level dynamic programming language for numerical computing, DynamicPPL inherits a rich set of features available through the Julia ecosystem. Since DynamicPPL is a modular, stand-alone library, any probabilistic programming system written in Julia, such as Turing.jl, can use DynamicPPL to specify models and trace their model parameters. The main features of DynamicPPL are: 1) a meta-programming based DSL for specifying dynamic models using an intuitive tilde-based notation; 2) a tracing data-structure for tracking random variables in dynamic probabilistic models; 3) a rich contextual dispatch system allowing tailored behaviour during model execution; and 4) a user-friendly syntax for probabilistic queries. Finally, we show in a variety of experiments that DynamicPPL, in combination with Turing.jl, achieves computational performance that is often close to or better than Stan. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/HWZ38H/ Purple Track Mohamed Tarek PUBLISH 8SZSBE@@pretalx.com -8SZSBE Interactive data dashboards with Julia and Stipple en en 20200730T190000 20200730T191000 001000 Interactive data dashboards with Julia and Stipple We will start by taking a quick look at the technology stack behind Stipple and its Reactive UI components, to provide a high level understanding of the various layers (Julia, Genie, Observables, Stipple, and Vue.js) and the interactions between them. We will then build a fully functional interactive data dashboard using the German Credit dataset, in which we will explore and visualize the credits distribution by age, using data tables, different types of plots and big numbers -- all in just 10 minutes! PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/8SZSBE/ Purple Track Adrian Salceanu PUBLISH 9RX99T@@pretalx.com -9RX99T Bijectors.jl: Transforming probability distributions in Julia en en 20200730T191000 20200730T192000 001000 Bijectors.jl: Transforming probability distributions in Julia PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/9RX99T/ Purple Track Tor Erlend Fjelde PUBLISH 3ZTCWX@@pretalx.com -3ZTCWX Easy and fast desktop GUIs with QML en en 20200730T192000 20200730T193000 001000 Easy and fast desktop GUIs with QML From a user perspective, the connection between Julia and QML works by exposing Julia functions to be called from QML and/or by using [Observables](https://github.com/JuliaGizmos/Observables.jl) that can be updated and monitored both from QML and Julia. Aside from these standard mechanism, the package also exposes some Julia-specific functionality, such as an [`AbstractDisplay`](https://docs.julialang.org/en/latest/base/io-network/#Multimedia-I/O-1) implementation and integration with [GR.jl](https://github.com/jheinen/GR.jl) and [Makie.jl](https://github.com/JuliaPlots/Makie.jl). The presentation will start off with a description of the Observables integration (new since the 2017 talk about this package) and then discuss more in detail how to combine different elements in Julia and QML to obtain interactive GR and Makie visualizations in a QML window. We will finish with a note on GUI styling and themes, showing how to configure a GUI for either an identical look across platforms, or for integration with the desktop look and feel. Slides and examples are available at https://github.com/barche/juliacon2020-qml PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/3ZTCWX/ Purple Track Bart Janssens PUBLISH N9RVPR@@pretalx.com -N9RVPR Number Theory and Computer Algebra in Julia en en 20200730T161000 20200730T165500 004500 Number Theory and Computer Algebra in Julia We're happy to talk about all kinds of other computer algebra and number theory topics such as: * Can you recommend a book for number theory beginners? [(Yes we can!)](http://illustratedtheoryofnumbers.com/) * What important computer algebra functionality don't yet exist in Julia? * Which packages do/do not allow composable computation? * Is there any interest in wrapping the [NTL](https://www.shoup.net/ntl/)(C++) or [PARI](http://pari.math.u-bordeaux.fr/)(C) libraries? * Would anyone use Julia wrappers around lattice libraries like [fplll](https://github.com/fplll/fplll), [plll](https://felix.fontein.de/plll/) or [LUSA](https://eprint.iacr.org/2020/605.pdf)? Bill Hart, author of [Nemo.jl](https://github.com/Nemocas/Nemo.jl), [AbstractAlgebra.jl](https://github.com/Nemocas/AbstractAlgebra.jl), [Hecke.jl](https://github.com/thofma/Hecke.jl) and other computer algebra packages will be available to answer questions about the wonderful packages that he and his collaborators have written. Here is an (incomplete!) list of computer algebra and number theory packages written in Julia. We may discuss some of these packages as well: [GaloisFields.jl](https://github.com/tkluck/GaloisFields.jl), [PolynomialFactors.jl](https://github.com/jverzani/PolynomialFactors.jl), [Theta.jl](https://github.com/chualynn/Theta.jl), [LatticeGFH90.jl](https://github.com/erou/LatticeGFH90.jl), [SecureComputation.jl](https://github.com/jiahao/SecureComputation.jl), [Coleman.jl](https://github.com/alexjbest/Coleman.jl), [ModularForms.jl](https://github.com/aghitza/ModularForms.jl), [RootFindGF.jl](https://github.com/defeo/RootFindGF.jl), [DlogGF.jl](https://github.com/erou/DlogGF.jl), [Braids.jl](https://github.com/jwvictor/Braids.jl), [IsogenyViz.jl](https://github.com/defeo/IsogenyViz.jl), [NumberTheoreticTransforms.jl](https://github.com/jakubwro/NumberTheoreticTransforms.jl), [ToyFHE.jl](https://github.com/JuliaCrypto/ToyFHE.jl) (relies on hardness of lattice problems). PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/N9RVPR/ BoF Chris Peel PUBLISH 8NDYCT@@pretalx.com -8NDYCT Julia For Quantum Physics en en 20200730T165500 20200730T174000 004500 Julia For Quantum Physics # JuliaCon 2020 Quantum BoF Materials Materials for Quantum BOF in JuliaCon 2020 ## Abstract Chat about [Yao](http://yaoquantum.org/), [ITensor](https://github.com/ITensor/ITensors.jl), [TensorOperations](https://github.com/Jutho/TensorOperations.jl), [OMEinsum](https://github.com/under-Peter/OMEinsum.jl) and development on common infrastructure such as lattices, sparse tensor, domain specific automatic differentiation etc. in Quantum Physics. ## Description Topics to discuss: - A Julian lattice package - Status of Julia library support for specialized tensor operation backends * CuTensor support in CuArrays * Support for TBLIS, GETT and similar? * Algorithms people want (TDVP, TEBD, tDMRG, any four letter acronym like this) - Domain specific automatic differentiation (AD) * AD through SVD in Julia libraries such as Zygote - GPU stuff * multi GPU parallelism * exploiting mixed precision for some quantum libraries - Tutorial writing - Julia quantum as a teaching tool - interactive graph demos? - Benchmarking within the Julia community and compared to other packages See https://github.com/Roger-luo/juliacon-quantum-bof for details PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/8NDYCT/ BoF Xiu-zhe (Roger) Luo Katharine Hyatt, Matthew Fishman JinGuo Liu Matthew Fishman PUBLISH 9X7V3A@@pretalx.com -9X7V3A JuliaGPU en en 20200730T180000 20200730T184500 004500 JuliaGPU PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/9X7V3A/ BoF Valentin Churavy PUBLISH YPT9CQ@@pretalx.com -YPT9CQ NumFOCUS and Julia project finances en en 20200730T184500 20200730T193000 004500 NumFOCUS and Julia project finances Income for the Julia project comes primarily from JuliaCon sponsorships, and some individual contributions. Expenditures is primarily the organisation of JuliaCon, as well as smaller events and hackathon. Join the BoF channel on Discord. PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/YPT9CQ/ BoF Avik Sengupta PUBLISH LCDHAG@@pretalx.com -LCDHAG Gather Town Social en en 20200730T193000 20200730T201500 004500 Gather Town Social PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/LCDHAG/ BoF PUBLISH NPWSWB@@pretalx.com -NPWSWB A Computational Textbook for Teaching Data Science with Julia en en 20200731T123000 20200731T130000 003000 A Computational Textbook for Teaching Data Science with Julia Over the past two years at the University of Michigan, we have successfully taught computational data science and machine learning using Julia to over a thousand graduate students, spanning over 80 disciplines. We've scaled to support 275 enrolled students (Fall 2019) and expect to scale to over 500 in the very near future. The course is taught in a hybrid lecture-lab style which presents students with the opportunity to experience hands-on, interactive, inquiry-based learning. Student feedback has been overwhelmingly positive. We will present a hands-on demo, featuring selected content from the course, and invite the audience to experience it for themselves. We will present our vision for an interactive computational textbook platform designed to stimulate deeper conversations between students and the material that they are attempting to master. The primary technique used to facilitate this deeper engagement is the punctuation of instructional content (such as motivation, math fundamentals, theorems, proofs, etc.) with short, self-contained exercises that are designed to allow the student to constantly check their understanding. Exercises include conceptual questions to check comprehension of the underlying content, auto-graded programming assignments to practice the ability to put ideas into practice as code, and free-response prompts to allow the student to make their own observations and draw the appropriate conclusions. The effect of this constant "self-checking" is two-fold. First, students are forced to more rigorously develop foundational knowledge before moving on to more advanced topics. This sets students up for success when the more advanced content is presented and avoids the dreaded "content paralysis" phenomenon where students are overwhelmed by the sheer scope of content on first glance (this usually manifests itself as a student blindly running code in “run-all mode" in an attempt to produce the desired results instead of actually understanding what they are doing). Second, this framework allows an author to more carefully design content to encourage a guided learning experience. The author can design a narrative, complete with exposition (what is this algorithm?), conflict (when does it fail?), and resolution (how can we fix it?). Our demo will allow you to experience how much more immersive “living” computational textbooks written in this way can be. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/NPWSWB/ Red Track Travis DePrato Raj Rao PUBLISH VPUS7J@@pretalx.com -VPUS7J Introducing the Hispanic community to Julia en en 20200731T130000 20200731T131000 001000 Introducing the Hispanic community to Julia For Julia, the diversity of users is fundamental for its development and growth. Users from different backgrounds, regions, ages, and social contexts can contribute with different perspectives, and promote its usage in their context. This talk presents our experience translating into Spanish the open-source book “Think Julia”, titled “Introducción a la Programación en Julia”. The goal of this translation is to facilitate the use of Julia in the Hispanic community. We will share how we planned and executed the translation, what we learned in the process, and why you might want to do something similar. The talk will review the choice to translate an introductory text rather than the Julia manual, including its utility to students in secondary education (high-school). A brief history of ThinkJulia will be shared, including its license and the use of Julia to verify inline code excerpts. We will review the utility of PDF and online versions (see https://introajulia.org/). "Intro a Julia" will be presented as a valuable tool for Spanish coders without English proficiency. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/VPUS7J/ Red Track Pamela Alejandra Bustamante Faúndez PUBLISH YYWMPR@@pretalx.com -YYWMPR No-overhead Game Development in Julia en en 20200731T131000 20200731T132000 001000 No-overhead Game Development in Julia Every child who starts programming wants to build games. Evidence of this can be seen in the popularity of block-based languages like Scratch. However, once they move to text-based languages (such as Julia), they struggle with the overheads of game development libraries, rather than being able to simply express their ideas in code. In this talk, I will demonstrate how to build simple games without the difficulties of low-level game-development frameworks, using GameZero.jl, a Julia library inspired by the Pygame Zero package. The talk will describe the library through the use of a series of examples that progressively build games from the simple to the more complicated. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/YYWMPR/ Red Track Ahan Sengupta PUBLISH HJTZNE@@pretalx.com -HJTZNE Julia Track Google Code In and Beyond en en 20200731T132000 20200731T133000 001000 Julia Track Google Code In and Beyond Some highlights for Google Code In were working with the NeuralNetDiffEq and Flux packages. In this talk, I will describe the process of writing a 2nd order ordinary differential equations solver using Neural Networks as part of GCI. Subsequently, I will cover how I used Flux to implement UNet's Fully-Convolutional Network architecture, for binary and multi-class (3 symptoms: ground glass, consolidation, pleural effusion) segmentation on the COVID-19 CT Segmentation Datasets, and discuss the Julia versus Python workflow in creating Corona-Net. Lastly, I will reflect on the impact of Google Code In Julia track on teenage ML & Open Source enthusiasts like myself, and how it ties in to my subsequent opportunities at NVIDIA. (A big thank you to Chris Rackauckas, Kirill Zubov, Avik Sengupta, Dhairya Gandhi, Avik Pal and Logan Kilpatrick for all their guidance in GCI, JuliaCon and beyond!) PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/HJTZNE/ Red Track Choi Ching Lam PUBLISH 9GDBEW@@pretalx.com -9GDBEW Julia in Education for Generation Z en en 20200731T133000 20200731T134000 001000 Julia in Education for Generation Z The students who belong to Generation Z or post-millennials have access to gadgets such as smartphones even before they go to school. This makes them technology savvy and at the same time, they get bored easily in a traditional classroom setting. It becomes necessary to use modern tools and techniques in the classroom to engage students in activities. Also, governments are promoting “Bring Your Own Device (BYOD)” concept in education which can be a boon to those who cannot afford a computer or laptop. In this BOF, I will demonstrate how Julia can be installed on a smartphone and execute Julia programs on the smartphone. Next, I will also introduce visual programming tools like flowgorithm which is a flowchart interpreter to generate Julia code (The Julia code generator for flowgorithm is available at https://github.com/gcdeshpande/Julia-Code-Generator). Then I will demonstrate how we can import Python packages in Julia for creative programming. Then the session will be open for the audience where they can share their thoughts on the topic. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/9GDBEW/ Red Track Gajendra Deshpande PUBLISH Z3RDBQ@@pretalx.com -Z3RDBQ Developing an exercise-based Julia curriculum en en 20200731T134000 20200731T135000 001000 Developing an exercise-based Julia curriculum To motivate the development of the new version and curriculum of the Exercism Julia Track (referred to as v3 from now on), we will briefly outline the history of Exercism, and the major problems of previous versions, mainly large amounts of repeated work by mentors and a lack of structured progression through concepts that the student needs to learn when learning Julia. The human interaction and mentoring is the core of Exercism, and the v3 curriculum is built around making these interactions as meaningful as possible. During the development of v3, we first identified concepts that make Julia unique and that users must know in order to reach “fluency” in the language. Then, we built bite-sized concept exercises that teach these concepts, ideally isolated from other concepts. These will be mentored automatically based on a normalization of the solution and community-sourced feedback. Solving these exercises unlocks practice exercises that can be used to deepen learned concepts and allow many different approaches whose merits can be discussed with a human mentor. While there are many great resources for learning Julia, information on how to create such resources is scarce. By sharing our experiences, challenges and learnings from creating v3, we hope to encourage others to create learning resources and share our approach to creating one. Additionally, we believe that the tooling, primarily the normalization of solutions, and the exercise pool can be of use to others teaching Julia. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/Z3RDBQ/ Red Track Sascha Mann PUBLISH FHEGUA@@pretalx.com -FHEGUA The ups and downs of convincing to switch to Julia in a company en en 20200731T135000 20200731T140000 001000 The ups and downs of convincing to switch to Julia in a company ASML is company in the Netherlands which is the world leader on photo-lithographic system which are crucial for semi-conductor manufacture. For many years its engineers have been using MATLAB to develop hardware and algorithms that are usually rewritten in C/C++ on the main photo-lithography systems. This is the well known *two-language problem* and for mission critical systems this has been accepted for long time. For several years ASML has been expanding its market to Analytics and Software for process optimization for which the two-language problem seems to be a little less forgiving than for hardware because time to market is a larger driving force. For this Julia seems to be a natural candidate to solve the problem. However as this talk will show it is hard to convince "normal" engineers to switch from their trusted tried and truth tools. Moreover, it's even harder to convince them to switch to a relatively unknown/unfamiliar language than a more mainstream like python ... even when it's not the right tool for the job. Which makes things even more difficult is that managers also have a say on this and most think that this is just a fad. This presentation will give an overview of common reactions, comments and attitudes, and hopefully a guide on how to work around them. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/FHEGUA/ Red Track Jorge Alberto Vieyra Salas PUBLISH LG3GQP@@pretalx.com -LG3GQP Keynote: Linda Petzold en en 20200731T142000 20200731T150500 004500 Keynote: Linda Petzold TBA PUBLIC CONFIRMED Keynote https://pretalx.com/juliacon2020/talk/LG3GQP/ Red Track Linda Petzold PUBLISH PLFURQ@@pretalx.com -PLFURQ Pkg.update() or What's going on in Pkg-land? en en 20200731T151000 20200731T152000 001000 Pkg.update() or What's going on in Pkg-land? The new package manager, `Pkg`, that comes with Julia 1.0 had many improvements over the previous one. However, just because Julia 1.0 was released, did not mean that the work on Pkg stopped. The biggest feature that has landed is the [Artifact system](https://julialang.org/blog/2019/11/artifacts/) which got added in 1.3. There are however also some other, smaller features that might have gone under the radar, for example: - New resolver strategy to reduce the number of resolver errors when adding packages but also reduce the number of unnecessary updates to packages when adding a package. - Built-in support for managing registries. - Argument passing to the test process - Support for instantiating a manifest without a corresponding project file. In addition, there are some exciting features that are in development some of which are listed below: - Offline mode (aka airplane mode) allows one to develop packages in a convenient manner even while being offline. - Community driven hosting of packages and artifacts allows for package authors to see e.g. download stats for their packages. - Multiple packages in one repo. This talk will summarize the new features of `Pkg` since 1.0 and also give an overview of plans and work in progress for future `Pkg` releases. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/PLFURQ/ Red Track Kristoffer Carlsson PUBLISH RMGYYX@@pretalx.com -RMGYYX Lessons learned on trait-based descriptions of graphs en en 20200731T152000 20200731T155000 003000 Lessons learned on trait-based descriptions of graphs The talk will cover the definition of interfaces for a Julia ecosystem and advantage of a trait-based approach, these two topics being of interest not only for graphs, but for other packages defining a common interface to reason on. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/RMGYYX/ Red Track Mathieu Besançon PUBLISH HBTFT7@@pretalx.com -HBTFT7 Using VS Code for Julia development en en 20200731T161000 20200731T164000 003000 Using VS Code for Julia development This talk is targeted as novel and experienced users of the Julia VS Code extension. I will provide an overview of the basic functionality, showcase tricks and good practice. I will also introduce a number of major new features that have been introduced since the last Juliacon: - the debugger and how to effectively use it. - the workspace view and how to effectively use it. - support for Julia Notebooks, how they work and how one can use them. - how one can use the remote capabilities of VS Code for Julia developments (including VS online). PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/HBTFT7/ Red Track David Anthoff PUBLISH KZK93G@@pretalx.com -KZK93G Display, show and print -- how Julia's display system works en en 20200731T164000 20200731T171000 003000 Display, show and print -- how Julia's display system works When Julia finishes a computation and obtains a value the user is presented with the result. In the Julia REPL the result is usually represented as plain text. In other environments, such as in a Jupyter notebook, you sometimes see more rich representations, for example some values display as HTML, and others as images. The main functions responsible for output in Julia are `display` and `show`. Usually `display` is the first method to be called when an object is presented to the user. The `display` function is implemented by displays such as the Julia REPL, the IDE or the notebook interface. Next, `display` requests output from `show` with a specific so-called MIME-type. Which MIME-types that are requested depends on what output the display is able to present back to the user. For example, the REPL mostly works with the `text/plain` MIME-type, and the notebook display supports multiple additional MIME-types, for example `image/png` for image output, `text/html` for HTML output, and so on. Given this rough overview the display system might seem rather simple, but there are many hidden complexities. In order to take advantage of the rich display system and implement "pretty printing" for a custom type it is generally enough to implement methods of `show` with specific MIME-types. All types get a default text representation, but this can easily be overridden by implementing `show` with the `text/plain` MIME type. If the type can be represented in richer formats it is simple to add additional methods. For example, in order to support image output in a notebook it is enough to implement `show` with the `image/png` MIME type. This talk will present how Julia's display system works and go through the process of taking an output object and generating output to present the user with. The talk will also examplify this process by discussing how to customize the output for your own types. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/KZK93G/ Red Track Fredrik Ekre PUBLISH S9TDNB@@pretalx.com -S9TDNB Invenia en en 20200731T171000 20200731T171500 000500 Invenia PUBLIC CONFIRMED Sponsor Talk https://pretalx.com/juliacon2020/talk/S9TDNB/ Red Track PUBLISH T7VKHM@@pretalx.com -T7VKHM Pumas en en 20200731T171500 20200731T172000 000500 Pumas PUBLIC CONFIRMED Sponsor Talk https://pretalx.com/juliacon2020/talk/T7VKHM/ Red Track PUBLISH ER3ZYC@@pretalx.com -ER3ZYC Changing the immutable en en 20200731T172000 20200731T173000 001000 Changing the immutable In Julia, some objects are *mutable* (`Array`, `mutable struct`, `...`), while others are *immutable* (`Tuple`, `struct`, `...`). Neither is strictly better than the other in every situation. However, *immutability* usually leads to code that is easier to reason about, for both humans and compilers. And therefore less buggy and more performant programs. One convenience with mutability is, that it makes updating objects very simple: `spaceship.captain.name = "Julia"` The analogous operation in the immutable case is to create a copy of `spaceship`, with just the captain's name changed to "Julia". Just think for a moment, how would you achieve this? It is a serious obstacle to adopting immutables in practice. The title "Changing the immutable" refers to this and similar problems. There are various approaches, for instance, https://github.com/JuliaLang/julia/pull/21912 . I would like to talk about this problem and present one solution, namely [`Setfield.jl`](https://github.com/jw3126/Setfield.jl). In the spirit of Julia, it is dirt simple to learn: `@set spaceship.captain.name = "Julia"` yet keeps the most serious hackers happy (as it is built around the beautiful concept of [lenses](https://hackage.haskell.org/package/lens)). PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/ER3ZYC/ Red Track Jan Weidner PUBLISH ZRC8HA@@pretalx.com -ZRC8HA SmartHomy: Julia controlling your home and life! en en 20200731T173000 20200731T174000 001000 SmartHomy: Julia controlling your home and life! PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/ZRC8HA/ Red Track Simon Danisch PUBLISH MCFFUY@@pretalx.com -MCFFUY Minisymposium on Partial Differential Equations en en 20200731T180000 20200731T193000 013000 Minisymposium on Partial Differential Equations Julia with its near optimal scalar performance, built-in multithreading, multiprocessing, and packages for GPU computing in combination with its generic programming facilities provides a new opportunities to implement high- performing and easy to uses packages for PDE solution. On the other hand, it is likely that the full potential of Julia with respect to this problem class has not been reached yet. The ecosystem of packages and the language itself have barely matured. We propose a minisymposium whose contributors present their Julia packages connected with the solution of partial differential equations and systems thereof. The talks shall appeal to a broader public. Updated July, 26: The following pre-recorded talks will be given: - Petr Krysl: "Julia for PDEs: Come for the speed, stay for ... much more" 10min - Jürgen Fuhrmann: "VoronoiFVM.jl: Finite Volume Methods for Nonlinear Multiphysics Problems" 17min - Kristof Cools: 'BEAST.jl - Minisymposium on Partial Differential Equations" 19min - Kirill Zubov: "NeuralPDE.jl: Physics Informed Neural Networks for Automated PDE solving" 15min - Michael Reed: "Grassmann.jl - Minisymposium on Partial Differential Equations" 17min During the remaining time, we will discuss the state of Julia concerning the solution of partial differential equations: - What are the pieces that are in your opinion missing from the Julia for PDE ecosystem? - What would make the ecosystem easier to use for novice users? - What would make it easier to collaborate? - What do you see as a role for the Julia PDE organization? PUBLIC CONFIRMED Minisymposia https://pretalx.com/juliacon2020/talk/MCFFUY/ Red Track Jürgen Fuhrmann PUBLISH 79FJUW@@pretalx.com -79FJUW Generic Manpower Simulation Engine: a SimJulia case study en en 20200731T123000 20200731T130000 003000 Generic Manpower Simulation Engine: a SimJulia case study Many studies have shown that proper human resource management is vital to the success of any organisation. This means that managers need to balance the needs of the organisation with the needs of their employees, and are required to make well-informed planning decisions. One part of the problem covers short term planning, such as setting up employee rosters to ensure an appropriate distribution of the workload over the employees. The other part deals with long term manpower planning, and usually concerns hiring and promotion policies to meet the organisation’s goals without alienating its employees. Naturally, any of the planning decisions have to be made within a certain legal framework that the organisation cannot influence. As such, such decisions are too important to be left to the manager’s "gut feeling". Instead, they can rely on a variety of mathematical models to provide invaluable insights to allow them to make the appropriate decisions. These models can be of various types: Markov models, optimisation models using mathematical programming, stochastic simulation models, or system dynamics models, each with their own benefits and drawbacks. In particular, we have chosen to develop a tool, the Generic Manpower Simulation Engine (GMSE), based on stochastic simulation, as an organisation’s internal structure and policies are often too complex and varied to be able to estimate all the effects of a particular change. Instead, our tool allows the user to define the structure of the organisation and its policies, entering only the direct effect these policies have on the personnel members of that organisation. Once the system is configured, the user can then run the simulation for the period of interest, and request reports on the state of the organisation at any time point covered by the simulation. This allows the user to get a prediction of the full impact of specific proposed policy changes, among other applications. The GMSE is developed entirely in Julia with the SimJulia library at its core, and provides all the necessary methods to fully configure a manpower simulation from within Julia for the expert user, as well as a way to configure one from MS Excel. In addition to giving an overview of the GMSE, we will show how we use the SimJulia library, and we illustrate some of the challenges we faced, and how we decided to handle those challenges. Finally, we give a quick overview of how we can use the GMSE to optimise the organisation’s policies. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/79FJUW/ Green Track Johan Van Kerckhoven PUBLISH S9BVBR@@pretalx.com -S9BVBR Migrating to JuMP: Leaving Behind Domain Specific Languages en en 20200731T130000 20200731T131000 001000 Migrating to JuMP: Leaving Behind Domain Specific Languages The REopt™ techno-economic decision support platform is used by the National Renewable Energy Laboratory (NREL) researchers to optimize energy systems for buildings, campuses, communities, microgrids, and more. REopt recommends the optimal mix of renewable energy, conventional generation, and energy storage technologies to meet cost savings, resilience, and energy performance goals. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/S9BVBR/ Green Track Josiah Pohl PUBLISH V3QDAM@@pretalx.com -V3QDAM Crash Course in Energy Systems Modeling and Analysis with Julia en en 20200731T131000 20200731T132000 001000 Crash Course in Energy Systems Modeling and Analysis with Julia Researchers at the U.S. National Renewable Energy Laboratory (NREL) have developed a new suite of infrastructure modeling capabilities to understand emerging energy systems operations and planning challenges. This talk will introduce the power systems modeling and analysis capabilities enabled by NREL researchers. Basic overviews of the following packages and associated capabilities will be presented: - **PowerSystems.jl:** Power system data specification, parsing, and analysis. - **PowerSimulations.jl:** Optimal power system scheduling, production cost modeling, and quasi-static system simulation. - **PowerGraphics.jl:** Visualization and analysis of power systems simulation results. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/V3QDAM/ Green Track Dheepak Krishnamurthy Clayton Barrows PUBLISH ETWX8X@@pretalx.com -ETWX8X HydroPowerModels.jl: Impacts of Network Simplifications en en 20200731T132000 20200731T133000 001000 HydroPowerModels.jl: Impacts of Network Simplifications One of the most efficient algorithms for solving hydrothermal operation planning problems, which are large-scale multi-stage stochastic models, is the so-called stochastic dual dynamic programming (SDDP) algorithm. Operation planning of power systems aims to assess the value of the scarce resources (e.g. water) to feed short-term dispatch models used in the actual implementation of the decisions. When the planning model significantly deviates from the reality of the implemented operation, decision policies are said to be time-inconsistent. Recent literature has explored different sources of inconsistency such as time-inconsistent dynamic risk measures, inaccurate representation of the information process and simplifications in the network planning model. This work addresses the time-inconsistency due to simplifications in the network representation in the planning model extending the existing literature. The objective of this work is to propose a framework, comprised of a methodology and an open-source computational package, for testing the operative and economic impact of modeling simplifications over the network power-flow in hydrothermal power systems.  In this presentation, we will discuss how the [HydroPowerModels.jl](https://github.com/andrewrosemberg/HydroPowerModels.jl) package models hydrothermal operation planning problems and how we have to use it to study the impacts of time-inconsistency in the operation of hydrothermal power systems. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/ETWX8X/ Green Track Andrew Rosemberg PUBLISH ELXNUQ@@pretalx.com -ELXNUQ Solving Practical Allotment Problems with Julia en en 20200731T133000 20200731T134000 001000 Solving Practical Allotment Problems with Julia Allotting interviewers to candidates, teaching assistants to courses, and invigilators to exams are routine problems at our university. These types of problems are combinatorially hard to solve and consumed significant staff-hours for manually coming up with decent allotments. We model such allotment problems as a Bipartite graph matching and develop a stochastic optimization approach to obtain an approximate solution. We developed a computational approach requiring no manual effort, which offers better allotments than previous manual solutions. We initially implemented this in Python, which brought down the time required for obtaining an allotment to a couple of CPU-hours. By reimplementing the solver in Julia, we got a speedup of 13x over the Python implementation. In particular, we were surprised to find how fast Julia is for implementing iterative algorithms. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/ELXNUQ/ Green Track Saurabh Kumar PUBLISH ZMHR9V@@pretalx.com -ZMHR9V A Parallel Time-Domain Power System Simulation Toolbox in Julia en en 20200731T134000 20200731T135000 001000 A Parallel Time-Domain Power System Simulation Toolbox in Julia Dynamic simulations are important in the design and operation of power systems in order to ensure grid stability. Traditional simulation tools in research and industry mainly rely on time-domain simulations based on step-by-step numerical integration. The power system, however, has seen an increase in complexity in light of the current operation of large interconnected networks, growth in electricity demand, and the increasing integration of renewable energies. From the power system analysis perspective, the impact of these changes in operating conditions is an increase in computational complexity in the simulation tools applied for stability and control studies. Parallel and distributed computing techniques are frequently applied to improve the computational speed by taking advantage of multi-core processors and cluster computing. However, the analysis methods for time-domain simulations were developed for sequential operation and optimized for running on single-processors, thereby rendering their application for parallel solutions challenging. This talk introduces a new Julia-based parallel simulation algorithm to address the need for efficient computation methods in power system stability analysis. The parallel algorithm achieves computational efficiency by adapting an inherently sequential power system numerical solution to a parallel solution using a parallel-in-space decomposition scheme and the Julia computing environment. This talk will describe the parallel-in-space technique which is applied to restructure the power system problem in such a way that it can be applied for formulation of a parallel algorithm. The in-space decomposition is based on the Block Bordered Diagonal Formulation (BBDF) to divide the network coefficient matrix into submatrices that can be solved in parallel. The talk will show how optimal balancing of tasks in the parallel solution process is achieved using a multi-level graph partitioning technique, which is extended to the dynamic simulation problem to obtain balanced subnetworks to be solved in parallel and only linked via an interconnect partition to share information at every time step. Simulation results will be presented using IEEE standard test networks of varying complexity. The results in the parallel simulation toolbox are compared to those obtained from a sequential implementation in order to validate the solution accuracy and to determine performance improvements in terms of computational speedup. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/ZMHR9V/ Green Track Michael Kyesswa PUBLISH JFUJJ7@@pretalx.com -JFUJJ7 Evolutionary algorithms for electrical circuit design en en 20200731T135000 20200731T140000 001000 Evolutionary algorithms for electrical circuit design Electrochemical impedance spectroscopy (EIS) is the study of a sample by measuring its resistance to alternating electrical currents (termed impedance) over a range of frequencies. The data arising from these experiments is commonly analysed by fitting an equivalent electrical circuit (EIC), which consists of resistors, capacitors and possibly other electrical elements. When considering well defined basic electrical systems, the configuration of these circuits is relatively straightforward. More complex systems, such as those arising in biology, where reasoning about the appropriate configurations of the circuits becomes more challenging and subjective, can benefit from an algorithmic approach. An efficient Julia equivalent electrical circuit modelling and fitting module that was implemented will be discussed. Next the evolutionary algorithms used to build optimal circuit designs based on the biological measurement data and fit the circuit-element parameters of the design, will be explained along with some performance metrics. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/JFUJJ7/ Green Track Maxime PUBLISH B3VAGU@@pretalx.com -B3VAGU Auto-Optimization and Parallelism in DifferentialEquations.jl en en 20200731T161000 20200731T164000 003000 Auto-Optimization and Parallelism in DifferentialEquations.jl A general compiler can only have so much knowledge, but when we know that someone is solving a differential equation, there are a million things that we know. We know that different sizes of differential equations will do better/worse with different solver methods, we know that sparsity of the Jacobian will have a large impact on the speed of computation, we know that the user's `f` function describing the ODE can be considered independently from the rest of the program, and so on. In DifferentialEquations.jl, we have codified these ideas in order to build a toolchain that automatically optimizes a user's `f` function in order to spit out a more optimized DEProblem. This works by first tracing to a symbolic sublanguage, ModelingToolkit.jl. By using tasks to time-out, we can try performing an auto-trace which, if successful, gives us a complete symbolic mathematical description of the user's numerical code. We can then proceed to symbolically analyze the function to generate the analytical solution to the user's Jacobian and even symbolically factorize the Jacobian, if doable in the allotted time. From the symbolic world we can then auto-parallelize the generated Julia code, chunking the output into tasks to multithread, or using a cost model determine that the ODE is large enough to automatically distribute (with auto-GPU coming soon). If the system is not symbolically trace-able (there is a while loop depending on an input value, something that is quite uncommon), then we can resort to IR-based and adaptive analysis. We will demonstrate how SparsityDetection.jl can automatically identify the sparsity pattern of the Jacobian for a Julia code and then use SparseDiffTools.jl to accelerate the solve of stiff equations by performing a matrix coloring and optimizing the Jacobian construction for the problem. We will then discuss how DifferentialEquations.jl automatically picks the solver algorithm, defaulting to methods which can automatically switch between stiff and non-stiff integrators, determining stiffness on the fly with heuristics. Together, we have demonstrated that these auto-optimizations can improve the code of even experienced Julia programmers by >100x by enabling sparsity coloring optimizations that they may not have known about, and by parallelizing code that is either difficult to parallelize or is simply automatically generated and thus hard to intervene with. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/B3VAGU/ Green Track Chris Rackauckas PUBLISH QABEK8@@pretalx.com -QABEK8 ChainRules.jl en en 20200731T164000 20200731T171000 003000 ChainRules.jl [Slides](https://raw.githack.com/oxinabox/ChainRulesJuliaCon2020/main/out/build/index.html) A perhaps counterintuitive requirement for differentiable programming is easy hand-coded rules for determining derivatives. You might think: “I thought the whole point of differentiable programming was to use AD, so I didn’t have to write all these derivatives by hand.”. Indeed you don’t have to, but that doesn’t mean you shouldn't be allowed to, and it doesn’t mean you can't get advantages out of doing do. Custom sensitivities allow programmers to insert domain knowledge that no autodiff system could ever figure out. Further custom rules, let you work around any bugs in the AD system, and fix performance issues. So being able to write custom rules is important, and doing it once for every AD system is win on deduplicating effort. A secondary advantage of ChainRules is that it provides a set of differential types to be used by AD systems. The differential types provided by ChainRules are very expressive, more expressive in-fact than is required for any current AD system. These types allow ChainRules to act as a lingua franca between AD systems. If it is advantageous because of some properties of your system to AD one part with ForwardDiff2 (via forward-mode), another part with Zygote (via source code transformation reverse mode) and another via Nabla (via overloading tape-based reverse mode) then you can; and each part can understand the derivative types returned by the other. The ChainRules project has 3 packages: - ChainRulesCore.jl: the minimum stuff required to implement custom rules for your package. Think of it like RecipesBase for Plots.jl. It should be used by all packages wanting to support rules. - ChainRules.jl: a repository of rules for functions defined in Base and the Standard Libraries. This was separated out from ChainRulesCore to minimize load time. It should be used by AD packages wanting to consume rules. - ChainRulesTestUtils.jl: robust testing utilities based on finite differencing. Its a test-time dependency for packages defining rules. This talk will cover: - An introduction to AD, including terminology such as pullback, custom sensitivity etc. - The details the use and design of the ChainRules packages - An explanation of some of the open questions in autodiff and our resolutions to them including: natural vs structural derivatives, mutating reverse-mode AD, chunked AD / change of basis, one-to-one vs many-to-many relationships between differential and primal types. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/QABEK8/ Green Track Frames Catherine White PUBLISH KCFCMQ@@pretalx.com -KCFCMQ Manifolds in Julia – Manifolds.jl & ManifoldsBase.jl en en 20200731T171000 20200731T174000 003000 Manifolds in Julia – Manifolds.jl & ManifoldsBase.jl [Slides](https://ronnybergmann.net/talks/2020-JuliaCon-Manifolds.pdf) In many scientific and engineering scenarios, measured data or model variables lie in smooth, nonlinear spaces like the sphere or the group of 3D rotations. Such spaces often have a manifold structure, that is, they locally can be approximately linearized (_i.e._ they are locally diffeomorphic to a Hilbert space). Equipping such manifolds with a (pseudo-)Riemannian metric tensor, which defines a ruler on the manifold, enables local computation of distances and angles. These features enable construction of efficient algorithms that respect the nonlinear structure, for example for optimization, interpolation, and statistical modeling. In this talk, we demonstrate various tools that [Manifolds.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/) provides for working with manifolds. With these tools, you can for example explicitly locally linearize points using inverse retractions and orthonormal bases. You can also compute intrinsic statistics, such as the Riemannian mean and variance, of data on manifolds. We also extend [Distributions.jl](https://juliastats.org/Distributions.jl/stable/) to support distributions on arbitrary manifolds, which can be used to generate random points on a manifold or for statistical modeling. [Manifolds.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/) implements a library of manifolds and provides combinators to construct new manifolds from these. Examples are the product manifold of two manifolds, the power manifold, the tangent bundle, and Lie groups. Using a trait-based system, any manifold may be augmented with additional geometric structure, including various metrics, without sacrificing efficiency. We also present the light-weight interface package [ManifoldsBase.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/interface.html), which enables users to easily extend [Manifolds.jl](https://juliamanifolds.github.io/Manifolds.jl/stable/) with new algorithms and additional manifolds thanks to multiple dispatch. The interface can also be used to develop new, stand-alone projects. It is minimally restrictive and makes it possible to write algorithms that are independent from any concrete implementations of the manifolds. One package that uses this interface is [Manopt.jl](http://manoptjl.org), which provides optimization algorithms on Riemannian manifolds, with a focus on high-dimensional and non-smooth optimization. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/KCFCMQ/ Green Track Ronny Bergmann PUBLISH UPHPAT@@pretalx.com -UPHPAT GigaSOM.jl: 1 billion cytometry events and beyond with Julia en en 20200731T180000 20200731T183000 003000 GigaSOM.jl: 1 billion cytometry events and beyond with Julia GigaSOM is an implementation of the Self-Organizing-Maps algorithm by Kohonen that facilitates the clustering and dimension reduction of huge-scale datasets, counting billions of individual data points with tens of dimensions. Its development, showcased at the 2019 JuliaCon conference, is motivated by the needs of flow and mass cytometry data analysis, relevant in immunology, developmental biology and clinical medicine: Individual cells from the measurements need to be precisely categorized (which is currently best done by the self-organizing maps as devised by van Gassen et al. (2015)), and eventually evaluated and visualized. GigaSOM is able to perform this precise kind of computation on large compute clusters, and facilitates the analysis to scale horizontally. We will describe a Julia toolkit for map-reduce-style computation and data distribution in the common HPC environments, which we developed for the purposes of GigaSOM. The toolkit cooperates with the Distributed package, and works well within common cluster software, e.g. Slurm. With that in hand, we demonstrate high-level implementation of SOMs and related algorithms (e.g. EmbedSOM (Kratochvíl et al., 2019)) that scale horizontally, show measurements of the performance, and demonstrate the results achievable on several datasets, including the data from International Mouse Phenotyping Consortium (Brown & Moore, 2012). Notably, our testing showed that 1 billion data points can be processed within only minutes using relatively common computer clusters or cloud compute grids, which vastly expands the possibilities of large-scale data analysis. The quality of the software package is assured using ARTENOLIS (https://artenolis.lcsb.uni.lu) (Heirendt et al., 2017). Biological validation of the results is performed by comparison to conventional implementations of the FlowSOM package and manual analysis. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/UPHPAT/ Green Track Miroslav Kratochvíl Oliver Hunewald PUBLISH LUSFK8@@pretalx.com -LUSFK8 Simulating the Early Universe with Inflation.jl en en 20200731T183000 20200731T190000 003000 Simulating the Early Universe with Inflation.jl The early universe is a terribly violent place, but within the first 10<sup>-30</sup> seconds, cosmologists believe a process called inflation smoothed out the primordial universe into something that could expand and cool into our universe today. Simulating this process is a necessity for understanding the early universe, but in practice this means symbolically generating and then solving a challenging set of PDEs, and comparing their solutions to cosmological data. When the model includes unknown parameters, some parameter estimation is needed as well. I'll describe how Julia is the right tool for every step in this process. `Inflation.jl` generates the symbolic PDEs with a **symbolic tensor manipulation engine** built on `SymPy.jl` and `sympy.tensor.tensor`. Then `DifferentialEquations.jl` and related parameter estimation routines solve the PDEs, having little trouble even with high-dimensional inflation models. The presentation will be organized into the lessons I learned while developing the package, and what I think we can all learn and apply to our own scientific computing projects, in cosmology and other fields. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/LUSFK8/ Green Track Robert Rosati PUBLISH 7XARPV@@pretalx.com -7XARPV Makie.jl en en 20200731T190000 20200731T191000 001000 Makie.jl PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/7XARPV/ Green Track Simon Danisch PUBLISH BMNWLJ@@pretalx.com -BMNWLJ Interactive data visualizations with AlgebraOfGraphics en en 20200731T191000 20200731T192000 001000 Interactive data visualizations with AlgebraOfGraphics In this talk, I will present Algebra of Graphics, a novel take on the Grammar of Graphics (GoG) approach to plotting. In GoG (available in Julia thanks to for example Gadfly.jl or VegaLite.jl), a tabular dataset is used to inform how a plot should look like. Different columns correspond to different plot attributes, according to different scales. On top of that, columns can be transformed using "statistics", which in turn will inform what plot function to use (e.g. bar plot or scatter plot). On the other hand, in the recipe framework, implemented in the Plots.jl and Makie.jl packages, custom types are recursively transformed into simpler types, until a suitable visualization is found. I will show how [AlgebraOfGraphics.jl](https://github.com/JuliaPlots/AlgebraOfGraphics.jl) (the successor of StatsMakie.jl) attempts to bridge the gap between the two approaches, as it implements a version of Grammar of Graphics based on custom types and multiple dispatch. In particular, a combination of custom types (`Style` and `Analysis`) can be used to express how data should be grouped, styled, and analyzed (see [examples](http://juliaplots.org/AlgebraOfGraphics.jl/dev/generated/tutorial/)). These basic types can then be combined using the `+` and `*` operators. The interface is declarative. The "translation" from data columns to plot attributes relies on a default theme, which can be customized, thus changing the "look" of all visualization consistently. As the library is implemented in pure Julia, users are not limited to pre-built analyses but can implement their own, and they will automatically be integrated in the framework. This GoG-inspired framework, can then be combined with Makie's plot functions, as well as with the plot functions provided in StatsMakie.jl (such as boxplot or violin plot) or in other external packages. An added benefit of the GoG approach is that many different plot commands can be expressed with a uniform syntax. This greatly simplifies the creation of interactive user interfaces for data analysis, where the user can select (from e.g. dropdown menus) what columns of a dataset to use, what analysis to run, and how to group and style the data. I will show a simple UI to create visualizations of a tabular dataset interactively. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/BMNWLJ/ Green Track Pietro Vertechi PUBLISH XBLMPG@@pretalx.com -XBLMPG The Julia Vega and Vega-Lite ecosystem en en 20200731T192000 20200731T193000 001000 The Julia Vega and Vega-Lite ecosystem The Julia Vega ecosystem is made up of five packages and tightly integrated with the Queryverse. The packages that this talk will introduce are: - VegaLite.jl: the core grammar of interactive graphics package that makes it easy to create powerful figures with ease. - Vega.jl: if you need the power of the full Vega grammar, you can access it via this package. Creating figures with Vega.jl is more verbose, but gives you more control. - QuickVega.jl: this package provides a simple imperative API to create complicated figures without a full grammar of graphics API. - DataVoyager.jl: an interactive UI for data exploration that allows you to create Vega-Lite plots. - Lyra.jl: another interactive UI that is WYSIWYG editor for powerful Vega figures. I will also briefly on various front-ends that have native Vega and Vega-Lite support built in: ElectronDisplay.jl, the Julia VS Code extension, Jupyterlab and nteract. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/XBLMPG/ Green Track David Anthoff PUBLISH TKAXGF@@pretalx.com -TKAXGF Bringing Julia to the Realm of Electronic Structure Theory en en 20200731T123000 20200731T124000 001000 Bringing Julia to the Realm of Electronic Structure Theory Electronic structure theorists love performing novel research in a variety of ways. However, the use of new programming languages remains largely unexplored. Due to its combination of features, Julia could be an extremely useful tool for quantum chemists, enabling high productivity without sacrificing performance. In this talk, we will see how Julia’s potential in electronic structure theory can be realized, by introducing the JuliaChem.jl package. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/TKAXGF/ Purple Track David Poole PUBLISH MMJXXC@@pretalx.com -MMJXXC Interrogating intratumor heterogeneity dynamics with Julia en en 20200731T124000 20200731T125000 001000 Interrogating intratumor heterogeneity dynamics with Julia Cancer research stipulates that more heterogenous tumor cell populations ultimately drive unfavorable outcomes for patients. To study this question, we have developed software tools in Julia that harnesses evolutionary game theory methodologies like replicator-mutator dynamics and random walk model simulations through DifferentialEquations.jl and Distributions.jl along with data analysis pipelines for quantifying generalized diversity index (GDI) with DataFrames.jl and Query.jl. These tools reveal quantitative insights into how GDI changes over time under evolutionary pressures. Julia has solved our two-language problem allowing us to interrogate temporal changes in intratumor heterogeneity by simulating different tumor ecological niches over time and quantifying those changes in diversity to help fight cancer. This talk will present this biological application and discuss how existing Julia packages make this analytical work feasible. I will also highlight some areas of biological science research where there are gaps in Julia tooling relative to other data science ecosystems such as R and Scientific Python. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/MMJXXC/ Purple Track Meghan Ferrall-Fairbanks PUBLISH GPFUZR@@pretalx.com -GPFUZR Analyzing species interaction networks in Julia en en 20200731T125000 20200731T130000 001000 Analyzing species interaction networks in Julia Network ecology is the novel approach to studying biodiversity. In that respect, this presentation provides an overview of three brand-new packages (`Mangal`, `EcologicalNetworks`, and `EcologicalNetworksPlots`) written by Timothée Poisot and collaborators, which were created in response to the increasing need to handle species interaction data in Julia. Built around state-of-the-art practices in network ecology, they largely facilitate the analysis and visualization of almost all types of species interaction networks. In these, two species are linked together if they can interact. The `Mangal` package is a wrapper around the Mangal database, which is among the world's most exhaustive open source database of ecological interactions. The Mangal database contains 172 well-documented datasets for a total of 1300 ecological networks worldwide. It encompasses various types of ecological networks, including predation (food webs), pollination and parasitism networks. In addition, the `EcologicalNetworksPlots` package implements the visualization of ecological networks, whereas `EcologicalNetworks` provides functions for the analysis of their emergent structure. The structure of species interaction networks is a rich source of information, as it is associated with the stability, dynamics, and functions of biological communities. The `EcologicalNetworks` package is the only one designed to conduct such a specialized analysis in Julia. It is also a suitable tool for the simulation of networks under different sets of assumptions and ecological models. These two packages use a well-documented type system for networks in order to capture the various types of data typically handled by network ecologists. This makes them easily extensible and somewhat fast. Together, these three packages provide an extremely valuable methodological framework for the analysis of ecological networks in Julia. Our presentation offers an overview of their key features and depicts some of their concrete applications in this complex and emerging subfield of biology. It is aimed at ecologists among the Julia community, but also more broadly at network scientists and other attendees fascinated by networks and graphs. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/GPFUZR/ Purple Track Francis Banville PUBLISH DTAFMF@@pretalx.com -DTAFMF A fast atmospheric radiation code for global circulation models en en 20200731T130000 20200731T131000 001000 A fast atmospheric radiation code for global circulation models PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/DTAFMF/ Purple Track Charlie Kawczynski PUBLISH PTL7YB@@pretalx.com -PTL7YB BITE, a Bayesian glacier thickness estimation model en en 20200731T131000 20200731T132000 001000 BITE, a Bayesian glacier thickness estimation model Accurate estimations of glacier ice thickness and volume are indispensable for ice flow modelling, hydrological forecasts and sea-level rise projections. I present a new ice thickness estimation model [1,2] based on a mass-conserving forward model and a Bayesian inversion scheme (BITE.jl code on github [3]). The model assimilates observations of ice thickness and speed using a Bayesian scheme implemented with a Markov chain Monte Carlo method, which calculates estimates of ice thickness and their error. The model is validated using 733 glaciers from four regions of the world with ice thickness measurements, and it is demonstrated that the model can be used for large-scale studies by fitting it to over 30,000 glaciers from around the globe. I will detail how Julia's speed as well as its productivity was indispensable in making the project succeed. [1] https://doi.org/10.1017/jog.2019.93, [2] https://juliacomputing.com/case-studies/bayesian.html, [3] https://github.com/mauro3/BITEmodel.jl PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/PTL7YB/ Purple Track Mauro Werder PUBLISH JPGZK3@@pretalx.com -JPGZK3 Climate models in 16bit: Arithmetic and algorithmic challenges en en 20200731T132000 20200731T133000 001000 Climate models in 16bit: Arithmetic and algorithmic challenges The need for high precision calculations with 64bit floating-point numbers for weather and climate models has been questioned. Lower precision numbers can accelerate simulations and are increasingly supported by modern computing architecture. Posit numbers, a recently proposed alternative to floating-point numbers, claim to have smaller arithmetic rounding errors in many applications. As a standardized posit processor does not exist yet, we emulate posit arithmetic with SoftPosit.jl on a conventional processor. Julia’s type-flexibility easily allows to test benefits of posits compared to floats at 16bit in the Lorenz system and in ShallowWaters.jl. We show that forecasts based on posits are clearly more accurate than floats. Mixing 16 bit arithmetic with 32 bit for critical computations strongly reduces errors and is promising for present-day float-based hardware. Reduced precision communication of boundary values with 16 or 8-bit encoded as floats or posits introduces negligible errors, presenting a perspective for reduced data communication within a computer cluster. Stochastic rounding modes, that are exact in expectation, are found to improve simulations at 16-bit and mimic uncertainties. Algorithmic bottlenecks with low precision are identified using Sherlogs.jl to facilitate the transition towards 16-bit arithmetic. We analyse algorithms form an information theory perspective to find the best number format for a given application. This approach led the the development of Sonums.jl, a number format that is optimal once trained on data to minimize the rounding error. The results promote the potential of 16-bit formats for at least parts of complex weather and climate models, where rounding errors would be entirely masked by intitial condition, model or discretization error. Co-authored by - Peter Dueben, ECMWF, Reading, UK - Tim Palmer, University of Oxford, UK PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/JPGZK3/ Purple Track Milan Klöwer PUBLISH UUECGJ@@pretalx.com -UUECGJ Intertwined Economic and Energy Analysis using Julia en en 20200731T133000 20200731T140000 003000 Intertwined Economic and Energy Analysis using Julia The Scalable Linked Dynamic Equilibrium (SLiDE) model is an implementation of a computable general equilibrium (CGE) model. CGE models are commonly used for detailed regional economic analysis of inputs, outputs, prices and quantities of various economic sectors to inform policy decisions. This talk will focus on the development of the data management approach with a focus on usability. We will delve into the inner workings of the SLiDE module to explore the benefits and challenges of using Julia for data science applications. Techniques used to standardize the publicly available blueNOTE dataset include autogenerated and populated structs and powerful multiple dispatch and methods. Discussion will include the design-thinking approach taken to create a user-friendly interface to scale the model in space, time, and sector and encourage further adoption of Julia in policy analysis. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/UUECGJ/ Purple Track Caroline Hughes PUBLISH LRRAGD@@pretalx.com -LRRAGD Poster Session 2 en en 20200731T161000 20200731T174000 013000 Poster Session 2 - ["Control and Automation Software for Chromatographic Processes" by Tiago Santos](https://pretalx.com/juliacon2020/talk/review/S8SQW3TQEQFLKDLGHXZNY93ZKXJFEXFX) - ["ContextTracking.jl - do you know where you are?" by Tom Kwong](https://pretalx.com/juliacon2020/talk/review/PSJDTU3ZVWNC7G3RKDLVCRCSLRPGEVGW) - ["Julia for Structural Engineering" by Henki Ashadi](https://pretalx.com/juliacon2020/talk/review/KY87TTQHX9BSHQPDT8HHSTDVZ3G8CJJG) - ["Steel Truss Design using Julia Programming Language" by Rahma Latifa Dewi](https://pretalx.com/juliacon2020/talk/review/APWY839YWNAYXCG9GXSVWJJLP7LQ98DW) - ["A two way real time communication for mute and deaf people" by Nafiz and Saiful Islam](https://pretalx.com/juliacon2020/talk/review/XC8RSZABX3SRTR3WN8PZBYTKWKVFACGV) - ["How to not lose a mind by paralelizing a feedback loop?" by paralelizing a feedback loop?" by Janis Erdmanis](https://pretalx.com/juliacon2020/talk/review/ZGP8BB3LYMFKWQ3VBVBGSGHXNG87KUGG) - ["Julia for cryptography, security and voting" by Janis Erdmanis](https://pretalx.com/juliacon2020/talk/review/L7YBHDCE3JNW3GLYC87QZL9HUEQ9KXNG) - ["Reproducible data science with the RENKU platform" by Christine Choirat](https://pretalx.com/juliacon2020/talk/review/GZJKCPEYRLXJBTZE7CQLCYMVLUG3S9FJ) - ["Julia Code Generator for Flowgorithm Flow Chart Interpreter" by Gajendra Deshpande](https://pretalx.com/juliacon2020/talk/review/79SJQV9USWAKCBASVVHMDY398MCFL7VA) - ["How Julia improves the ROI of analytics: A case study of Arthur" by Eric Torkia and Egan Picken](https://pretalx.com/juliacon2020/talk/review/9PUBLQWTPPKRKTL3UP3MAQ39R8EJZWBF) - ["JLBoost.jl: Hackable XGBoost-like Gradient Boosting Tree Package" by Dai ZJ](https://pretalx.com/juliacon2020/talk/review/XPJXWS3S3GZ8ASLUVCS3CXXWH9HZUMKF) - ["HierarchicalTemporalMemory.jl: a short delta from paper to code" by Konstantinos Samaras-Tsakiris](https://pretalx.com/juliacon2020/talk/review/DEKU8BUBDRYLTADSNXNBPNESL9WSRSGQ) - ["A new Traits.jl: Easily dispatch on whatever you want" by Stephan Sahm](https://pretalx.com/juliacon2020/talk/review/3PMFP3TEH8MLUFXW7JXNEMAZSUMKFASS) - ["Using Julia for User Interface Design" by Erik Engheim](https://pretalx.com/juliacon2020/talk/review/SPFQXYJFL9F9WQGCMDEXSFJ8KDLRWRUH) - ["Decision Modeling and Simulation with MCHammer.jl" by Eric Torkia](https://pretalx.com/juliacon2020/talk/review/RQCY8FWQSTLFHV8Q99SJQW8KLG99ZFXU) - ["Implicit RK solver for high precision numerical integration" by Mikel](https://pretalx.com/juliacon2020/talk/review/MQTDFQKVH3U3ACLWRMPKZNRXSPWE3CPX) - ["Bayesian curve reconstruction from noisy streams in Julia" by Marco Quartulli](https://pretalx.com/juliacon2020/talk/review/PDEZCD7HPMJ3XASVT3QGQSEH38XWUDH8) - ["WaspNet.jl, a Julian Spiking Neural Network Simulator" by Sam Buercklin](https://pretalx.com/juliacon2020/talk/review/WR798NBTNZCDELPRFVCQSTKA7CJ8MBE9) - ["A Julia coding font" by cormullion](https://pretalx.com/juliacon2020/talk/review/QQS3Y9NXHYYP9VUBAWRTZQB9VYYLNMKT) - ["Quantum Game Theory with Julia: A computational analysis" by Indranil Ghosh](https://pretalx.com/juliacon2020/talk/review/EWD7WUAQ3HSYJ7JHVB9LNXLF3VXPJYR8) - ["Exposing Julia to the frontend web developer via DanceJL" by Chris "Yoh" Meyers](https://pretalx.com/juliacon2020/talk/review/SVTDWU9UEY9HF8GNRPM7WGJZH7GSTR3Z) - ["Computing on Encrypted Data with Julia and Friends" by David W. Archer](https://pretalx.com/juliacon2020/talk/review/D3YYHHX7Y9ZCDFJNST8KVXU3BYAAPJLL) PUBLIC CONFIRMED Minisymposia https://pretalx.com/juliacon2020/talk/LRRAGD/ Purple Track JuliaCon Committee PUBLISH P8D3PF@@pretalx.com -P8D3PF DynamicGrids.jl: high-performance spatial simulations in Julia en en 20200731T180000 20200731T183000 003000 DynamicGrids.jl: high-performance spatial simulations in Julia DynamicGrids.jl facilitates the easy construction of custom high-performance spatial simulations. It provides tools to construct simple simulations like the game-of-life and other cellular automata, but also complex, multi-rule and even multi-grid simulations that can involve random grid writes and grid interactions. DynamicGridsGtk.jl and DynamicGridsInteract.jl provide live visual interfaces, where simulations can be tweaked in real-time. Dispersal.jl will be used to demonstrate its potential. PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/P8D3PF/ Purple Track Rafael Schouten PUBLISH Z8WWNV@@pretalx.com -Z8WWNV Natural Language Processing in Julia en en 20200731T183000 20200731T190000 003000 Natural Language Processing in Julia Natural Language Processing (NLP) enables the computers to analyse, understand and read human languages. In the past decade, tremendous growth has been witnessed in NLP owing to milestones like word embeddings, neural networks for NLP, attention and pre-trained language modelling. JuliaText packages, together with Flux, makes Deep Learning for NLP easy in Julia. ## Packages We will start with an overview of natural language processing. Then we pick up the task of Sentiment Analysis and discuss following packages: - `WordTokenizers.jl` provides various high-speed tokenizers and APIs for writing custom tokenizers for natural languages. - `CorpusLoaders.jl` contains a variety of (lazy) loaders for NLP corpora. - `Embeddings.jl` for working with Word Embeddings. - `Flux.jl` for neural networks. Next we will move on to some other NLP pipelines and discuss some APIs from `TextAnalysis.jl` ## Talk The attendees will gain working knowledge about how to apply the package for NLP in Julia. The talk will encompass the following: - Tokenizers (Sentence splitters and word tokenizers) in WordTokenizers.jl - Word Embeddings (mapping words to vectors of numbers) using Embeddings.jl - Recurrent Neural Networks and Language models. All notebooks with model weights at https://github.com/Ayushk4/JuliaCon20_Talk PUBLIC CONFIRMED Talk https://pretalx.com/juliacon2020/talk/Z8WWNV/ Purple Track Ayush Kaushal PUBLISH M8JLAF@@pretalx.com -M8JLAF Iterable Parser Combinators for fast parsing in pure Julia en en 20200731T190000 20200731T191000 001000 Iterable Parser Combinators for fast parsing in pure Julia Parsing data from strings recurrently is at the beginning of scientific computing and thus regular expressions are a familiar part of standard tooling. CombinedParsers constructors will be presented side-by-side with the equivalent regex syntax. The regex parser provided with the package can be used as a pure julia plug-in replacement for the current julia Regex type. Benchmarks and compliance with PCRE syntax will be reported based on the extensive unit tests of the PCRE library. Leveraging julia compiler optimizations for multiple dispatch and parametric types, CombinedParsers performance can for many patterns compete with the PCRE C library that currently is used by julia base Regex. Arbitrary transformations can be defined as part of the grammar definition, with convenient syntax for extracting data as named tuples. For optimized performance, parsing and transformation are decoupled, and parsing memoization can be used optionally. Parser combinators straightforwardly generalize from strings to parsing any iterator type. Logging and human-readable error messages help debugging complex parsers. CombinedParsers supports the iterate interface to lazily generate all valid parsings, and the TextParse interface to include CombinedParsers e.g. in CSV.jl. Preliminary packages for parsing wikitext and orgmode markup with ParserIterators are available. Other parsing packages (Automa.jl, ParserCombinator.jl) will be acknowledged. Current limitations and considerations for further optimization will be discussed. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/M8JLAF/ Purple Track Gregor Kappler PUBLISH V9NX3C@@pretalx.com -V9NX3C Creating an XML parser from scratch en en 20200731T191000 20200731T192000 001000 Creating an XML parser from scratch Many Julia XML packages wrap complex C++ parsers. This create annoying dependencies and are hard to debug. However Julia is a very nice language to hand code lexers and parsers from scratch. Here we will show how surprisingly easy it is to create a parser for XML and Apple's PList format. We will utilize channels and coroutines to simplify our design. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/V9NX3C/ Purple Track Erik Engheim PUBLISH PTZDCJ@@pretalx.com -PTZDCJ How similar do two strings look? Visual distances in Julia en en 20200731T192000 20200731T193000 001000 How similar do two strings look? Visual distances in Julia The Julia package VisualStringDistances.jl provides several notions of distance between two strings based on how they are rendered by GNU Unifont; e.g., capital-eye (“I”) and lowercase-ell (“l”) are close together, while “a” and e.g. “X” are far apart, even though they are both one character apart. By comparing strings visually, this package provides a means for quantifying how easily two strings might be confused when read by a human. This measure of distance is calculated by the means of “unbalanced optimal transport” via the package UnbalancedOptimalTransport.jl which will also be discussed. Loosely speaking, this measures the cost of moving “mass” (i.e. black pixels in the printed representation of a string) from one place to another in order to transform the printed representation of one string into another, allowing the destruction or creation of mass (with some cost). This will be illustrated visually in the talk to provide an understanding of this interesting technique that has been applied to a variety of fields (image registration, economics, traffic flows, etc). The motivating application of VisualStringDistances.jl is for establishing automated checks for Julia’s General registry of packages in order to flag new packages for manual review. A malicious agent might try to register a package with a name that looks very similar to the name of some popular package, and then suggest users use it in online postings or tutorials. A user who copy-pastes the name or code that adds the package might not realize the name is different from that of the popular package. To aid in preventing this scenario, an automated check can be added to the General registry in order to prevent automated merging of new packages whose names look similar to those of existing packages. A related task is that of measuring “typo-similarity” to prevent automerging of packages who names are likely to be entered by mistake when typing the name of another package. This will be discussed as well, time permitting. PUBLIC CONFIRMED Lightning Talk https://pretalx.com/juliacon2020/talk/PTZDCJ/ Purple Track Eric P. Hanson PUBLISH CA3SET@@pretalx.com -CA3SET Julia & Data: An Evolving Ecosystem en en 20200731T161000 20200731T165500 004500 Julia & Data: An Evolving Ecosystem PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/CA3SET/ BoF Jacob Quinn PUBLISH YYKQCW@@pretalx.com -YYKQCW What's Next For Dynamical Modeling In Julia? en en 20200731T165500 20200731T174000 004500 What's Next For Dynamical Modeling In Julia? There are many directions that we can explore. What should we as a community be prioritizing? I think it would be good to hear from users what they think is "complete", and what gaps commonly show up. There's many topics this discussion can go towards: 1) Improved modeling tools and DSLs (ModelingToolkit) 2) Automated PDE solving 3) Targeting alternative hardware (exporting models for embedded systems) 4) New domains: integro-differential equations, fractional differential equations 5) Geometric methods and DAEs 6) Parallelism (MPI, GPUs, alternative acceleration hardware) 7) Connections: mixing ApproxFun.jl and FEM packages with DifferentialEquations.jl, etc. 8) Continuing to improve benchmarking 9) Accessibility, tutorials, blog posts, etc. 10) Whatever else comes to mind! PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/YYKQCW/ BoF Chris Rackauckas PUBLISH L9LV3N@@pretalx.com -L9LV3N Transitioning Code From Closed To Open en en 20200731T180000 20200731T184500 004500 Transitioning Code From Closed To Open Julia's package ecosystem makes it fairly easy for private organizations to redistribute code back to the Julia community, and we've found there are numerous benefits to routinely open-sourcing internally developed packages: - great for recruiting both community collaborators and future FTEs - encourages well-scoped, composable APIs and discourages overcoupling of orthogonal functionality - encourages structuring/maintaining the project in a manner that keeps the contribution/collaboration barrier low - positively contributes to the health/growth of the Julia ecosystem that we all rely on; a more robust/featureful ecosystem attracts more great community members and improves productivity for existing community members. However, it can be difficult to implement effective internal practices that enable internal code to smoothly transition into high quality, open-source contributions. In this BoF, we'll swap techniques for maximizing open-source impact in the Julia ecosystem while minimizing refactor time/effort and code churn. Discussion points include: - developing Julia packages with upfront "intent to open-source" - the benefits/challenges of piecemeal upstreaming to existing packages - identifying/mitigating common pain points w.r.t. internal code churn - managing internal dependency graphs when nodes are open-sourced - the interplay between private CI/CD and open CI/CD for Julia packages - git history/metadata preservation - the role of GitHub in the Julia community, and open-sourcing non-GitHub-hosted projects - software licensing PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/L9LV3N/ BoF Jarrett Revels PUBLISH 3AGJ3V@@pretalx.com -3AGJ3V Julia in Production en en 20200731T184500 20200731T193000 004500 Julia in Production Running Julia in production can take many different forms. Those who have already deployed Julia to production will share their experiences and discuss challenges they have had or still have. For those who have not yet run Julia in production this is a good opportunity to get feedback on deployment strategies. This birds-of-a-feather also provides us with the chance to discover common patterns with running Julia in production and hopefully will generate ideas for new tools that can we can all share. PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/3AGJ3V/ BoF Curtis Vogt PUBLISH 8WYB3B@@pretalx.com -8WYB3B Gather Town Social en en 20200731T193000 20200731T201500 004500 Gather Town Social PUBLIC CONFIRMED Birds of Feather https://pretalx.com/juliacon2020/talk/8WYB3B/ BoF