JuliaCon 2020 (times are in UTC)
From logistics to bioinformatics or web analytics, graphs are versatile abstractions for modelling problems and solving them with specialized efficient algorithms. But with different problems comes the need for different representations. This workshop aims at giving a hands-on tour to the JuliaGraphs libraries, letting the participants build, analyze and visualize graphs for different applications. Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/K3z0kUOBy2Y.
This is a tutorial workshop, aimed at people with some experience of using
basic Julia, e.g. by following one of the excellent tutorials available at
JuliaAcademy or on YouTube.
You should be familiar with using variables, functions and for loops, and basic plots using Plots.jl, in order to get the most out of the workshop.
Join this workshop by clicking on the Zoom link in the email from Eventbrite. Otherwise, watch the backup YouTube livestream: https://youtu.be/k0fr7XjH1_Y
This workshop will walk you through the wonders of BinaryBuilder.jl, the framework that allows you to compile binary libraries and programs for all supported Julia platforms.
Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/3IyXsBwqll8
While Julia started as a "fresh approach to technical computing", it has blossomed into a powerful general-purpose language fit for much more than "just" linear algebra and automatic differentiation. This workshop will walk-through an architecture of microservices in Julia, and a broad spectrum of high-quality packages to aid in the process.
Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/uLhXgt_gKJc.
Scientific machine learning combines differentiable programming, scientific simulation, and machine learning in order impose physical constraints on machine learning and automatically learn biological models. Given the composibility of Julia, it is positioned as the best language for this set of numerical techniques, but how to do actually "do" SciML? This workshop gets your hands dirty.
Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/QwVO0Xh2Hbg
This workshop will show how to use CxxWrap.jl to wrap a C++ library, based on tutorial material that can be followed along during the workshop. We will show everything you need to know about writing and compiling the required C++ wrapping code.
Setup beforehand is required, see https://github.com/barche/cxxwrap-juliacon2020#docker-dev-container
Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/VoXmXtqLhdo
During this workshop I will explain the design of indexing of the DataFrame type provided by the DataFrames.jl package. Next a detailed discussion of the implementation challenges we faced will be given.
Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/X7AJf0C4Czw
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.
Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/LAuRCy9jUU8
With JuliaCon being remote we've created a gather.town room that will be live throughout the event so that people can mingle and meet.
Any time people want to use it, just go to https://gather.town/rBrwIUqeDkb5JTxu/juliacon2020
And there's now a scheduled social gathering in there on Monday after the workshops (the event's been added to pretalx).
The team at gather.town are kindly supporting higher capacity for us, and asked that we give them feedback in
MLJ is a machine learning framework for Julia aiming to provide a convenient way to use and combine a multitude of tools and models available in the Julia ML/Stats ecosystem.
Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/qSWbCn170HU
Often, new comers to Julia face one of two issues: (1) write a quick Julia implementation that turns out slower than expected, and (2) find it hard to bridge existing codes in another programming language to Julia. In this workshop, I will show Julia tools and "aha-moments" that will allow your Julia code to be much faster, and walk through examples of wrapping Python, and C codes into Julia.
Join via Zoom: link in email from Eventbrite. Backup Youtube link: https://youtu.be/S5R8zXJOsUQ
After the success of the Monday session, a further scheduled social on Gather Town will happen again on Tuesday after the workshops, at 17:30 UTC.
Please join then (or indeed at any time) using https://gather.town/rBrwIUqeDkb5JTxu/juliacon2020
For today's event, there will be a dedicated space for MLJ, the Julia Machine Learning toolkit, where the the development team will be around to chat and answer questions.
Kernel functions are used in an incredible number of applications ranging from SVM to Gaussian processes as well as Stein variational methods.
With KernelFunctions.jl we propose a modular and easily customizable kernel framework. The emphasis made in this package is to work smoothly with automatic differentiation while being able to construct arbitrarily complex kernels both in terms of input transformation and kernel structure.
We will show how the different types of parallelization in Julia interact with random number generators and shared state. Using the parametric bootstrap in MixedModels, we will show to how use threads effectively with a shared random number generator to give the same result as the serial version.
This talk will show a Julia based solution that can automatically create a price function and map the risk factors of a given Financial Contract defined in a domain-specific language. This project applies compiler algorithms to take advantage of context in the pricing formulas so that it is possible to handle big portfolios with a wide variety of financial contracts.
Science is hard! Not only because scientific work requires utmost scrutiny and focus, but also because managing a scientific project is hard and messy. DrWatson is a scientific project assistant software made for Julia that makes scientific work less nightmarish.
TemporalGPs.jl provides a single-function API to make inference in Gaussian processes (GPs) from Stheno.jl dramatically more efficient in the time-series setting. It makes it feasible to perform (almost) exact inference with 10s of millions of data points quickly on a laptop, and plays nicely with StaticArrays.jl and Zygote.jl.
Gaussian Processes (GP) are an essential model of Bayesian non-parametrics. While multiple GP packages already exist in Julia such as Stheno.jl or GaussianProcesses.jl, AugmentedGaussianProcesses.jl has a larger scope of applications and is constantly updated with state-of-the-art methods. One of its specificity is to work with augmented variables to simplify inference. In this talk I will briefly explain this concept and show the potential of the package.
Today’s science requires ever-increasing amounts of computation, so ideally, we should be able to easily shift our simulations to any nonpersonal machine and guarantee that we can exactly reproduce the result later.
To do so, I would like to talk about a containerization software aimed at high performance computing called Singularity, the small package that I wrote for it, and the adventure of combining JIT with read-only containers.
The talk will introduce Jusdl.jl, which is a Julia based system description language and simulation tool that focuses on effective system simulations together with online and offline data analysis. Jusdl provides users with the ability to simulate systems consisting of components represented by different types of equations and the flexibility of enriching analysis capabilities with user-defined plugins.
Time series models with time-varying parameters have become increasingly popular over the years due to their advantages in capturing the dynamics of series of interest. In this context, score-driven models represent a recently developed and powerful framework for modeling time series considering non-Gaussian predictive distributions. In this talk, we present ScoreDrivenModels.jl, a Julia package for modeling, forecasting, and simulating data using score-driven models.
This talk presents the new 1.0 release of the Julia package PackageCompiler.jl which allows one to, in addition to create sysimages, also create “apps” or executables which can be run on machines that do not have Julia installed. In addition, it gives a background to the Julia compilation model and how and why one would want to create custom sysimages.
AutoMLPipeline (AMLP) is a package that makes it trivial to create
complex ML pipeline structures using simple
expressions. AMLP leverages on the built-in
macro programming features of Julia
to symbolically process, manipulate
pipeline expressions, and
makes it easy to discover optimal structures
for machine learning prediction and classification.
Project Binder (https://mybinder.org, https://jupyter.org/binder) offers an easy place to share reproducible computing environments, including Julia. In this lightning talk, Sarah Gibson will present the results of the mybinder.org User Survey, in particular those of interest to or suggested by the Julia community. She will introduce herself as a point of contact for further discussion on how the Julia and Binder communities can work more closely, and how you can become involved in Project Binde
Salsa.jl is a framework for on-demand, incremental computation. This type of incremental computing is seen in modern compilers (for IDEs), database systems (to maintain queries), spreadsheets (to recompute values on edits) and web applications (for UIs). Salsa guides and simplifies writing such applications and ensures correctness by construction. We use Salsa at RelationalAI as the core of our highly responsive compiler and database product.
Jupyter notebooks are useful for sharing Julia code. But if collaborators have different package versions, bugs arise and reproducibility is lost.
We present two tools that solve this problem, and describe their use in QuantEcon's Julia course. One (InstantiateFromURL.jl) allows binds notebooks to GitHub repositories for TOML, and supports version-controlling notebooks and manifests. The other (PkgUtils.jl) allows for direct pasting of Manifest and Project information into the notebook file.
Introduction to Evotrees.jl, a package developed to provide a pure Julia implementation of Gradient Boosted Trees with performance competitive with reference C++ implementations.
Main design choices and challenges encountered to achieve a performant solution will be covered. Discussion of the benefits stemming from developing in Julia, notably the ease to extend supported models such as quantile and Gaussian regression, as well as its MLJ ecosystem integration.
Machine learning research relies heavily on curated data sets for experimentation, measuring performance, and communicating results. Labeling data is a labor most researchers would rather avoid, so the same standard data sets are constantly reused. Lattice.jl is our attempt to provide a much wider variety of machine learning datasets with little or no human effort.
Julia is often not recommended for a "scripting workflow", i.e. starting Julia, execute a code snippet, and exit. This especially applies to short tasks where most of the time will be spent on compiling the code instead of running it. The recommended workflow is instead to keep the Julia session alive for as long as possible in order to benefit from already compiled methods. This talk will discuss how Julia can be used for scripting and present some tips on how to reduce compilation time.
Scientific Machine Learning: Where Physics-based Modeling Meets Data-driven Learning
It takes the entire community to promote diversity and inclusion. This talk will focus on the current plans underway to promote diversity and inclusion in the Julia Community as well as give an updated look at the state of diversity and inclusion in our community.
In this talk we will introduce Juno 1.0 and give an overview of new features and workflows as well as key development choices we made during the last months. This new version of Juno is more robust and easy to install than ever before and combines powerful static analysis features with the dynamic approach that's been at Juno's core for so long.
Some words from our sponsors
Macroeconomic models require efficient estimation methods when used in policy analysis. Recent additions to DSGE.jl expand its toolkit with state-of-the-art routines for constructing and analyzing Dynamic Stochastic General Equilibrium (DSGE) models. Additions include DSGE-Vector Autoregressions (DSGEVAR), Hamiltonian Monte Carlo (HMC), and potentially a “double-parallel” Bayesian algorithm.
This is a BoF to talk about cool array types, such as:
- AxisArrays
- AxisRanges
- IndexedDims
- NamedDims
- DimensionalData
- JuMP's DenseAxisArray and SparseAxisArray
- etc
Do you have or love an array package with fancy indexing? Come chat about it.
Maybe we will even be in a position to kill off some of them, and decide on a rightful successor to AxisArrays;
or at least make a plan for what to decide in the next 12 months.
This is the first poster session.
Julia is used along applied group theory to solve the problem of describing and classifying molecular vibrations, a highly demanding computational problem. The solution of this problem using applied group theory requires, high numerical capabilities, a fast and an extensive use of matrix operations and the possibility to efficiently handle different kinds of data structures. It is shown that Julia is one of the best options for implementing fast, reliable and accurate solutions.
Applied Category Theory is a new paradigm of applied mathematics that incorporates the advances in type theory to analyze scientific and engineering systems. Our talk will describe the AlgebraicJulia software ecosystem for representing and executing category theoretic computations with applications to numerical linear algebra, scientific modeling, and data science.
We will show off some new features in Convex.jl, solve a few example problems, and discuss development plans for the future.
There have been some major developments in Julia package manager in the past year. A system has been added in 1.3 for content-addressed binary artifacts, including data and platform-dependent binaries. In conjunction, the BinaryBuilder system has been updated to produce these artifacts, allowing package to depend on non-Julia libraries without any client-side build step. Pkg 1.4 introduced a new protocol for clients to get packages and artifacts from "Pkg servers" without needing git or GitHub.
The field of neuroinformatics requires collaboration from highly skilled experts from many diverse fields.
We will briefly introduce the problem space and show how JuliaNeuroscience addresses this.
For the past few years JuliaCon has hosted yearly discussions on how to improve diversity and inclusion in the Julia community as well as conducted a survey on how users and developers in the community identify. Many excellent ideas emerged from these sessions, including creating accessible material and targeted outreach and recruitment. In this session we will review our diversity goals, then form affinity groups to accomplish those goals using inspiration from previous brainstorming sessions.
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. In this work the Koopman Operator and its computational advantages are presented using the AD-compatible DiffEqUncertainty.jl.
We present an iterative and massively scalable 3-D multi-GPU inversion workflow using Julia for coupled multi-physics processes in Earth Sciences. We introduce an adjoint framework for the two-phase flow equations, assess the unknown porosity field reconstruction in 3-D and discuss the performance evaluation.
We study the larval zebrafish, a vertebrate whose whole brain can be imaged during behavior. In this system, we can observe neural activity underlying computations in visual processing, decision making and adaptive motor control. To analyze terabyte-size imaging data and test a variety of hypotheses about the neural processes, we are using a Julia-based pipeline that takes full advantage of the parallelism, multiple dispatch and flexible package ecosystem of the language.
Living systems, from molecules to ecosystems, are modular, allowing us to engineer them. I develop computational tools to aid bioscience engineering with applications in health, ecology and engineering. The whole chain of modeling, knowledge and decision relies on methods from machine learning, bioinformatics and optimization. Julia has proven to be a useful language for these tasks. In this talk, I will outline how I use Julia for my research through a series of case studies.
Have you ever wondered how htop, vim or other terminal applications work? Do you want to add color, or formatting to the terminal output from your Julia application? Are you interested in building interactive terminal user interfaces for your users? Well, this is the talk for you!
We will discuss how terminal emulators work, features they make available and how you can leverage these features to create the best experience for you and your users in the terminal for a Julia application.
We present our use of Julia to build a new kind of cloud-native relational database management system for knowledge graphs. We motivate the need for a database that excels in supporting workloads that mix data management, machine learning, and graph analytics. We explain how Julia's unique features enabled us to build a high-performance database with less time and effort. We also discuss how we contribute to and leverage the Julia ecosystem.
This talk will focus on the library LoopVectorization, providing an overview of how the library represents loops, and how this representation is used alongside cost modeling to pick an efficient vectorization strategy, and how it can be used for defining loops for an autodiff reverse pass.
Neural Processes (NPs) are a rich class of models for meta-learning that have enjoyed a flurry of interest recently. We present NeuralProcesses.jl, a compositional framework for constructing and training NPs built on top of Flux.jl. We demonstrate how the Convolutional Conditional Neural Process (ConvCNP), a new member of the NP family, can be implemented with the framework. The ConvCNP models translation equivariance, which is an important inductive bias for many learning problems.
This Birds of Feather session aims to facilitate structured discussion around some of the themes that arose from the mybinder.org user survey (https://mybinder.org). Specifically, which features or improvements would the Julia community like the Project Binder team (https://jupyter.org/binder) to pursue, what roadblocks do they foresee, and what "on ramps" are available for community members to become involved in the development and implementation processes.
The Dark Channel Prior was introduced by He, et al. as a method to dehaze a single image. Since its publication in 2010, other authors have sought to improve this dehazing method. Using the parameters that other authors have tuned as a guide, we parameterize the Dark Channel Prior dehazing method and utilize Zygote to apply gradient based optimization.
As climate change alters the distribution of disease vectors, the prevention of mosquito-borne illnesses like dengue and malaria stand to be complicated by shifting ecological realities. I use DifferentialEquations.jl to gain insights about the population dynamics of disease vectors that are subjected to environmental variation.
We consider a classical droplet fragmentation problem in fluid mechanics, and augment the system modeling with neural architectures using DiffEqFlux.jl. This augmentation speeds up experimental inquiries by training physically-interpretable neural architectures to recover the physical equations for the spatial and temporal variation of dynamic quantities. Together we showcase how Julia's unique differentiable programming ecosystem can be the basis for next-generation physical science.
Learn how to speed up your tensor calculations with SymbolicTensors.jl, a package designed to manipulate and simplify your tensor expressions before rewriting them in performant pure Julia.
In this talk, I present LinearMaps.jl, a well-established Julia package for handling linear maps whose action on vectors is given by the classic matrix-vector product or by the application of a function to a vector. I will focus on two recently added features, namely (diagonal) block concatenation and (higher-order) Kronecker products and sums of such abstract linear maps.
The MPI.jl package provides a standard Julia interface for working with the Message Passing Interface (MPI). In this talk I will introduce the package and illustrate its use with some examples, describe some of the unique challenges it faces, and detail plans for the future to make it easier to use.
Julia's PPL community is strong and growing. The various groups already have a strong professional relationship, but a BoF would help to formalize this somewhat, as well as being a good introduction for newcomers to the community. Join the BoF channel on Discord.
GR is a plotting package for creating two- and three-dimensional graphics in Julia that provides basic MATLAB-like plotting functions for visualizing static or dynamic data. In this talk, the most important new features are presented, such as a new meta layer that allows the integration of GR in browser environments and GUI toolkits, or improved output functions for drawing paths and texts to make publication-quality plots.
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. This can give significant speedups. Julia has many ways to take advantage of SIMD, sometimes it happens automatically, as an optimization, but it is also possible to manually write SIMD code.
This talk will give an overview of the different ways you can use SIMD in Julia.
This talk will present how basic operations on vectors, like summation and dot products, can be made more accurate with respect to Floating-Point arithmetic by using compensated algorithms. The proposed implementation is available in the AccurateArithmetic.jl package, and leverages SIMD instructions in order to achieve high performance on modern hardware architectures.
Density-functional theory (DFT) is a widespread method for simulating the quantum-chemical behaviour of electrons in matter. This talk presents our package DFTK, which aims to provide a joint platform accessible to different scientific communities.
Machine Learning is more than large complex models, it is moving towards integrating existing domain knowledge to better inform learning processes. See how Flux expresses that problem in the modern machine learning paradigm.
A scheduled social on Gather Town will happen after the last talk finishes
Please join then (or indeed at any time) using https://gather.town/rBrwIUqeDkb5JTxu/juliacon2020
We will show how to perform modeling and large scale simulation of complex graphs using the OpenStreetMapX.jl package.
Any transportation network can be represented as a complex directed graph where vertices are spread an Euclidean space. The library provides a bridging functionality between real world spatial data available in the OpenStreetMap project and LightGraphs.jl and makes it possible to run real-life-sized experiment on transportation networks along with various visualizations.
The Julia package ecosystem provides a rich trove of useful functionality across a wide range of platforms. By standing on the shoulders of giants and combining packages such as ZMQ.jl, Opus.jl, PortAudio.jl, DSP.jl and more, we are able to build a multichannel, low-latency, intelligent wireless speaker system that runs on cheap single-board linux computers.
We will show how StateSpaceEcon can be used for state space modeling in macroeconomics in Julia. This package can solve discrete-time systems of linear and non-linear equations that contain expectations of future values of the variables. The shocks to the system can be anticipated or unanticipated. This package can also find the steady state of the system and diagnose which variables are left undetermined. In addition, we will cover the Julia package TSeries to work with discrete time series.
Boid ("bird" pronounced in New York dialect) is an artificial life program
simulating flocking behaviour. In this fun, short talk I will describe one
boids simulation, a Dance with Friends and Enemies, and demonstrate a Makie
visualization that allows manipulating the swarm behaviour in realtime.
The GeoInterface, a package for interoperability of geospatial geometries, has been completely redesigned. Formerly it forced geometries to subtype abstract interface types. Now it is much more flexible, allowing packages to hook in using traits, and support methods based on the Simple Features standard. This talk will show why this is important for the JuliaGeo ecosystem, and what it enables you to do.
This work presents a parallel implementation of Monte Carlo-Markov Chain method for solving systems of linear algebraic equations using Julia and GPU accelerator. Julia 1.1.0 + CUDAnative.jl provide several advantages regarding development and performance which help to delve into convergence and precision analysis. This work is supported by PAPIIT-IA104720.
I will describe the current state of Julia's AMDGPU stack and how it compares
to Julia's CUDA stack, interesting advantages of AMD's ROCm platform that
we can leverage from Julia, as well as my own perspective on the future of
Julia's GPGPU ecosystem.
Currently, satellites generate data of the Earth in an unprecedented
amount.
These datasets need to be processed in a fast and user friendly way to
derive comprehensive information. This talk shows how we use the
Earth System Data
Lab to handle Sentinel-1 time
series for the detection of deforestation.
JuliaMusic is a collection of packages for analyzing music data. As the lead-dev I use these packages in my day-to-day scientific work about the properties of music. However I also use them to create exercises that help me become a better drummer.
NetworkDynamics.jl is a tool for dynamical modeling and analysis of large, inhomogeneous, networked systems. It provides a convenient interface between LightGraphs.jl and DifferentialEquations.jl.
We introduce the basic syntax of our package and showcase applications ranging from neurodynamics to power systems. We conclude with a brief overview of advanced features such as multi-threading, support for SDEs and integration with the machine learning environment DiffEqFlux.jl.
The ExaSGD (Optimizing Stochastic Grid Dynamics at Exascale) application is part of the Department of Energy's Exascale project (ECP). We show our challenges of finding optimization algorithms for GPUs and present our prototyping framework that written end-to-end in Julia.
GeometricFlux, a Julia package for geometric deep learning on graph. GeometricFlux relies on Flux/Zygote framework, integrates with JuliaGraph ecosystem and supports CUDA.
KernelAbstractions.jl is a library to write portable kernels for CPU and GPU computing.
It presents a unified programming model ala OpenCL in Julia so that users can write a
single kernel that targets multiple accelerators an multi-threaded CPUs.
In robotics, the two language problem is potentially even more pronounced than in other fields of scientific computing. KEF Robotics is using Julia to tackle this challenge and rapidly develop, field test, and commercialize autonomy software for small multirotor drones.
We take stock of the Julia and its ecosystem. The releases since 1.0 have been less major and non-breaking—which has been a relief—but nevertheless, a significant number of major new functionality has been added. We'll highlight some of the biggest developments in the language (can anyone say "multithreading"?), infrastructure (BB, Pkg3, Artifacts), and ecosystem (the Dataverse, DiffEqs, differentiable programming) and beyond. And finally, we look ahead to Julia 2.0.
TBA
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 is particularly efficient from a performance point of view, and makes it easy to integrate Julia in existing Javascript environments.
In Julia 1.5, a new interface for calling dynamic libraries will be introduced: the @ccall macro. The talk goes over the new syntax, API and development process.
CxxWrap.jl simplifies the creation of Julia packages that rely on C++ libraries for part of their functionality. Unlike Cxx.jl, the focus is on writing the wrapper code in C++, compiling it into a small shared library, inspired by the approach of Boost.Python for Python.
We will review existing computer algebra packages, discuss what new packages could be written, and look at existing C/C++ libraries like NTL that we might provide Julia wrappers for. Join the BoF channel on Discord.
Whether you have an existing package, are planning a re-write or creating a new package, design documents can help explain the problem you are trying to solve. In this talk, we will walk through AWSCore as a use-case, discuss what design documents are, their benefits, and showcase how they help users understand packages they haven't seen before.
A quick tour de force of Genie's most important features, now packed into the stable, mature, performant, and resilient v1 API. The attendees will discover how Genie can help them to productively build and deploy powerful web applications with Julia.
Lessons learned while achieving a 100x speedup of TrajectoryOptimization.jl by eliminating allocations.
This talk presents JSServe.jl, a high performance framework to easily combines interactive plots, markdown, widgets and plain HTML/Javascript in Jupyter / Atom / Nextjournal and on websites.
Julia provides an intimidating array of ways to write programs that write programs. There are macros, generated functions, custom compiler passes, ASTs, IRs, DSLs and backends galore. This talk is a deep-dive into all of these tools that will hopefully clarify how and when you'd want to use them, with examples from advanced projects across the Julia ecosystem.
This talk covers common patterns that have emerged in Julia using multiple dispatch and generic types to create code that is flexible, robust and performs well.
For many scientific workflows, an easy way to publish results interactively to the browser is very useful. However, most web frameworks have a steep learning curve, and involve knowledge of multiple languages and technologies. In this talk, we will show you how to create web applications in pure Julia, without any javascript or html using Dash.jl.
Chat about Yao, ITensor, TensorOperations, OMEinsum and development on common infrastructure such as lattices, sparse tensor, domain specific automatic differentiation etc. in Quantum Physics. Join the BoF channel on Discord.
Rocket.jl is a native Julia implementation of reactive programming concepts.
The package uses the observable sequence and actor model to make it easier to work with asynchronous data streams and message-driven program architectures.
A case of IR-based metaprogramming, going beyond just nonstandard function execution.
When coming from Python (or C#) you may be like me and love using generators yield a lot. Of course I wanted to have this in Julia, too, and wanted it to be blazingly fast. Unfortunately, the recommended approach using Julia Channels is everything else but super fast. That motivated me to build a solution which in many cases can compile down to perfect machine code: Continuables.jl.
Introducing a fresh, new notebook system for rapid prototyping! Pluto understands global references between cells, and reactively re-evaluates cells affected by a code change. At JuliaCon, we will show how Pluto can liven up your workflow.
The session begins with a discussion on homomorphic properties of cryptographic algorithms with the demonstration and techniques to reduce computational complexity. The session discusses the concept of recryption for secure computation. This session also discusses a case study on how machine learning techniques can be applied to encrypted data for secure computation and protecting the machine learning model. Finally, the utility of homomorphic encryption for blockchain will be discussed.
Despite the advantages of Julia, there are some hurdles that prevent R users from making the leap and switch to Julia. To bring Julia closer to R, we developed the new "JuliaConnectoR" R package that conveniently integrates Julia in R, allowing R users to harness the power of Julia, and making it easier for Julia developers to share features of their Julia code with R users.
The results of the 2020 JuliaLang Survey
Some words from our sponsor
How can enterprises create a catalogue of what data they have, given only a few labels and access to physical data layouts and other metadata? I show how to extend GeneralizedLowRankModels.jl to generate topic models that can be used for semisupervised learning tasks like extrapolating from known labels, evaluating possible errors in existing labels, and predicting missing metadata.
Bird of a feather for the JuliaGPU ecosystem. Join the BoF channel on Discord.
We present a self-contained approach for the development of massively scalable multi-GPU solvers for coupled nonlinear systems of partial differential equations (PDEs) in Julia. The approach encompasses numerics, implementation and performance evaluation. We showcase several 2-D and 3-D Multi-GPU PDE solvers as, e.g., a solver for spontaneous nonlinear porous flow localization in 3-D which scales nearly ideally on thousands of GPUs.
What happens when you re-implement a critical piece of the data science
ecosystem from what was essentially an R clone to take full advantage of the
Julia language? You learn a lot about flexibility, composability, and
performance.
We present DynamicPPL.jl, a modular library providing a lightning-fast infrastructure for probabilistic programming and Bayesian inference, used in Turing.jl. DynamicPPL enables Turing to have C/Stan-like speeds for Bayesian inference involving static and dynamic models alike. Beside run-time speed, DynamicPPL provides a user-friendly domain-specific language for defining and then querying probabilistic models.
We present Gridap, a novel finite element framework written in Julia. In the talk, we will show the software design behind the library and its application to solve a collection of well-known partial differential equations including linear, non-linear, single-field and multi-physics problems. To this end, we will consider different discretization techniques provided by the package such as continuous and discontinuous Galerkin methods with Lagrangian and Raviart-Thomas elements.
This talk will give a quick introduction to the Queryverse. I will also give an update on new features since the last Juliacon.
Industry 4.0, simply I4.0 or I4, refers to the “Fourth Industrial Revolution” that's the new digital industrial technology for transforming industries into smart/intelligent industries (iIndustry) by connecting machines with intelligent robots and Industrial Internet of Things (IIoT) devices. In this talk, we have addressed and proposed several issues for knowledge mining from Industrial Big Data (iBigData) in Industry 4.0 using Julia programming language.
The Julia project is fiscally sponsored at NumFOCUS. In this session, we will discuss the projects income and expenditures, including the finances for JuliaCon.
RANSAC.jl offers the Efficient RANSAC algorithm, a widely spread method to recognize simple primitives in point clouds of scanned objects. This talk will show that the package can not only be a basis for existing reconstruction processes, but a tool for further research as well.
In this talk I will demonstrate a gradient-based semi-supervised approach for matching target codimension one bifurcations with parameterised differential equation models. This work has been applied in synthetic biology settings, where experiments generate qualitative observations: locations of fixed points, limit cycles and bistability. Future outlooks include a view towards designing patterns and limit cycles in partial differential equations.
Learn how to build interactive, web based data dashboards in pure Julia with the Stipple Reactive UI library. The participants will learn the fundamentals of developing Stipple apps, allowing them to apply the skills to easily and efficiently create their own interactive data dashboards with pure Julia.
In this talk, attendees will learn about natural language processing techniques (TextAnalysis.jl) using Julia and how it can be combined with machine learning(MLJ.jl) to generate new knowledge from the existing knowledge. We will talk about how we designed curriculum using natural language processing, unsupervised machine learning and pointer-generator network.
Transforming one probability distribution to another is a powerful tool in Bayesian inference and machine learning, e.g. constrained-to-unconstrained transformations of distributions for use in Hamiltonian Monte Carlo or constructing flexible and learnable densities such as normalizing flows.
In this talk we'll have a look at how we can use Bijectors.jl to do all of the above and more!
The slides can be bound at https://torfjelde.github.io/presentations/juliacon-2020-bijectors/.
Qt QML is a declarative, javascript-based language to describe graphical user interfaces (GUIs) for desktop and mobile platforms. With the QML.jl package it is possible to also use this to create user interfaces for Julia programs, on Linux, Mac and Windows.
A scheduled social on Gather Town will happen after the last talk finishes
Please join then (or indeed at any time) using https://gather.town/rBrwIUqeDkb5JTxu/juliacon2020
Data science and machine learning courses are in high demand with growing enrollments. We discuss our experience teaching a computational DS&ML course with 250+ students that is designed to scale. We highlight the use of experiential learning, just-in-time presentation of key concepts, and real-time feedback on students’ understanding. We demo a computational textbook to make teaching a scalable DS&ML course easy.
DEMO: https://mynerva.io/courses/register, code juliacon2020
This talk introduces JuliaChem.jl, a package designed for performing quantum chemistry calculations via electronic structure theory methods. JuliaChem.jl uses Julia’s features to achieve performance similar to established quantum chemistry codes.
Proper HR management within an organisation is vital in the current day and age. Because of this task’s complexity, managers should be able to rely on good tools or models to support them, so they can gauge the short and long term impact of their decisions before making them. To this end, we developed a generalised manpower simulation engine in Julia, using SimJulia. We present this tool’s main features, highlight some of the encountered difficulties, and illustrate how it can be employed.
Julia is a great scientific computing language for interrogating ecological and evolutionary dynamics of intratumor heterogeneity and how it changes over time. This talk will appeal to people interested in studying Mathematical Biology and Ecology applications with Julia.
In this talk, we will present three novel and complementary Julia packages that can handle data on species interactions. These packages can be used to import, simulate, analyze, and visualize all sorts of ecological networks, greatly simplifying the study of this emerging subfield of biology.
Global circulation models, for numerical weather and climate prediction, spend about 30% of their time in radiation computations. Hence, the performance of atmospheric radiative transfer models (RTMs) is critically important.
We present RRTMGP.jl, a commonly used atmospheric RTM for global circulation models. Translated from Fortran, RRTMGP.jl has new abstractions, CI tests, and will run on GPUs. We will give a quick overview of the problem/equations that are solved and improvements.
This talk gives the origin and development of the Spanish translation of the open-source book “Think Julia”, titled “Introducción a la Programación en Julia”. This book focuses on teaching to program with Julia as the first programming language and is one of the first books in Spanish about Julia. The goal of this translation is to facilitate the use of Julia in the Hispanic community; the English level of most Latin American countries is medium or low according to the English Proficiency Index.
To increase transparency and partnership opportunities, the Department of Energy funded an open source release of NREL developed REopt. The optimization model that powers REopt was originally written in a domain specific, proprietary modeling language called Mosel. This transition required some python-familiar engineers to learn Julia and the JuMP package. This talk will detail our experience and what we learned along the way.
BITE is a new glacier thickness estimation model based on a mass-conserving forward model and a Bayesian inversion scheme. The model is fitted to available data using a Markov chain Monte Carlo (MCMC) method. The model is applied to more than 30,000 glaciers representing about 1/6 of the total. Thanks to Julia's speed it was possible to calculate the 1e8 glacier thickness maps necessary for the MCMC procedure.
Do you want to customize an energy systems market model? Do you have trouble parsing data from various tools? Do you want to interactively explore your model results? This 0-60 crash course will get you up and going on energy systems modeling and analysis with Julia using PowerSystems.jl, PowerSimulations.jl, PowerModels.jl, and PowerGraphics.jl.
Game development is a great way to attract beginner programmers. However, they are often dissuaded by the accidental complexity. In this talk, I will show how to easily create a simple game without any framework overheads.
Powered by Julia’s type-flexibility, various posit and float arithmetics are tested in ShallowWaters.jl for perspectives to accelerate climate models on modern computing architecture in 16 bit, using either deterministic or StochasticRounding.jl. Algorithmic bottlenecks with low precision are identified and information theory is used to find the best number format for a given algorithm, which led to the development of Sonums.jl – a number format that learns from data.
Planning the operation of Power Systems is an important task to guarantee low operational costs and reliability. In practice, model simplifications are used given problem complexity. The objective of this work is to propose a framework, comprised of a methodology and the HydroPowerModels.jl Julia package for testing the operative and economic impact of modeling simplifications over the network power-flow in hydrothermal power systems.
This talk will describe work done using the NeuralNetDiffEq & Flux packages, as part of the Google Code In 2019 program, including writing a second order ODE solver. I will also talk about pursuing Julia beyond GCI, including how I used Julia to create Corona-Net, a binary and multi-class symptoms localisation system for COVID-19. Through this talk, I hope share on how GCI with Julia has accelerated my progress in ML, and how Julia can be used to help contribute to the fight against COVID-19.
Energy and the economy are deeply intertwined yet the models typically employed for energy analysis treat the energy sector in isolation while lacking the capability to robustly represent the U.S. economy. This talk introduces the SLiDE.jl package, which leverages U.S. economic data to assess economic implications of energy infrastructure planning to answer these and other questions.
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. In this BOF, I will demonstrate how we can use smartphone and visual programming tools to engage Generation Z students in the classroom.
Allotting the best possible choice to each individual as per their preferences while adhering to total available positions and satisfying quality constraints is a common practical problem. Using Julia helped us get a tenfold speedup over our previous Python implementation.
This talk introduces a new flexible and extendable parallel time-domain simulation toolbox developed in Julia for the analysis of power system dynamics in large networks. The simulation algorithm adapts a parallel-in-space decomposition scheme to a sequential algorithm to create parallelizable tasks in the numerical solution of the power system analysis problem. Test simulations using a supercomputing cluster show a huge potential for computational speedup with increasing network complexity.
We will share our learnings from creating a Julia curriculum on Exercism that teaches Julia to users with previous programming experience based on practice exercises, automated as well as community-sourced and individual human mentoring. Further we will share how Julia users teaching workshops or classes can benefit from our project, and why we think that Exercism benefits the community as a whole.
The goal of this presentation will be to illustrate how the design
of equivalent electrical circuits for the analysis of electrochemical
(e.g. biological) systems can be optimized with an approach based
on evolutionary algorithms.
We will talk about the hurdles of trying to convince people at ASML to switch from a very entrenched MATLAB culture to Julia at times when people are just starting to switch to python.
TBA
Julia 1.0 was released two years ago and with that a brand new, rewritten from scratch, package manager called Pkg. This talk summarizes some of the improvements and features that have been added to Pkg since Julia 1.0 was released and also gives an overview of some of the plans for the future.
LightGraphs has been structured around a graph interface, which is used by algorithms without assuming anything on the underlying data structure. Few months ago, we realized it was implicitly assumed in some places that the graph vertices are contiguous integers starting from one. Making this assumption explicit for each graph type allows users to describe more properties of their types, and to indicate in the signature of algorithms whether this assumption is necessary.
You might not know all of the latest methods in differential equations, all of the best knobs to tweak,
how to properly handle sparsity, or how to parallelize your code. Or you might just write bad code. Don't you wish someone would just fix that for you automatically? It turns out that the latest feature of DifferentialEquations.jl, autooptimize, can do just that. This talk is both a demo of this cool new feature and a description of how it was created for other package authors to copy.
Come join authors and fellow users of many of Julia's most popular data-related packages to discuss what works, what doesn't, and how current roadmaps can reconcile the two. Join the BoF channel on Discord.
This is the second poster session
This talk will demonstrate how one can use the Julia extension for VS Code effectively. Special emphasis will be given to new features like the debugger, the workspace view, remote scenarios and support for Julia Notebooks (if finished by Juliacon).
The ChainRules project allows package authors to write rules for custom sensitivities (sometimes called custom adjoints) in a way that is not dependent on any particular autodiff (AD) package.
It allows authors of AD packages to access a wealth of prewritten custom sensitivities, saving them the effort of writing them all out themselves.
ChainRules is the successor to DiffRules.jl and is the native rule system currently used by ForwardDiff2, Zygote and soon ReverseDiff
After executing Julia code you are presented with the result. If you are working in the Julia REPL you are usually seeing just a basic text representation. However, in other environments, such as in a Jupyter notebook, you sometimes see a more rich representation of the output. This talk will present how Julia's display system works when presenting output to the user, which methods are called when, and how to implement "pretty printing" for custom types.
Dynamical modeling is arguably one of the biggest strengths of the Julia programming language. With DifferentialEquations.jl, DynamicalSystems.jl, RigidBodyDynamics.jl, ModelingToolkit.jl, DiffEqBiological.jl, Pumas.jl, etc. (the list keeps going), there are many state-of-the-art award winning projects. However, ,what's missing? What's next? Let's discuss and figure out some next steps. Join the BoF channel on Discord.
A message from our sponsor: https://www.invenia.ca/
From optimization to statistical modeling, many problems involve working with manifolds, smooth sets of points with nonlinear constraints.
Manifolds.jl provides various tools to work on these problems along with a library of manifolds.
ManifoldsBase.jl gives it a light-weight, extensible interface.
We will show how to use these tools to construct new manifolds and implement algorithms on these manifolds.
A message from our sponsor. https://pumas.ai/
We discuss the problem of updating immutable objects. The solutions presented are implemented in the Setfield.jl package.
After fighting with a Python smarthome implementation, I re-implemented it in Julia. I'll show how I set up Julia on a Raspberry Pi, control the sensors & devices with a mix of PyCall & Julia libraries, and how I unite it all under a UI written with JSServe.jl.
DynamicGrids.jl is a new framework for constructing, running and visualising gridded spatial simulations, in Julia, developed for organism dispersal modelling with Dispersal.jl, but but generalised to be applicable to a wide range of contexts.
Studies in immunology, developmental biology, and medicine use flow and mass cytometry to generate huge amounts of single-cell data. GigaSOM.jl is a high-performance, horizontally scalable implementation of the commonly used clustering and visualization algorithms used in cytometry, designed to handle dataset of sizes inaccessible to currently available tools. We show the structure and design of GigaSOM.jl, and demonstrate the results on recent datasets from a massive immunophenotyping effort.
Chairs:
Jürgen Fuhrmann (Weierstrass Institute Berlin),
Petr Krysl (UCSD)
The talks at the minisymposium present several packages devoted to the solution of partial differential equations based on various approaches to space discretization including finite element, finite volume, boundary element and neural networks.
During the conference chat, developments of the PDE simulation infrastructure shall be discussed.
Within private companies/institutions, 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. Join the BoF channel on Discord.
The JuliaText ecosystem provides various packages for working with human languages. In this talk, we show the usage of these JuliaText packages with Flux.jl for Natural Language Processing (NLP) with a focus on deep learning-based approaches.
I'll talk about my experience developing the Inflation.jl package in my research as a graduate student, and what I think Julia can do for computational and theoretical cosmology.
The talk should appeal to anyone interested in Julia's differential equations and parameter estimation suites, symbolic computation, package development, or the early universe.
An informal conversation about problems and solutions related to running Julia in a production environment. Join the BoF channel on Discord.
I will introduce the CombinedParsers package for writing complex recursive parsers efficiently in a composable functional style.
The package API will be demonstrated by example of an CombinedParser for regular expressions which generates compiled regular expression parsers in pure julia.
Far more expressive than regular expressions, parser combinators allow for arbitrary transformations and higher-order parsers depending on the parsing state (exemplified with a very short html parser).
All the news about Makie! WebGL, layouts, widgets, recipes and more!
By utilizing channels and coroutines in Julia we can create a simple lexer and parser quickly in Julia. In this example we will be building an XML parser from scratch. Focus is on simplicity rather than performance.
The Makie library supports interactive visualizations in 2D or 3D, both native and web-based. AlgebraOfGraphics.jl adds support for statistical visualizations in two ways. It implements visualizations for common analyses (frequency table, kernel density, linear and non-linear regressions...), and it offers a set of custom types that allow to express how the data should be grouped, styled, and analyzed. This unified syntax layer simplifies the creation of UIs for interactive data analysis.
We will describe a Julia package VisualStringDistances.jl which provides notions of distance between two strings based on how close they look when printed, and discuss a possible application of this: an automated check in the General Registry auto-merge process to help prevent malicious lookalike registrations.
The Queryverse has a powerful visualization story that is based on the Vega ecosystem. This talk will demonstrate how one can use the Vega family of packages to easily create simple and advanced visualizations with Julia and how the various packages are integrated with each other.
A scheduled social on Gather Town will happen after the last talk finishes
Please join then (or indeed at any time) using https://gather.town/rBrwIUqeDkb5JTxu/juliacon2020