2.0
-//Pentabarf//Schedule//EN
PUBLISH
LSNEWV@@pretalx.com
-LSNEWV
Learn Julia via epidemic modelling
en
en
20200724T140000
20200724T173000
3.03000
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
3.03000
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
Mathieu Besançon
James Fairbanks
Simon Schoelly
PUBLISH
Y3H7FG@@pretalx.com
-Y3H7FG
Building microservices and applications in Julia
en
en
20200725T140000
20200725T173000
3.03000
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
3.03000
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
Mosè Giordano
Elliot Saba
PUBLISH
C9FGPP@@pretalx.com
-C9FGPP
Doing Scientific Machine Learning (SciML) With Julia
en
en
20200726T140000
20200726T173000
3.03000
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
3.03000
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
3.03000
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
3.03000
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
0.04500
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
3.03000
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
Thibaut Lienart
Anthony Blaom
PUBLISH
7MALUA@@pretalx.com
-7MALUA
Make your Julia code faster and compatible with non-Julia code.
en
en
20200728T140000
20200728T173000
3.03000
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
0.04500
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.01000
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
0.01000
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
0.04500
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
0.01000
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
0.03000
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
Sebastian Pfitzner
Shuhei Kadowaki
PUBLISH
HZRHEL@@pretalx.com
-HZRHEL
Julia Computing
en
en
20200729T154500
20200729T155000
0.00500
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
0.01000
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
Roberto Bernal-Jaquez
León Alday
PUBLISH
GALAX8@@pretalx.com
-GALAX8
AlgebraicJulia: Applied Category Theory in Julia
en
en
20200729T162000
20200729T165000
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.03000
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
0.03000
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
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.03000
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
Stefan Karpinski
Elliot Saba
PUBLISH
KTDY7J@@pretalx.com
-KTDY7J
Probabilistic Optimization with the Koopman Operator
en
en
20200729T171000
20200729T172000
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
1.03000
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
0.03000
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
0.01000
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
0.01000
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
0.03000
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
0.04500
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
0.04500
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
August Guang
Huda Nassar
PUBLISH
QF8BC7@@pretalx.com
-QF8BC7
Project Binder and the Julia Community: Planning for the Future
en
en
20200729T180000
20200729T184500
0.04500
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
0.04500
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
0.04500
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
0.01000
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
Przemysław Szufel
Bogumił Kamiński
PUBLISH
GR9TZH@@pretalx.com
-GR9TZH
GeoInterface: bringing geospatial packages together
en
en
20200730T124000
20200730T125000
0.01000
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
0.01000
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
0.03000
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
0.03000
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
0.04500
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
0.04500
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
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.00500
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
0.03000
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
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.01000
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
0.01000
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
Dewan Md. Farid
Swakkhar Shatabda
Aicha Sekhari
Yacine Ouzrout
PUBLISH
XQ9YQK@@pretalx.com
-XQ9YQK
Efficient RANSAC in efficient Julia
en
en
20200730T185000
20200730T190000
0.01000
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
0.03000
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
0.01000
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
0.01000
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
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.04500
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
0.04500
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
0.04500
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
0.04500
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
0.04500
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.04500
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
0.01000
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
0.03000
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
0.03000
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
0.03000
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
0.00500
Invenia
PUBLIC
CONFIRMED
Sponsor Talk
https://pretalx.com/juliacon2020/talk/S9TDNB/
Red Track
PUBLISH
T7VKHM@@pretalx.com
-T7VKHM
Pumas
en
en
20200731T171500
20200731T172000
0.00500
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
0.01000
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
0.01000
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
1.03000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
0.03000
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
0.03000
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
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.01000
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
0.03000
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
1.03000
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
0.03000
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
0.03000
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
0.01000
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
0.01000
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
0.01000
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
0.04500
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
0.04500
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
0.04500
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
0.04500
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
0.04500
Gather Town Social
PUBLIC
CONFIRMED
Birds of Feather
https://pretalx.com/juliacon2020/talk/8WYB3B/
BoF