0.20 juliacon2019 2019-07-22 2019-07-26 5 00:05 https://pretalx.com https://pretalx.com/media/juliacon2019/img/53984646-04faa100-411a-11e9-8933-16064af80068.png US/Eastern PH 103N Workshop (half day) 2019-07-22T08:30:00-04:00 08:30 03:30 This workshop is for both experienced DifferentialEquations.jl users and newcomers. The first hour of the workshop will introduce the user to DifferentialEquations.jl, describing the basic workflow and the special features which are designed to make solving hard equations (automatic sparsity detection, Jacobian coloring, polyalgorithms, etc.) easy. After the introduction, the workshop will break out into groups to work on exercises, where the developers of the library's components will be available for any questions. Some of the exercises are designed for beginners to learn how to solve differential equations and fit models to data, while others are for experienced users to learn the newest performance-enhancement features and upgrade to GPU-accelerated workflows. juliacon2019-2559-solving-differential-equations-in-julia Chris Rackauckas en The exercises are described as follows: - Exercise 1 takes the user through defining the same biological system with stochasticity, utilizing EnsembleProblems to understand 95% bounds on the solution, and perform Bayesian parameter estimation. - Exercise 2 takes the user through defining hybrid differential equation, that is a differential equation with events, and using adjoints to to perform gradient-based parameter estimation. - Exercise 3 takes the user through differential-algebraic equation (DAE) modeling, the concept of index, and using both mass-matrix and implicit ODE representations. - Exercise 4 takes the user through optimizing a PDE solver, utilizing automatic sparsity pattern recognition, automatic conversion of numerical codes to symbolic codes for analytical construction of the Jacobian, preconditioned GMRES, and setting up a solver for IMEX and GPUs. - Exercise 5 focuses on a parameter sensitivity study, utilizing GPU-based ensemble solvers to quickly train a surrogate model to perform global parameter optimization. - Exercise 6 takes the user through training a neural stochastic differential equation, using GPU-acceleration and adjoints through Flux.jl's neural network framework to build efficient training codes. true https://pretalx.com/juliacon2019/talk/8SBXLD/ https://pretalx.com/juliacon2019/talk/8SBXLD/feedback/ PH 103N Workshop (half day) 2019-07-22T13:30:00-04:00 13:30 03:30 Pharmacometics is commonly used to optimize drug doses and pre-screen drugs before clinical trials. In this workshop, users familiar with Julia will learn about pharmacometrics and how to perform the model simulations, while pharmacometricians will learn how to use Julia to build the models they know from their field. The focus will be on simulating bioequivalance studies with Bioequivalence.jl, performing nonlinear mixed-effects modeling (NLME) simulation and estimation with Pumas.jl, and non-compartmental analysis (NCA) with the PumasNCA submodule. juliacon2019-1057-pharmaceutical-modeling-and-simulation-with-pumas Chris RackauckasVijay Ivaturi en Phamacometrics is the practice of using mathematical models to predict the effect of drugs on a patient’s internal biology. This field has become a standard part of pharmaceutical research, with major pharmaceutical companies routinely utilizing these methodologies to optimize dosing schedules and analyze clinical trial data for efficacy and toxicity before performing expensive clinical trials. These models are nonlinear mixed effects models where the nonlinearity is given by a system of differential equations. Because the process is limited by the speed and flexibility of the differential equation solvers, there has been increasing interest in using Julia for this practice. In this workshop we will walk both Julia users and pharmaceutical practitioners through the process of pharmacometric modeling in Julia. Pharmaceutical practitioners will be paired with Julia users to work on guided exercises to learn both the pharmacometric modeling workflows and their implementation in Julia. Workshop participants will learn to make use of Pumas.jl and Bioequivalence.jl to perform clinical trial simulations, and analyze the results using the Pumas Non-Compartmental Analysis (NCA) functionality. Users will learn how to implement Pk/Pd models with complex dosing schedules and incorporating population models and estimate population parameters from data. Advanced users can explore the function-based interface of Pumas.jl to define delay and stochastic differential equation models, and optimize the runtime of their simulations using the full functionality of DifferentialEquations.jl. The participants will leave with a clear understanding of how to use the Julia package ecosystem to efficiently handle these difficult pharmacometric models, and will have a new perspective for understanding the differential equation solver advances being discussed at JuliaCon. true https://pretalx.com/juliacon2019/talk/EHSJY3/ https://pretalx.com/juliacon2019/talk/EHSJY3/feedback/ PH 111N Workshop (half day) 2019-07-22T08:30:00-04:00 08:30 03:30 This tutorial targets both new and moderately experienced Julia users. After covering the basics and tools for data science, we will delve into topics such as memory management, type stability, and profiling. juliacon2019-992-excelling-at-julia-basics-and-beyond Jane HerrimanHuda Nassar en We will kick off this tutorial with an introduction to Julia, which should be accessible to anyone with technical computing needs and some exposure to another language. In the first part of the tutorial, we will cover Julia’s syntax, design paradigm, performance, basic plotting, and interfaces to other languages. We hope to show you why Julia is special, demonstrate how easy Julia is to learn, and get you writing your first Julia programs. In the second part of this tutorial, we will introduce you to data science tools for data management and machine learning algorithms and then delve into topics in performance optimization such as type stability and profiling. We will end this tutorial by going over the parallel computing infrastructure in Julia. true https://pretalx.com/juliacon2019/talk/QYQNMW/ https://pretalx.com/juliacon2019/talk/QYQNMW/feedback/ PH 111N Workshop (half day) 2019-07-22T13:30:00-04:00 13:30 03:30 In this workshop, we will go through all the necessary steps to create a Julia package. The goal of the workshop is that attendees should be well prepared for getting started with package writing in Julia. juliacon2019-1090-writing-a-package-a-thorough-guide Kristoffer CarlssonFredrik Ekre en In Julia a lot of important functionality is implemented in packages living outside the core language. There are many reasons for this, for example that user defined types and functions are first class citizens and treated the same way as built-in types and functions, and that Julia's multiple dispatch makes it possible to work together with, and extend, other packages and the core language. There are packages available in Julia for almost everything, for example differential equations, machine learning, data science, debugging and web applications. They are all very different, some are tens of thousands of source lines, while others are single line packages. Basically, the common denominator is that a package is a reusable piece of code wrapped in a specific structure, that solve a specific problem. For newcomers to Julia, or to programming in general, it might seem like a difficult task to author a Julia package. Therefore, in this workshop, we will go through all the necessary steps to create a Julia package. In particular we will learn how to: - set up the package structure; - add package dependencies; - write unit tests; - write documentation; - set up continuous integration (CI); - release a package. The goal of the workshop is that attendees should be well prepared for getting started with package writing in Julia. true https://pretalx.com/juliacon2019/talk/XKURRK/ https://pretalx.com/juliacon2019/talk/XKURRK/feedback/ PH 203N Workshop (half day) 2019-07-22T08:30:00-04:00 08:30 03:30 Demystify machine learning buzzwords by learning how to train and use your own neural network in this interactive workshop. We'll cover the foundational principles that underpin modern machine learning and demonstrate how Julia makes it easy and fast. juliacon2019-1111-machine-learning-workshop Matt Bauman en Interest and excitement in machine learning (ML) has skyrocketed in recent years due to its proven successes in many disparate domains. Julia is uniquely positioned as a strong language for ML due to its high performance, ease of use, and groundbreaking research in differentiable programming. In this interactive workshop you will learn the core concepts that drive and underpin modern machine learning techniques. The first half incrementally introduces key ML terminology and concepts as you build and train your first neural network with Flux. Covered along the way are data representations, models, gradient descent, training, and testing. Then take a step back and explore the wide array of applications of machine learning with a handful of demonstrations of different tasks and models. false https://pretalx.com/juliacon2019/talk/UEDNGH/ https://pretalx.com/juliacon2019/talk/UEDNGH/feedback/ PH 203N Workshop (half day) 2019-07-22T13:30:00-04:00 13:30 03:30 A case-study based tutorial on working with tabular data using the [DataFrames.jl](https://github.com/JuliaData/DataFrames.jl) package. juliacon2019-889-handling-data-with-dataframes-jl Bogumił Kamiński en The workshop provides an overview of all major functionality provided in the [DataFrames.jl](https://github.com/JuliaData/DataFrames.jl) package. It is organized around solving several practical case-studies of working with tabular data and covers in particular: * Reading/writing tabular data, getting summary information about data. * Handling missing values and categorical data. * Standard transformations of tabular data (sorting, filtering, mutating, joining, reshaping, grouped operations, tabulating etc.). * Plotting of tabular data. * Performance considerations of using the DataFrames.jl package. false https://pretalx.com/juliacon2019/talk/KD9RGB/ https://pretalx.com/juliacon2019/talk/KD9RGB/feedback/ PH 211N Workshop (half day) 2019-07-22T08:30:00-04:00 08:30 03:30 This is a workshop aimed at people who already know basic Julia usage and wish to explore some more advanced topics that make Julia special, namely defining and using types, and metaprogramming. juliacon2019-956-intermediate-julia-for-scientific-computing David P. Sanders en In this workshop, we will explore two of the more advanced topics that make Julia special: types and metaprogramming. We will start off by looking at different uses of *types* as a glue in a scientific programming application: implementing a new arithmetic (automatic differentiation) and dispatch-based design. In the second half, we will look at metaprogramming: how to get inside a Julia expression tree and apply that to write macros and "domain-specific languages". This workshop is suitable for people who are comfortable with basic usage of Julia and wish to explore the language in more depth. false https://pretalx.com/juliacon2019/talk/PSSWXL/ https://pretalx.com/juliacon2019/talk/PSSWXL/feedback/ PH 211N Workshop (half day) 2019-07-22T13:30:00-04:00 13:30 03:30 Parallel computing is hard. Julia can make it much easier. In this workshop, we discuss modern trends in high performance computing, how they’ve converged towards multiple types of parallelism, and how to most effectively use these different types in Julia. juliacon2019-1086-parallel-computing-workshop Matt BaumanAvik Sengupta en This interactive workshop demonstrates how to write parallel Julia code in a variety of ways, including shared memory computing with threads, multiple processes for distributed computing, and computing on the GPU. Julia makes all these modes of parallelism possible, and the Julia community is continuing to perform active research to make high performance parallel computing easier. Many national labs, major corporations, and universities are already using Julia with parallel computing. The workshop will help you: * identify the challenges in converting a program from serial to parallel * discover the many forms of parallelism Julia offers and learn when to use each * learn how to structure programs to take advantage of parallel computation * write programs that use an appropriate form of parallelism In this workshop, we will cover * A quick primer on serial performance * Multithreading * Designing parallel algorithms * Tasks (also known as co-routines or green threads) * Multi-process parallelism * A very quick introduction to GPU programming * Future developments Participants should have basic understanding of non-parallel programming techniques and of Julia itself. false https://pretalx.com/juliacon2019/talk/RLDSVL/ https://pretalx.com/juliacon2019/talk/RLDSVL/feedback/ Other Break 2019-07-22T07:30:00-04:00 07:30 01:00 Breakfast will be provided in the PH Galley juliacon2019-2585-breakfast-workshops en true https://pretalx.com/juliacon2019/talk/3RGNK9/ https://pretalx.com/juliacon2019/talk/3RGNK9/feedback/ Other Break 2019-07-22T12:00:00-04:00 12:00 01:15 Lunch will be held in the SMC 2nd Floor Lobby juliacon2019-2586-lunch en false https://pretalx.com/juliacon2019/talk/WVVALL/ https://pretalx.com/juliacon2019/talk/WVVALL/feedback/ Elm A Talk 2019-07-23T11:00:00-04:00 11:00 00:30 We present ITensors.jl, a ground-up rewrite of the C++ ITensor package for tensor network simulations in Julia. We will motivate the use of tensor networks in physics and give some examples for how ITensors.jl can help make the use and development of tensor network algorithms easier for researchers, users, and developers. juliacon2019-890-intelligent-tensors-in-julia Katharine Hyatt, Matthew Fishman en Tensor network methods are an extremely useful class of simulation algorithms in physics. They work by constructing a graph of tensors -- of which matrices and vectors are low-dimensional examples -- and making local optimizations to these tensors to capture the essential physics of a many-body system. ITensor (Intelligent Tensor) is a leading C++ package created to make tensor network methods accessible to a wider group of scientists and programmers. In this talk, we present ITensors.jl, a ground-up rewrite of ITensor in Julia, which uses the lessons from the C++ project to offer much of the same powerful functionality in a more concise and elegant format, substantially lowering the "barrier to entry" for using tensor network techniques. We will present some usage examples that are common in physics applications to exemplify the ITensors.jl user interface and design philosophy. Using Julia, we can create a tensor network package expressive enough to capture a variety of physics that's also accessible enough for more physicists and computer scientists to use. false https://pretalx.com/juliacon2019/talk/BNSCFK/ https://pretalx.com/juliacon2019/talk/BNSCFK/feedback/ Elm A Lightning Talk 2019-07-23T11:30:00-04:00 11:30 00:10 Pairwise learning is a machine learning paradigm where the goal is to predict properties of pairs of objects. Applications include recommender systems, such as used by Amazon, molecular network inference and ecological interaction prediction. Kronecker-based learning systems provide a simple, yet elegant method to learn from such pairs. Using tricks from linear algebra, these models can be trained, tuned and validated on large datasets. The Julia package Kronecker.jl aggregates these tricks, such that it is easy to build such learning systems. juliacon2019-905-a-general-purpose-toolbox-for-efficient-kronecker-based-learning Michiel Stock en I would like to introduce the Kronecker kernel-based framework I developed during my PhD and explain why I would switch from Python to Julia for this. false https://pretalx.com/juliacon2019/talk/QAAUCS/ https://pretalx.com/juliacon2019/talk/QAAUCS/feedback/ Elm A Lightning Talk 2019-07-23T11:40:00-04:00 11:40 00:10 Hear about what is new in julia 1.2 and 1.3 with thread-based parallelism. (note: due to a race condition, Thread Based Parallelism part 2 occurs before Thread Based Parallelism part 1) juliacon2019-2619-thread-based-parallelism-part-2 Jeff Bezanson en false https://pretalx.com/juliacon2019/talk/83YFMV/ https://pretalx.com/juliacon2019/talk/83YFMV/feedback/ Elm A Lightning Talk 2019-07-23T11:50:00-04:00 11:50 00:10 Hear about what is new in julia 1.2 and 1.3 with thread-based parallelism. (note: due to a race condition, Thread Based Parallelism part 1 occurs after Thread Based Parallelism part 2) juliacon2019-2620-thread-based-parallelism-part-1 Jameson Nash en false https://pretalx.com/juliacon2019/talk/3YQSSP/ https://pretalx.com/juliacon2019/talk/3YQSSP/feedback/ Elm A Talk 2019-07-23T14:30:00-04:00 14:30 00:30 Documenter compiles docstrings, code snippets, and Markdown pages into HTML or PDF documents and can automatically deploy them as websites, making it easy to create manuals for Julia packages that are immediately available to users. This talk explores what goes into making all of that happen. juliacon2019-1040-generating-documentation-under-the-hood-of-documenter-jl /media/juliacon2019/images/TTBU37/logo.png Morten Piibeleht en Documenter can take Markdown files and inline docstrings and combine them into a manual for your Julia package. In addition, it can also run code snippets, verify that the output from code examples is up to date (doctesting) and upload the manual automatically to GitHub from a Travis CI build to be published as a website. Documenter is used by many Julia packages, and for generating Julia's own manual. Behind the scenes, Documenter needs to (1) parse and represent Markdown documents, done via the Markdown standard library, (2) run code snippets embedded in the Markdown documents, (3) work with meta-information about functions and types, such as method signatures, and (4) fetch docstrings from your Julia code. Once all that is done, it compiles the result into the chosen output format -- a set of HTML pages or a PDF document. The talk explores how Documenter goes from a make.jl script to a completely rendered and deployed manual. It should give existing users a glance into how Documenter works, but also provide a thorough overview of what is possible with Documenter to prospective new users. false https://pretalx.com/juliacon2019/talk/TTBU37/ https://pretalx.com/juliacon2019/talk/TTBU37/feedback/ Elm A Lightning Talk 2019-07-23T15:00:00-04:00 15:00 00:10 Literate programming is described as an _explanation of the program logic in a natural language, interspersed with traditional source code_. This presentation will describe how the `Literate.jl` package can be used for literate programming, and show how to generate multiple outputs, such as jupyter notebooks, or markdown pages, based on the same source file. juliacon2019-1088-literate-programming-with-literate-jl Fredrik Ekre en Literate programming was introduced by Donald Knuth in 1984 and is described as an _explanation of the program logic in a natural language, interspersed with traditional source code_. `Literate.jl` is a simple Julia package that can be used for literate programming. The original purpose was to facilitate writing example programs for documenting Julia packages. Julia packages are often showcased and documented using "example notebooks". Notebooks are great for this purpose since they contain both input source code, descriptive markdown and rich output like plots and figures, and, from the description above, notebooks can be considered a form of literate programming. One downside with notebooks is that they are a pain to deal with in version control systems like git, since they contain lots of extra data. A small change to the notebook thus often results in a large and complicated diff, which makes it harder to review the actual changes. Another downside is that notebooks require external tools, like Jupyter and `IJulia.jl` to be used effectively. With `Literate.jl` is is possible to dynamically generate notebooks from a simple source file. The source file is a regular `.jl` file, where comments are used for describing the interspersed code snippets. This means that, for basic usage, there are no new syntax to learn in order to use `Literate.jl`, basically any valid Julia source file can be used as a source file. This solves the problem with notebooks described in the previous section, since the notebook itself does not need to be checked into version control -- it is just the source text file that is needed. `Literate.jl` can also, from the _same_ input source file, generate markdown files to be used with e.g. `Documenter.jl` to produce HTML pages in the package documentation. This makes it easy to maintain both a notebook and HTML version of examples, since they are based on the same source file. This presentation will briefly cover the `Literate.jl` syntax, and show examples of how `Literate.jl` can be used. false https://pretalx.com/juliacon2019/talk/DAKCYM/ https://pretalx.com/juliacon2019/talk/DAKCYM/feedback/ Elm A Lightning Talk 2019-07-23T15:10:00-04:00 15:10 00:10 Ever wish your code automatically beautiful? Tired of spacing out commas, wrangling parenthesis and indenting? Julia's formatter can do all this and more! Come find out how to use it your everyday workflow. juliacon2019-907-formatting-julia Dominique Luna en Formatting code has recently gained significant trackion amongst the programming community. The most notable formatters being [gofmt](https://golang.org/cmd/gofmt/) (Go), [remft](https://reasonml.github.io/) (Reason/Ocaml), and [prettier](https://prettier.io/) (JS/CSS/HTML,etc). In this talk I'll present Julia's own formatter, which formats Julia code into a canonical, width-aware output. I'll go over: * Why you should format your code. * How the Julia formatter works and how you can use it in your workflow. * Lots of demos showing beautifully formatted code! false https://pretalx.com/juliacon2019/talk/RUYDYR/ https://pretalx.com/juliacon2019/talk/RUYDYR/feedback/ Elm A Talk 2019-07-23T15:45:00-04:00 15:45 00:30 Julia is home to a growing ecosystem of probabilistic programming languages—but how can we put them to use for practical, everyday tasks? In this talk, we'll discuss our ongoing effort to automate common-sense data cleaning by building a declarative modeling language for messy datasets on top of [Gen](https://github.com/probcomp/Gen). juliacon2019-995-cleaning-messy-data-with-julia-and-gen Alex Lew en Julia is home to a growing ecosystem of probabilistic programming languages—but how can we put them to use for practical, everyday tasks? In this talk, we'll discuss our ongoing effort to automate common-sense data cleaning by building a declarative dataset description language on top of [Gen](https://github.com/probcomp/Gen). Users of the language can encode domain knowledge about their dataset and the ways in which it might be unclean in short, declarative probabilistic scripts, which are compiled to Gen programs that infer locations of probable errors, impute missing values, and propose likely corrections in tabular data. false https://pretalx.com/juliacon2019/talk/EHG87D/ https://pretalx.com/juliacon2019/talk/EHG87D/feedback/ Elm A Talk 2019-07-23T16:15:00-04:00 16:15 00:30 Introducting LightQuery.jl, a new querying package which combines performance with flexibility. juliacon2019-983-lightquery-jl Brandon Taylor en LightQuery.jl is a new package for querying tabular data. I'll discuss a number of things which make it special. 1) Careful use of constant propagation, so that named-tuple level operations are type stable when wrapped in a functions. 2) The ability to simultaneously collect into (and iteratively widen) several sinks at once. 3) Very few macros: only two, one for chaining and one for anonymizing. Compare the number of macros required for Query, DataFramesMeta, and JuliaDBMeta. 4) Careful tracking and propagation of line number information. 5) Huge speed-ups when sources are pre-sorted. 6) Flexibility. Row-wise operations work with arbitrary containers, provided they can be indexed out of order. Column-wise operations work for anything which has propertynames. false https://pretalx.com/juliacon2019/talk/8WT7C8/ https://pretalx.com/juliacon2019/talk/8WT7C8/feedback/ Elm A Lightning Talk 2019-07-23T16:45:00-04:00 16:45 00:10 With the release of Julia 1.0, packages have raced to update and stabilize APIs. Come learn about all things current and planned for JuliaData packages, including: * DataFrames.jl * CSV.jl * Tables.jl * CategoricalArrays.jl * and others juliacon2019-1093-state-of-the-data-juliadata Jacob Quinn en false https://pretalx.com/juliacon2019/talk/DJY9HU/ https://pretalx.com/juliacon2019/talk/DJY9HU/feedback/ Elm A Lightning Talk 2019-07-23T16:55:00-04:00 16:55 00:10 The internet is a powerful medium for story telling in data science, but creating compelling, interactive graphics can be difficult. This talk will show how Vega (VegaLite.jl) and Julia can be used to prototype interactive visualizations, and then how those visualizations can be deployed to the web. juliacon2019-1762-prototyping-visualizations-for-the-web-with-vega-and-julia Mary McGrath en Using Julia and Vega to jumpstart development of interactive visualizations helps bridge the gap between analysis done on your laptop and publishing compelling results to the web. This talk will show how you can use the language, tools, and development environment you love with Julia and have web-ready interactive graphics ready to deploy. We'll highlight the use of DataVoyager.jl for data exploration, how to use DataVoyager plots to quick-start your visualizations in VegaLite.jl, adding interactivity to your visualizations, and finally how this translates to the web. false https://pretalx.com/juliacon2019/talk/YZPSDK/ https://pretalx.com/juliacon2019/talk/YZPSDK/feedback/ Elm A Talk 2019-07-23T17:05:00-04:00 17:05 00:30 Makie is a new plotting library written a 100% in Julia. It offers a GPU accelerated drawing backend that can draw huge amounts of data at interactive speeds. Other backends for SVG, PDF and the Web are available as well, so Makie can be used in a many different scenarios. This talk will give an overview of how Makie works and will present the most outstanding plotting examples from the areas of Interactivity, Data Science, Geology and Simulations. juliacon2019-908-a-showcase-for-makie /media/juliacon2019/images/ZCWD9M/Screenshot_from_2019-02-25_19-16-22.png Simon Danisch en false https://pretalx.com/juliacon2019/talk/ZCWD9M/ https://pretalx.com/juliacon2019/talk/ZCWD9M/feedback/ Elm B Talk 2019-07-23T11:00:00-04:00 11:00 00:30 If you like using serious scientific tools to do silly things, then this talk is for you. Join me as I explore the intersection of computational linguistics, algorithm design, and machine learning in an effort to seriously overthink cryptic crossword clues. juliacon2019-974-the-linguistics-of-puzzles-solving-cryptic-crosswords-in-julia Robin Deits en Cryptic (or British-style) crosswords are designed to be intentionally vague, misleading, or ambiguous. Each clue combines a standard crossword clue with wordplay elements like anagrams, reversals, or homophones, so solving the clue requires understanding both crossword definitions and a combinatorial explosion of possible wordplays. Here are a couple of easy examples: Clue: "Spin broken shingle" Answer: "english" Explanation: "broken" means to take an anagram of "shingle", which produces "english", and "english" can mean "spin" (at least in billiards). Clue: "Initially babies are naked" Answer "bare" Explanation: "initially" means to take the first letter of "babies", giving "b". Combining "b" and "are" gives "bare", which means "naked". We could try to enumerate every possible thing a word might mean, and every way those meanings might combine, but doing so would result in billions of possibilities, most of which are nonsense. instead, I'll show how we can use tools from computational linguistics to attack this silly problem in a serious way, and I'll show how Julia makes doing so even easier. In particular, I will talk about: * Developing a formal grammar for cryptic crossword clues * Implementing probabilistic parsers which can parse cryptic crossword grammars (or any other grammar, I suppose) * Squeezing as much performance as possible out of string manipulation in Julia * Analyzing the meaning of words and phrases with WordNet.jl and machine learning To learn more, check out the code, all of which is available online right now. You can find the parsing code at https://github.com/rdeits/ChartParsers.jl and the solver itself at https://github.com/rdeits/CrypticCrosswords.jl false https://pretalx.com/juliacon2019/talk/RAKLRV/ https://pretalx.com/juliacon2019/talk/RAKLRV/feedback/ Elm B Lightning Talk 2019-07-23T11:30:00-04:00 11:30 00:10 DoubleFloats.jl offers performant types, Double64 and Double32, with twice the precision of Float64 and Float32. Attendees will gain a working knowledge of how to apply the package in support of more reliably accurate results. juliacon2019-896-counting-on-floating-point Jeffrey Sarnoff en Relax into more reliable floating point. Get more good digits, keep the ones that count. Robustly accurate, `DoubleFloats` offers a way to develop resilient numerics reliably. false https://pretalx.com/juliacon2019/talk/VN7TVD/ https://pretalx.com/juliacon2019/talk/VN7TVD/feedback/ Elm B Lightning Talk 2019-07-23T11:40:00-04:00 11:40 00:10 A hypergraph is a generalization of a graph where a single edge can connect more than two vertices. Typical applications are related to social data analysis and include situations such as sending a single email to several recipients, a customer giving reviews to several restaurants or analyzing security vulnerabilities of information networks. In many situations the usage of a hypergraph rather than a classical graph allows to better capture and analyze dependencies within the network. We will start by presenting the library and its functionality. As an example a use case with analysis of Yelp reviews will be shown. The presentation will be based on Jupyter notebook and will be very illustrative for researchers planning to do social network modelling in Julia. In the second part of presentation we will show how we made use of typical Julia programming patterns to build the library. This includes overloading Array operators to provide a user an Array-like access to the hypegraphs data, using object composition as a standard inheritance mechanism for generating various representations (views) of a hypergraph and finally, making the hypegraph data structures compatible with LightGraphs.jl by providing new method implementations. This should give the participants an overview of typical patterns used when extending the package ecosystem of the Julia language. Acknowledgement: The project is financed by the Polish National Agency for Academic Exchange. juliacon2019-1019-analyzing-social-networks-with-simplehypergraphs-jl Bogumił KamińskiPrzemysław Szufel en false https://pretalx.com/juliacon2019/talk/3FSTJF/ https://pretalx.com/juliacon2019/talk/3FSTJF/feedback/ Elm B Lightning Talk 2019-07-23T11:50:00-04:00 11:50 00:10 This talk demonstrates [Recommendation.jl](https://github.com/takuti/Recommendation.jl), a Julia package for building recommender systems. We will eventually see (1) a brief overview of common recommendation techniques, (2) advantages and use cases of their Julia implementation, and (3) design principles behind the easy-to-use, extensible package. juliacon2019-1015-recommendation-jl-building-recommender-systems-in-julia Takuya Kitazawa en [Recommendation.jl](https://github.com/takuti/Recommendation.jl) allows you to easily implement and experiment your recommender systems, by fully leveraging Julia's efficiency and applicability. This talk demonstrates the package as follows. The speaker first gives a brief overview of theoretical background in the field of recommender systems, along with corresponding Recommendation.jl functionalities. The package supports a variety of well-know recommendation techniques, including k-nearest-neighbors and matrix factorization. Meanwhile, their dedicated evaluation metrics (e.g., recall, precision) and non-personalized baseline methods are available for your experiments. Next, this talk discusses pros and cons of using Julia for recommendation. On the one hand, a number of algorithms fits well into Julia's capability of high-performance scientific computing in this field, but at the same time, it is challenging to make Julia-based recommenders production-grade at scale. The discussion ends up with future ideas of how to improve the package. We will finally see the extensibility of the package with an example of building our own custom recommendation method. In practice, Recommendation.jl is designed to provide separated, flexible *data access layer*, *algorithm layer*, and *recommender layer* to the end users. Consequently, the users can quickly build and test their custom recommendation model with less efforts. Reference: [Recommendation.jl: Building Recommender Systems in Julia](https://takuti.me/note/recommendation-julia/), an article written by the speaker. false https://pretalx.com/juliacon2019/talk/FFXKCX/ https://pretalx.com/juliacon2019/talk/FFXKCX/feedback/ Elm B Talk 2019-07-23T14:30:00-04:00 14:30 00:30 When you design an aircraft or spacecraft, it generally has to work the first time or the consequences are fiery destruction. You simulate a lot. Julia enables not merely a flexible and fast way to write a custom simulation, but in fact an entirely new and powerful breed of simulation architecture. juliacon2019-930-a-new-breed-of-vehicle-simulation Tucker McClure en We’ll see how Julia’s combination of mathy notation, built-in numerical tools, compilation, and metaprogramming opens up new possibilities for creating a simulation environment fit for aircraft, spacecraft, autonomous underwater vehicles, and the like. We’ll examine the special requirements for these types of applications, why elegant solutions have historically been out of reach, and how that picture is beginning to change. Finally, we’ll see how one such simulation environment in Julia has become the backbone of flight algorithm development and testing for a large fleet of autonomous aircraft that deliver life-saving medical supplies in Rwanda and Ghana. false https://pretalx.com/juliacon2019/talk/9D933F/ https://pretalx.com/juliacon2019/talk/9D933F/feedback/ Elm B Lightning Talk 2019-07-23T15:00:00-04:00 15:00 00:10 Model and simulate mechanical 3D-systems with hierarchical components, kinematic loops, and collision handling of convex bodies. juliacon2019-980-modia3d-modeling-and-simulation-of-3d-systems-in-julia /media/juliacon2019/images/WNWNYK/ThreeBar.jpg Andrea Neumayr en The talk is about modeling and simulating mechanical 3D-systems with the Julia package Modia3D.jl. Modia3D initially supports mechanical systems and it shall be expanded into other domains in the future. The package uses the multiple dispatch and metaprogramming concepts of Julia to implement features of modern game engines and multi-body programs such as component-based design, hierarchical structuring, and closed kinematic loops. The mechanical systems are treated as Differential Algebraic Equations which are solved with the variable-step integrator IDA of the Sundials.jl package. Modia3D performs collision handling with elastic response calculation for convex geometries or shapes approximated by a set of convex geometries. A broad phase is executed where each geometry is approximated by a bounding box and only if the bounding boxes are intersecting, the Euclidean distance or the penetration depth is computed in the narrow phase with an improved Minkowski Portal Refinement algorithm. It is planned to combine 3D modeling closely with equation-based modeling. Therefore, the Julia packages Modia3D and Modia needs to interact, for example a joint of a Modia3D system is driven by a Modia model of an electrical motor and gearbox. false https://pretalx.com/juliacon2019/talk/WNWNYK/ https://pretalx.com/juliacon2019/talk/WNWNYK/feedback/ Elm B Lightning Talk 2019-07-23T15:10:00-04:00 15:10 00:10 Trajectory optimization is a fundamental tool for controlling robots with complex, nonlinear dynamics. TrajectoryOptimization.jl is devoted to providing a unified testbed for developing, comparing, and deploying algorithms for trajectory optimization. juliacon2019-986-trajectoryoptimization-jl-a-testbed-for-optimization-based-robotic-motion-planning Brian Jackson en Trajectory optimization is a powerful tool for motion planning, enabling the synthesis of dynamic motion for complex underactuated robotic systems. This general framework can be applied to robots with nonlinear dynamics and constraints where other motion planning paradigms---such as sample-based planning, inverse dynamics, or differential flatness---are impractical or ineffective. TrajectoryOptimization.jl has been developed for the purpose of collecting and developing state-of-the-art algorithms for trajectory optimization under a single, unified platform that offers the user state-of-the-art performance, an intuitive interface, and versatility. Initial results using a novel algorithm written in Julia already beat previous methods leveraging NLP solvers such as Ipopt and Snopt. false https://pretalx.com/juliacon2019/talk/UPLPQW/ https://pretalx.com/juliacon2019/talk/UPLPQW/feedback/ Elm B Lightning Talk 2019-07-23T15:20:00-04:00 15:20 00:10 Navigation and mapping for robots require data fusion from various sensors, each producing uncertain and opportunistic measurement data. We are continuing with a multi-year, native Julia factor graph based simultaneous localization and mapping (SLAM) inference system that grew out of research work on non-Gaussian state-estimation, and is the primary implementation of the "multimodal-iSAM" algorithm from robotics literature. juliacon2019-1017-non-gaussian-state-estimation-with-juliarobotics-caesar-jl Dehann FourieSam Claassens en We are actively using Julia in algorithmic research and development work for robotic navigation. In robotic navigation, multiple sensor data are combined such as odometers, cameras, inertial measurement units, lidars, GPS, sonar acoustics, etc. The dream is to build factor graph based non-Gaussian state-estimation into real-time capable systems. Julia has enabled the development of newer non-Gaussian inference techniques that would otherwise have been near intractable if attempted with older languages. Most SLAM systems today are built in C++ with some Python integration while others are using MATLAB with an eye on later C++ implementations. Switching to Julia has been worth it; our ongoing efforts are to formalize the benefits of the one-language / fast / distributed / high-level-numerical-syntax of Julia with an open-source development model. Our approach not only includes on-board computations but also distributed inference with a cloud server model. JuliaRobotics/Caesar.jl is an umbrella framework alongside dedicated packages such as RoME.jl / IncrementalInference.jl / Arena.jl / ApproxManifoldProducts.jl / GraffSDK.jl. The JuliaRobotics/Caesar.jl package depends on over 100 other Julia packages, creating challenges with first run compile times and debugging efforts. Our challenge now is to continue software development, all-round performance improvement, improved user experience, and help grow the JuliaRobotics community. Although the JuliaRobotics community is still small, we believe that Julia could become a significant language in robotics. In the mean-time, a multi-language interface is in the works too. We are actively using Julia in algorithmic research and development work for robotic navigation. Robotic navigation is generally done by combining data from multiple sensors such as odometers, cameras, inertial measurement units, lidars, GPS, sonar acoustics, etc. The dream is to build factor graph based non-Gaussian state-estimation into real-time capable systems. Julia has enabled the development of newer non-Gaussian inference techniques that would otherwise have been near intractable if attempted with older languages. Most SLAM systems today are built in C++ with some Python integration while others are using MATLAB with an eye on later C++ implementations. Switching to Julia has been worth it; our ongoing efforts are to formalize the benefits of the one-language / fast / distributed / high-level-numerical-syntax of Julia with an open-source development model. Our approach not only includes on-board computations but also distributed inference with a cloud server model. JuliaRobotics/Caesar.jl is an umbrella framework alongside dedicated packages such as RoME.jl / IncrementalInference.jl / Arena.jl / ApproxManifoldProducts.jl / GraffSDK.jl. The JuliaRobotics/Caesar.jl package depends on over 100 other Julia packages, creating challenges with first run compile times and debugging efforts. Our challenge now is to continue software development, all-round performance improvement, improved user experience, and help grow the JuliaRobotics community. false https://pretalx.com/juliacon2019/talk/G7LXYQ/ https://pretalx.com/juliacon2019/talk/G7LXYQ/feedback/ Elm B Talk 2019-07-23T15:45:00-04:00 15:45 00:30 Delay differential equations (DDEs) are used to model dynamics with inherent time delays in different scientific areas; however, solving them numerically in an efficient way is hard. This talk demonstrates how the DifferentialEquations ecosystem allows to solve even complicated DDEs with a variety of different numerical algorithms. juliacon2019-1032-solving-delay-differential-equations-with-julia David Widmann en Time delays are an inherent part of many dynamical systems in different scientific areas such as biology, physiology, chemistry, and control theory, suggesting to model these systems with delay differential equations (DDEs), i.e., differential equations including time delays. However, solving DDEs numerically in an efficient way is hard. In my talk I present [DelayDiffEq.jl](https://github.com/JuliaDiffEq/DelayDiffEq.jl), a Julia package for solving DDEs. I show how it integrates into the DifferentialEquations ecosystem and makes use of the large number of numerical algorithms in [OrdinaryDiffEq.jl](https://github.com/JuliaDiffEq/OrdinaryDiffEq.jl) for solving ordinary differential equations. false https://pretalx.com/juliacon2019/talk/H7TZTT/ https://pretalx.com/juliacon2019/talk/H7TZTT/feedback/ Elm B Talk 2019-07-23T16:15:00-04:00 16:15 00:30 Operating a power system on a day to day basis involves optimizing the operation of the given energy system. Modeling these operations requires solving a Mixed Integer Linear Programming problem. In this talk, we will present methods for solving a production cost model in Julia and JuMP using PowerSimulations.jl juliacon2019-997-open-source-power-system-production-cost-modeling-in-julia Dheepak Krishnamurthy en Production Cost Modeling (PCM) of power systems captures all the costs of operating a fleet of generators. This model captures hourly chronological security constrained unit commitment and economic dispatch simulation while minimizing costs and adhering to a wide variety of operating constraints. In this talk, we will cover the basics of Production Cost Modeling, and will explain how we have implemented this in Julia using JuMP. We will also discuss our experiences using Julia and JuMP and express the benefits to our users and some challenges we faced. false https://pretalx.com/juliacon2019/talk/8DTHDK/ https://pretalx.com/juliacon2019/talk/8DTHDK/feedback/ Elm B Talk 2019-07-23T16:45:00-04:00 16:45 00:30 Modeling practice seems to be partitioned into scientific models defined by mechanistic differential equations and machine learning models defined by parameterizations of neural networks. While the ability for interpretable mechanistic models to extrapolate from little information is seemingly at odds with the big data "model-free" approach of neural networks, the next step in scientific progress is to utilize these methodologies together in order to emphasize their strengths while mitigating weaknesses. In this talk we will describe four separate ways that we are merging differential equations and deep learning through the power of the DifferentialEquations.jl and Flux.jl libraries. Data-driven hypothesis generation of model structure, automated real-time control of dynamical systems, accelerated of PDE solving, and memory-efficient deep learning workflows will all shown to be derived from this common computational structure of differential equations mixed with neural networks. The audience will leave with a new appreciation of how these two disciplines can benefit from one another, and how neural networks can be used for more than just data analysis. juliacon2019-1056-scientific-ai-domain-models-with-integrated-machine-learning Chris Rackauckas en Dynamical models are often interesting due to the high-level qualitative behavior that they display. Differential equation descriptions of fluids accurately predict when drone flight will go unstable, and stochastic evolution models demonstrate the behavior for how patterns may suddenly emerge from biological chemical reactions. However, utilizing these models in practice requires the ability to understand, prediction, and control these outcomes. Traditional nonlinear control methods directly tie the complexity of the simulation to the control optimization process, making it difficult to apply these methods in real-time to highly detailed but computationally expensive models. In this talk we will show how to decouple the computation time of a model from the ability to predict and control its qualitative behavior through a mixture of differential equation and machine learning techniques. These new methods directly utilize the language-wide differentiable programming provided by Flux.jl to perform automatic differentiation on differential equation models described using DifferentialEquations.jl. We demonstrate an adaptive data generation technique and show that common classification methods from machine learning literature converge to >99% accuracy for determining qualitative model outcomes directly from the parameters of the dynamical model. Using a modification of methods from Generative Adversarial Networks (GANs), we demonstrate an inversion technique with the ability to predict dynamical parameters that meet user-chosen objectives. This method is demonstrated to be able to determine parameters which constrains predator-prey models to a specific chosen domain and predict chemical reaction rates that result in Turing patterns for reaction-diffusion partial differential equations. Code examples will be shown and explained to directly show Julia users how to do these new techniques. Together, these methods are scalable and real-time computational tools for predicting and controlling the relation between dynamical systems and their qualitative outcomes with many possible applications. false https://pretalx.com/juliacon2019/talk/QJAUAT/ https://pretalx.com/juliacon2019/talk/QJAUAT/feedback/ Elm B Lightning Talk 2019-07-23T17:15:00-04:00 17:15 00:10 [HydroPowerModels.jl](https://github.com/andrewrosemberg/HydroPowerModels.jl) is a Julia/JuMP package for Hydrothermal Multistage Steady-State Power Network Optimization solved by Stochastic Dual Dynamic Programming (SDDP). The objective of this work is to build an open source tool for hydro-thermal dispatch that is flexible enough for the electrical sector to test new ideas in an agile and high-level way, but at the same time using the state-of-the-art implementations of both the SDDP and the dispatch model formulations. For this, we will take advantage of the julia language and the packages, also open-source, which implement the power flow of the electrical dispatch and the Stochastic Dual Dynamic Programming (SDDP), called respectively [PowerModels.jl](https://github.com/lanl-ansi/PowerModels.jl) and [SDDP.jl](https://github.com/odow/SDDP.jl). juliacon2019-1033-hydropowermodels-jl-a-julia-jump-package-for-hydrothermal-economic-dispatch-optimization Andrew Rosemberg en The hydrothermal dispatch problem is very important for the planning and operation of the electrical system, especially for the Brazilian system. It is composed of an optimization problem in which the generation of generators, energy distribution and hydro storage management are coordinated in order to minimize cost of operation. Often, this problem is formulated with the Multi-stage Stochastic optimization framework, where decisions are taken for various periods and in the presence of uncertainties, since the generation resources are limited and often shared inter-temporally. Solving Multi-stage Stochastic optimization is a challenging numerical problem. Therefore, these are commonly solved by a methodology based on the approximation of the bellman equation of stochastic dynamic programming by a piecewise linear function, called Stochastic Dual Dynamic Programming (SDDP). This methodology is preferred because it avoids the high dimensionality of present in classical stochastic dynamic programming. The objective of this work is to build an open source tool for Hydrothermal Multistage Steady-State Power Network Optimization solved by Stochastic Dual Dynamic Programming (SDDP). Problem Specifications and Network Formulations are handled by [PowerModels.jl](https://github.com/lanl-ansi/PowerModels.jl). Solution method is handled by [SDDP.jl](https://github.com/odow/SDDP.jl). The talk will constitute of: (i) An overview of the package; (ii) A brief description of the dependent packages and their integration; (iii) Quick example of the package's usage. false https://pretalx.com/juliacon2019/talk/BXYJ8D/ https://pretalx.com/juliacon2019/talk/BXYJ8D/feedback/ Elm B Lightning Talk 2019-07-23T17:25:00-04:00 17:25 00:10 The ExaSGD (Optimizing Stochastic Grid Dynamics at Exascale) application is part of the Department of Energy's Exascale project (ECP). The dawn of renewable energies poses a great challenge to long-term planning with higher uncertainties, not only in the grid load, but also in the energy generation. The goal of this project is to provide policy planners and grid operators with cost effective long term planning solutions that are protected against uncertainties in the grid operation. This talk gives an overview of our implementation and where we leverage Julia's unique capabilities to make efficient use of the upcoming exascale hardware, while giving engineers a flexible modeling language. juliacon2019-1045-modeling-in-julia-at-exascale-for-power-grids Michel Schanen en false https://pretalx.com/juliacon2019/talk/JAXM9R/ https://pretalx.com/juliacon2019/talk/JAXM9R/feedback/ Room 349 Talk 2019-07-23T11:00:00-04:00 11:00 00:30 One of the major features of Julia's new package manager is _package environments_. This presentation will explain how environments work, what they are useful for and how to use them effectively. juliacon2019-1089-pkg-project-toml-manifest-toml-and-environments Fredrik Ekre en Julia's new package manager, Pkg, was released together with version 1.0 of the Julia language. The new package manager is a complete rewrite of the old one, and solves many of the problems observed in the old version. One major feature of the new package manager is the concept of _package environments_, which can be described as independent, sandboxed, sets of packages. A package environment is represented by a `Project.toml` and `Manifest.toml` file pair. These files keep track of what packages, and what versions, are available in a given environment. Since environments are "cheap", just two files, they can be used liberally. It is often useful to create new environments for every new coding project, instead of installing packages on the global level. Since the package manager modifies the current project, e.g. when adding, removing or updating packages, there is no risk for these operations to mess up other environments. The fact that exact versions of packages in the environment is being recorded means that Julia has reproducibility built-in. As long as the `Project.toml` and `Manifest.toml` file pair is available it is possible to replicate exactly the same package environment. Some typical use cases include being able to replicate the same package environment on a different machine, and being able to go back in time and run some old code which might require some old versions of packages. In this presentation we will discuss how environments work, how they interact with the package manager and Julia's code loading, and how to effectively use them. Hopefully you will be more comfortable working with, and seeing the usefulness of, environments after this presentation. false https://pretalx.com/juliacon2019/talk/KAMHYJ/ https://pretalx.com/juliacon2019/talk/KAMHYJ/feedback/ Room 349 Lightning Talk 2019-07-23T11:30:00-04:00 11:30 00:10 Have you ever found yourself writing code that special cases different local and remote [filesystems](https://en.wikipedia.org/wiki/File_system)? FilePath types are a great way to encapsulate filesystem specific logic and provide a common [abstraction](https://en.wikipedia.org/wiki/Abstraction_layer) for interacting with various types of paths (e.g., posix, windows, S3, FTP). juliacon2019-1104-filepaths-file-system-abstractions-and-why-we-need-them Rory Finnegan en We'll start by discussing filesystem libraries for other languages (e.g., [pathlib](https://docs.python.org/3/library/pathlib.html) for Python, [Data.FilePath](https://hackage.haskell.org/package/data-filepath-2.2.0.0/docs/Data-FilePath.html) for Haskell, [Paths](https://doc.rust-lang.org/std/path/struct.Path.html) in Rust) and how such abstractions may uniquely benefit from multiple dispatch in Julia. I’ll review some examples of how we (myself and my colleagues) have used [FilePathsBase.jl](https://github.com/rofinn/FilePathsBase.jl) to simplify our application logic and avoid ambiguous code paths. Finally, we'll conclude with an open discussion around how these abstractions can be better incorporated into the larger Julia ecosystem. false https://pretalx.com/juliacon2019/talk/CY3YQB/ https://pretalx.com/juliacon2019/talk/CY3YQB/feedback/ Room 349 Lightning Talk 2019-07-23T11:40:00-04:00 11:40 00:10 Ultimate datetime is a datetime data type, which eliminates many of the limitations and inaccuracies of the datetime datatypes generally employed in computer languages. Ultimate datetime enables representation of datetimes from the Big Bang through to the year 100,000,000,000 with attosecond precision, while properly handling leap seconds, the full range of time zones, and accounting for precision and uncertainty. juliacon2019-1094-ultimate-datetime Jay Dweck en Ultimate datetime is a high performance, comprehensive datatype that was developed in C, then integrated into Julia. Ultimate datetime represents datetimes from the Big Bang through the year 100,000,000,000 with attosecond precision. Specifiable precision and uncertainty have been implemented along with a rich set of comparison and arithmetic functions. Leap seconds are handled properly, as is the pre-leap second atomic time period. Local times support the full range of time zones provided in the IANA database, including proper accounting for historical time zones, as well as the varying transitions from the Julian to the Gregorian calendar around the world. false https://pretalx.com/juliacon2019/talk/UUESUW/ https://pretalx.com/juliacon2019/talk/UUESUW/feedback/ Room 349 Lightning Talk 2019-07-23T11:50:00-04:00 11:50 00:10 Hardware and software scale model of a smart house that utilises the functions of a Raspberry Pi. It has several functions that could be transferred to a full-scale model using the same hardware. juliacon2019-897-smart-house-with-juliaberry Ahan Sengupta en This project is a miniaturised smart house that uses a Raspberry Pi and Julia to automatically run a small model home. This smart house uses a Raspberry Pi with a Sense HAT and Explorer HAT Pro to create several functions that could be used on a real house. This includes a motion sensor that opens a door; a photoresistor that turns lights on and off and a Sense HAT taking readings and scrolling through them on an LED matrix. All these are functions which are used on houses and have been scaled down using the Raspberry Pi and the Julia Language. false https://pretalx.com/juliacon2019/talk/G9Z3AG/ https://pretalx.com/juliacon2019/talk/G9Z3AG/feedback/ Room 349 Talk 2019-07-23T14:30:00-04:00 14:30 00:30 We present MLJ, Machine Learning in Julia, a new toolbox for combining and systematically tuning machine learning models. juliacon2019-978-mlj-machine-learning-in-julia Anthony Blaom en MLJ, an open-source machine learning toolbox written in Julia, has evolved from an early proof of concept, to a functioning well-featured prototype. Features include: 1. A flexible API for complex model composition, such as stacking. 2. Repository of externally implemented model metadata, for facilitating composite model design, and for matching models to problems through a MLR-like task interface. 3. Systematic tuning and benchmarking of models having possibly nested hyperparameters. 4. Unified interface for handling probabilistic predictors and multivariate targets. 5. Agnostic data containers 6. Careful handling of categorical data types. In addition to demonstrating some of these features, we discuss relationships with other Julia projects in the data science domain. false https://pretalx.com/juliacon2019/talk/JWEAN3/ https://pretalx.com/juliacon2019/talk/JWEAN3/feedback/ Room 349 Lightning Talk 2019-07-23T15:00:00-04:00 15:00 00:10 Working on our previous contributions for JuliaCon 2018 (see [GlobalSearchRegresssion.jl](https://github.com/ParallelGSReg/GlobalSearchRegression.jl), [GlobalSearchRegressionGUI.jl](https://github.com/ParallelGSReg/GlobalSearchRegressionGUI.jl), and [our JuliaCon 2018 Lighting Talk] (https://bit.ly/2UC7dr1)) we develop a new GlobalSearchRegression.jl version merging LASSO and QR-OLS algorithms, and including new outcome capabilities. Combining machine learning (ML) and econometric (EC) procedures allows us to deal with a much larger set of potential covariates (e.g. from 30 to hundresds) preserving most of the original advantages of all-subset regression approaches (in-sample and out-of sample optimality, model averaging results and residuals tests for coefficient robustness). Additionally, the new version of GlobalSearchRegression.jl allows users to obtain LATEX and PDF outcomes with best model results, model averaging estimations and key statistics distributions juliacon2019-976-merging-machine-learning-and-econometric-algorithms-to-improve-feature-selection-with-julia Demian PanigoAdán Mauri UngaroNicolás MonzónValentin Mari en Applied scientific research increasingly uses Fat-Data (e.g. large number of explanatory variables relative to number of observations) for feature selection purposes. Previous version of our all-subset-regression Julia package was unable to deal with such databases. Existing ML packages (e.g. [Lasso.jl](https://github.com/JuliaStats/Lasso.jl)) overcome this problem paying a cost in terms of statistical inference, coefficient robustness and feature selection optimality (because ML algorithms focus on prediction not on explanation or causal-prediction). The new GlobalSearchRegression.jl version combines regularization pre-processsing with all-subset-regression algorithms to efficiently work with Fat Data without losing EC-strengths in terms of sensitivity analysis, residual properties and coefficient robustness. In the first 3 minutes, our Lighting talk will discuss GlobalSearchRegression.jl new capabilities. We will focus on the main advantages of merging ML and EC algorithms for feature selection when the number of potential covariates is relatively large: ML provides efficiency and sub-sample uncertainty assessment while EC guarantees in-sample and out-of-sample optimality with covariate uncertainty assessment. Then, we will show different benchmarks for the new GlobalSearchRegression.jl package against R and Stata counterparts, as well as against their own original version. Our updated ML-EC- algorithm written in Julia is up to 100 times faster than similar R or Stata programs, and allows working with hundreds of potential covariates (while the upper limit for the original GlobalSearchRegression.jl version was 28). Finally, we will use the last 4 minutes for a live hands-on example to show the Graphical User Interface, execute the ML-EC algorithm with fat data and analyze main results using new output capabilities in Latex-PDF. false https://pretalx.com/juliacon2019/talk/7NRBXW/ https://pretalx.com/juliacon2019/talk/7NRBXW/feedback/ Room 349 Lightning Talk 2019-07-23T15:10:00-04:00 15:10 00:10 Games have been testbeds for Artificial Intelligence research for a long time. Here I will demonstrate how to play the fantastic [Hanabi card game](https://en.wikipedia.org/wiki/Hanabi_(card_game)) interactively in Julia REPL. Furthermore, I will introduce how to implement some state-of-the-art learning algorithms in pure Julia. juliacon2019-1041-let-s-play-hanabi /media/juliacon2019/images/8T3FVZ/me.jpg Jun Tian en Hanabi is a card game for two to five players. What makes Hanabi special is that, unlike most card games, players can only see their partners' hands, and not their own. In this talk, I will focus on the following three parts: 1. A short introduction to Hanabi and how to implement the game in a client-server style in Julia. 2. The challenges of Hanabi and some typical approaches. 3. The implementation details of some state-of-the-art algorithms. I hope this talk can arouse the interest of the audiences. And get more people involved in the reinforcement learning field in Julia. false https://pretalx.com/juliacon2019/talk/8T3FVZ/ https://pretalx.com/juliacon2019/talk/8T3FVZ/feedback/ Room 349 Lightning Talk 2019-07-23T15:20:00-04:00 15:20 00:10 TSML is a package for time series data processing, classification, and prediction. It provides common API for ML libraries from Python's ScikitLearn, R's caret, and native Julia MLs for seamless integration of heterogenous libraries to create complex ensembles for robust time-series preprocessing, prediction, clustering, and classification. juliacon2019-1011-tsml-time-series-machine-learning Paulito Palmes en Over the past years, the industrial sector has seen many innovations brought about by automation. Inherent in this automation is the installation of sensor networks for status monitoring and data collection. One of the major challenges in these data-rich environments is how to extract and exploit information from these large volume of data to detect anomalies, discover patterns to reduce downtimes and manufacturing errors, reduce energy usage, etc. To address these issues, we developed TSML package. It leverages AI and ML libraries from ScikitLearn, Caret, and Julia as building blocks in processing huge amount of industrial time series data. It has the following characteristics: - TS data type clustering/classification for automatic data discovery - TS aggregation based on date/time interval - TS imputation based on symmetric Nearest Neighbors - TS statistical metrics for data quality assessment - TS ML wrapper with more than 100+ libraries from caret, scikitlearn, and julia - TS date/value matrix conversion of 1-D TS using sliding windows for ML input - Common API wrappers for ML libs from JuliaML, PyCall, and RCall - Pipeline API allows high-level description of the processing workflow - Specific cleaning/normalization workflow based on data type - Automatic selection of optimised ML model - Automatic segmentation of time-series data into matrix form for ML training and prediction - Easily extensible architecture by using just two main interfaces: fit and transform - Meta-ensembles for robust prediction - Support for distributed computation, for scalability, and speed TSML uses a pipeline which iteratively calls the fit and transform families of functions relying on multiple dispatch to select the correct algorithm. Machine learning functions in TSML are wrappers to the corresponding Scikit-learn, Caret, and native Julia ML libraries. There are more than hundred classifiers and regression functions available using a common API. Full TSML documentation: https://ibm.github.io/TSML.jl/stable/ false https://pretalx.com/juliacon2019/talk/9GAZTS/ https://pretalx.com/juliacon2019/talk/9GAZTS/feedback/ Room 349 Talk 2019-07-23T15:45:00-04:00 15:45 00:30 We showcase the port to Julia of a massively parallel Multi-GPU solver for spontaneous nonlinear multi-physics flow localization in 3-D. Our contribution is a real-world example of Julia solving "the two language problem". juliacon2019-1028-porting-a-massively-parallel-multi-gpu-application-to-julia-a-3-d-nonlinear-multi-physics-flow-solver Ludovic Räss en We showcase the port to Julia of a massively parallel Multi-GPU solver for spontaneous nonlinear multi-physics flow localization in 3-D. The original solver is itself the result of a translation from a Matlab prototype to CUDA C and MPI. Our contribution is an illustration of Julia solving "the two language problem": the Matlab prototype and the CUDA C + MPI production code are being replaced by a single Julia code that will serve both further prototyping and production. The solver's parallel and matrix-free design enables a short time to solution and is applicable to solve a wide variety of coupled and nonlinear systems of partial differential equations in 3-D. The employed stencil-based iterative method optimally suits both shared and distributed memory parallelization. As reference, the original Multi-GPU solver achieved a high performance and a nearly ideal parallel efficiency on up to 5120 NVIDIA Tesla P100 GPUs on the hybrid Cray XC-50 "Piz Daint" supercomputer at the Swiss National Supercomputing Centre, CSCS. We report the first performance and scaling results obtained with the Julia port. We present additionally our porting approach and discuss the related challenges. false https://pretalx.com/juliacon2019/talk/LGHLC3/ https://pretalx.com/juliacon2019/talk/LGHLC3/feedback/ Room 349 Talk 2019-07-23T16:15:00-04:00 16:15 00:30 The intersection of Machine Learning and High Performance Computing: Running Julia code on Google Cloud Tensor Processing Units. juliacon2019-1018-xla-jl-julia-on-tpus Elliot SabaKeno Fischer en Machine Learning workloads continue to require greater and greater compute capability, spawning the development of multiple generations of specialized hardware designed to eke out ever greater efficiency in training and inference workloads. This talk will explore the state of Julia on this hardware platform, showcasing some of the impressive speedups the hardware and provide, alongside some of the restrictions the hardware model imposes upon the dynamic nature of the Julia language. false https://pretalx.com/juliacon2019/talk/8ANSVY/ https://pretalx.com/juliacon2019/talk/8ANSVY/feedback/ Room 349 Lightning Talk 2019-07-23T16:45:00-04:00 16:45 00:10 MLIR is a flexible compiler infrastructure with an open ecosystem of dialects, built for a world of increasingly heterogeneous hardware. With its support for metaprogramming and extensible JIT compiler, Julia is well-positioned as a frontend language for the MLIR stack. juliacon2019-1060-targeting-accelerators-with-mlir-jl James Bradbury en false https://pretalx.com/juliacon2019/talk/3YBZLC/ https://pretalx.com/juliacon2019/talk/3YBZLC/feedback/ Room 349 Lightning Talk 2019-07-23T16:55:00-04:00 16:55 00:10 ChipSort.jl is a sorting package that exploits instruction-level parallelism and cache memory seeking the best performance in any system. juliacon2019-931-simd-and-cache-aware-sorting-with-chipsort-jl /media/juliacon2019/images/YDVQKM/logo.png Nicolau Leal Werneck en To attain the best performance with a modern computer, programmers are required to exploit thread and instruction level parallelism and make sure memory access follows suitable patterns. ChipSort.jl is a sorting package that implements techniques exploiting parallelism and memory locality. It uses SIMD instructions to implement basic operations such as sorting networks, merging networks, and in-place matrix transpose. These operations can be used to sort large arrays using merge-sort exploiting SIMD and cache memory for improved performance. The implementation is largely based on unique Julia features such as generated functions and parametric methods, allowing Julia to generate optimized custom machine code for different architectures based on the same high-level Julia code. Experiments were made with both Intel (AVX2 and AVX512) and AMD (NEON) processors, achieving speedups from 2 up to 17 times in different benchmarks. Project documentation: https://nlw0.github.io/ChipSort.jl false https://pretalx.com/juliacon2019/talk/YDVQKM/ https://pretalx.com/juliacon2019/talk/YDVQKM/feedback/ Room 349 Lightning Talk 2019-07-23T17:05:00-04:00 17:05 00:10 Sparse linear operators that arise from structured grids often tend to have rich structure. We present a feature rich yet simple DIAgonal format (DIA), which also supports blocked and GPU arrays, as well as Algebraic Multigrid (AMG) preconditioners. We present this rich framework of tools to solve large oil reservoir simulations. juliacon2019-1070-generic-sparse-data-structures-on-gpus Sungwoo JeongRanjan Anantharaman en Sparse matrices arising from structured grids generally possess rich structure, which is amenable to GPU-parallelism. We implemented the DIA format, one of the most primitive sparse matrix storage formats, in Julia. BLAS routines are implemented on DIA format with GPU using `CUDAnative.jl` and `CuArrays.jl`. We also present Geometric Multigrid(GMG) preconditioner, implemented on GPU using DIA format and solve large ill-conditioned systems. Julia allows users to write generic code, which allows us to exploit blocked structure that arises from higher degrees of freedom. We benchmark and verify against the SPE10 problem, a standard oil reservoir simulation benchmark. false https://pretalx.com/juliacon2019/talk/BXVHJV/ https://pretalx.com/juliacon2019/talk/BXVHJV/feedback/ Room 349 Lightning Talk 2019-07-23T17:15:00-04:00 17:15 00:10 We introduce the ArrayChannels.jl library, which allows communication between distributed nodes to occur between fixed buffers in memory. We explore the effects of in-place serialisation on cache usage and communication performance, and consider its suitability for high performance scientific computing. juliacon2019-960-array-data-distribution-with-arraychannels-jl Rohan McLure en We introduce a library to the language, 'ArrayChannels.jl', encapsulating several data parallelism patterns which causes serialisation of arrays between processes to occur in-place. This provides for better handling of processor cache, while retaining the synchronous semantics of Julia's RemoteChannel constructs. We then evaluate the performance of the library by comparison to MPI and standard Julia on a number of microbenchmarks and HPC kernels. false https://pretalx.com/juliacon2019/talk/AADAJW/ https://pretalx.com/juliacon2019/talk/AADAJW/feedback/ Room 349 Lightning Talk 2019-07-23T17:25:00-04:00 17:25 00:10 We will talk about how a risk management use case got sped up ~150x using multi-core parallel computing techniques in a Docker environment. juliacon2019-1092-high-performance-portfolio-risk-aggregation Tom Kwong en Western Asset is a fixed income asset manager. We recently replaced the portfolio risk aggregation process with a Julia implementation, and the run-time performance has improved tremendously. This talk will focus on system architecture, performance optimization, and deployment to a Docker swarm environment. false https://pretalx.com/juliacon2019/talk/LR9FW9/ https://pretalx.com/juliacon2019/talk/LR9FW9/feedback/ NS Room 130 Lightning Talk 2019-07-23T08:30:00-04:00 08:30 00:10 Welcome to Juliacon! This opening session will let you know all the details of what is going on, and will include the important information and what to do in-case of emergencies. juliacon2019-2566-opening-remarks JuliaCon Committee en false https://pretalx.com/juliacon2019/talk/F8BBQW/ https://pretalx.com/juliacon2019/talk/F8BBQW/feedback/ NS Room 130 Keynote 2019-07-23T08:40:00-04:00 08:40 00:45 Madeleine Udell is Assistant Professor of Operations Research and Information Engineering and Richard and Sybil Smith Sesquicentennial Fellow at Cornell University. She studies optimization and machine learning for large scale data analysis and control, with applications in marketing, demographic modeling, medical informatics, engineering system design, and automated machine learning. Her research in optimization centers on detecting and exploiting novel structures in optimization problems, with a particular focus on convex and low rank problems. These structures lead the way to automatic proofs of optimality, better complexity guarantees, and faster, more memory-efficient algorithms. She has developed a number of open source libraries for modeling and solving optimization problems, including [Convex.jl](https://github.com/JuliaOpt/Convex.jl), one of the top tools in the Julia language for technical computing. juliacon2019-2560-keynote-professor-madeleine-udell Professor Madeleine Udell en false https://pretalx.com/juliacon2019/talk/PMLSD9/ https://pretalx.com/juliacon2019/talk/PMLSD9/feedback/ NS Room 130 Talk 2019-07-23T09:30:00-04:00 09:30 00:30 We present a Julia debugger and demonstrate a variety of interfaces for accessing it. We also describe the infrastructure that provides intriguing new capabilities to the Julia ecosystem. juliacon2019-1107-debugging-code-with-juliainterpreter Kristoffer CarlssonTim HolySebastian Pfitzner en A Julia debugger, with support for breakpoints, trapping errors, and inspection of local variables, has been long desired in the Julia community. We describe an approach based on a new interpreter for Julia code, JuliaInterpreter.jl. JuliaInterpreter is able to evaluate Julia’s [lowered representation](https://docs.julialang.org/en/latest/devdocs/ast/) statement-by-statement, and thus serves as the foundation for inspecting and manipulating intermediate results. Compared with previous tools, JuliaInterpreter offers several new features, such as improved performance, the ability to evaluate top-level code, built-in support for breakpoints, and the ability to switch flexibly between compiled and interpreted evaluation. JuliaInterpreter can be used directly as a standalone interpreter, and this makes it interesting for other purposes such as exploring tradeoffs between compile-time and run-time efficiency. To enable JuliaInterpreter’s use as a debugger, we developed three different front-ends. One is the Juno IDE, which supports graphical management of breakpoints and stepping through code in a manner integrated with its editing capabilities. In addition to Juno, there are two different console-based (REPL) interfaces. Debugger.jl offers the most powerful control over stepping, whereas Rebugger.jl emulates features of a graphical client. We will demonstrate these tools as means to access some of JuliaInterpreter’s capabilities. false https://pretalx.com/juliacon2019/talk/BB9VQZ/ https://pretalx.com/juliacon2019/talk/BB9VQZ/feedback/ NS Room 130 Sponsor's Address 2019-07-23T10:00:00-04:00 10:00 00:05 An address from one of our sponsors. juliacon2019-2569-sponsor-address-intel /media/juliacon2019/images/LFGLXC/intel1_HL8u1Rh.png Paul Petersen en false https://pretalx.com/juliacon2019/talk/LFGLXC/ https://pretalx.com/juliacon2019/talk/LFGLXC/feedback/ NS Room 130 Lightning Talk 2019-07-23T10:05:00-04:00 10:05 00:10 A presentation on the results of the 2019 Julia Survey juliacon2019-2558-julia-survey-results Viral B. Shah en false https://pretalx.com/juliacon2019/talk/9NK3HY/ https://pretalx.com/juliacon2019/talk/9NK3HY/feedback/ NS Room 130 Sponsor's Address 2019-07-23T10:15:00-04:00 10:15 00:05 A talk from one of our gracious sponsors. juliacon2019-2622-sponsor-address-relational-ai Nathan Daly en false https://pretalx.com/juliacon2019/talk/CQM3RC/ https://pretalx.com/juliacon2019/talk/CQM3RC/feedback/ NS Room 130 Keynote 2019-07-23T13:30:00-04:00 13:30 00:45 Ted Rieger received his PhD in Chemical Engineering from Northwestern where he developed models of protein aggregation of Huntington. After graduate school, he joined Entelos, Inc in the Bay Area where he spent 6 years, developing and utilizing Quantitative Systems Pharmacology (QSP) models to understand drug development questions, primarily in the area of cardiometabolic diseases. In 2011, Ted transitioned to Pfizer’s Systems Biology Group in our CVMET Research Unit. He has been at Pfizer since then, and is now a Senior Principal Scientist in the QSP Group in Early Clinical Development. He presently supports programs in the cardiometabolic space from early discovery through proof-of-concept. juliacon2019-2565-keynote-dr-ted-rieger Dr Ted Rieger en false https://pretalx.com/juliacon2019/talk/AY9C9Z/ https://pretalx.com/juliacon2019/talk/AY9C9Z/feedback/ BoF: Room 353 Birds of Feather 2019-07-23T11:00:00-04:00 11:00 01:00 A lot of people are building tooling for differential equation based models in Julia for various domains. DifferentialEquations.jl, DynamicalSystems.jl, PuMaS.jl, Modia.jl, QuantumOptics.jl, etc. and the list goes on. The purpose of this BoF is to gather the developers who are interested in this topic in order to learn about the priorities and gripes within the community in order to plan for the next developments. juliacon2019-1058-dynamical-modeling-in-julia Chris Rackauckas en Many different aspects of dynamical modeling in Julia have seen a recent boom in popularity. A lot of package development focus has been given to the tooling for simulating dynamical models, such as the differential equation solvers of DifferentialEquations.jl and the relevant underlying pieces like IterativeSolvers.jl and NLsolve.jl. In addition, a community of domain-specific modeling tools such as DynamicalSystems.jl, Modia.jl, PuMaS.jl, QuantumOptics.jl, and more than can be listed have all built their own user bases. The purpose of this BoF is to gather the developers of these related tooling to discuss the current state of the ecosystem and develop plans and priorities for next steps. A quick overview of the package space and its recent developments will be given to frame the conversion, with most of the time dedicated to discussion. Possible topics include (but are not limited to) understanding the domains most in need of new and more performant solvers, the utilization of parallelism (multithreading, multiprocessing, and GPu), incorporating symbolic tooling such as ModelingToolkit.jl, and the commonalities of analysis tooling (such as parameter estimation, neural network integration, uncertainty propagation). We invite developers within the community to express their feedback and help guide our next moves within the package space. true https://pretalx.com/juliacon2019/talk/Q8KE7A/ https://pretalx.com/juliacon2019/talk/Q8KE7A/feedback/ BoF: Room 353 Birds of Feather 2019-07-23T14:30:00-04:00 14:30 01:00 JuliaDB is an analytical data framework that offers typed dataframes, parallel processing, and limited out-of-core support. This session gives JuliaDB users and contributors the opportunity to discuss how JuliaDB works for them, tackle issues, and discuss the future of JuliaDB. juliacon2019-951-juliadb-code-and-chat /media/juliacon2019/images/GPZYS7/39419944.png Josh Day en Possible topics of conversation/things to work on: - JuliaDB wishlist - Utilities for feature engineering/other ML tasks - Fixing bugs - Creating benchmarks true https://pretalx.com/juliacon2019/talk/GPZYS7/ https://pretalx.com/juliacon2019/talk/GPZYS7/feedback/ BoF: Room 353 Birds of Feather 2019-07-23T15:45:00-04:00 15:45 00:50 Discussion on how Julia as a community handles money, sponsorship and grants. juliacon2019-2618-julia-and-numfocus-a-discussion-of-how-money-works Viral B. Shah en true https://pretalx.com/juliacon2019/talk/TFFARR/ https://pretalx.com/juliacon2019/talk/TFFARR/feedback/ BoF: Room 353 Birds of Feather 2019-07-23T16:35:00-04:00 16:35 01:00 Chat about Cassette, Vinyl, IRTools, and Aborist. Things that rewrite the code at compile-time, based on context. juliacon2019-2631-cassette-and-company-dynamic-compiler-passes Valentin ChuravyJarrett Revels en true https://pretalx.com/juliacon2019/talk/APPUNN/ https://pretalx.com/juliacon2019/talk/APPUNN/feedback/ Other Break 2019-07-23T07:30:00-04:00 07:30 01:00 Breakfast will be held in the SMC 2nd Floor Lobby juliacon2019-2593-breakfast en false https://pretalx.com/juliacon2019/talk/JRCQHU/ https://pretalx.com/juliacon2019/talk/JRCQHU/feedback/ Other Break 2019-07-23T10:20:00-04:00 10:20 00:40 A break for coffee juliacon2019-2606-morning-break en false https://pretalx.com/juliacon2019/talk/BY7ZUX/ https://pretalx.com/juliacon2019/talk/BY7ZUX/feedback/ Other Break 2019-07-23T12:05:00-04:00 12:05 01:15 Lunch will be held in the SMC 2nd Floor Lobby juliacon2019-2587-lunch en false https://pretalx.com/juliacon2019/talk/ESLAXZ/ https://pretalx.com/juliacon2019/talk/ESLAXZ/feedback/ Other Break 2019-07-23T15:30:00-04:00 15:30 00:15 A short break between sessions juliacon2019-2610-short-break en false https://pretalx.com/juliacon2019/talk/BZSMMV/ https://pretalx.com/juliacon2019/talk/BZSMMV/feedback/ Other Break 2019-07-23T19:00:00-04:00 19:00 02:30 A conference dinner and cruise are planned on Tuesday evening for all ticketed attendees. Boarding is at 7:00 PM in front of the Baltimore Visitor Center located on the promenade facing Light Street. *All participants are expected to bring the conference badges for identification*. Boarding will be complete by 7:25 PM and the Cruise begins at sharp 7:30 PM. Dinner will be served at 8:00 PM so, feel free to get a light snack if it’s too late. There will be a DJ onboard in case anyone wants to put on their dancing shoes. Further details will be announced on-site. juliacon2019-2612-conference-dinner-and-inner-harbor-cruise en false https://pretalx.com/juliacon2019/talk/CNQ9JB/ https://pretalx.com/juliacon2019/talk/CNQ9JB/feedback/ Elm A Talk 2019-07-24T11:00:00-04:00 11:00 00:30 Julia allows interfacing with shared libraries using `ccall`. This allows calling into compiled binaries that could be written in any language that exposes the C ABI. In this talk, I'll describe best practices to follow for interfacing with C libraries. juliacon2019-998-why-writing-c-interfaces-in-julia-is-so-easy Dheepak Krishnamurthy en This talk is titled why writing C interfaces in Julia is so easy, but as anyone that has written interfaces to C ABI will know, interfacing with the C ABI is never easy. There can be segfaults, memory leaks, uninitialized memory issues and a host of other challenges to deal with when working through this process. In this talk, I'll briefly describe how the C ABI works, and then describe how `ccall` can be used. I'll also go through many best practices that I've used to ensure a nice clean Julian interface to a shared library. I will show how some best practices regarding writing interfaces to a large number of functions, you can use Julia's type system to guarantee that the users of your Julia library don't accidentally pass the wrong pointer to a function using `unsafe_convert`, and some general advice for programmers interested in writing their own libraries in a lower level language (such as C, C++, Rust, Nim etc) and how to ensure that they can be provided as pre-compiled binaries for Julia packages (using BinaryBuilder and alternatives). false https://pretalx.com/juliacon2019/talk/ARX8CY/ https://pretalx.com/juliacon2019/talk/ARX8CY/feedback/ Elm A Lightning Talk 2019-07-24T11:30:00-04:00 11:30 00:10 Julia command literals are one of the most compelling abstractions for dealing with processes in any programming language. This talk will show what these command literals offer that similar constructs in other languages do not and how they can be used to write safer, more robust shell scripts. juliacon2019-1014-backticks-and-the-glorious-command-literal Aaron Christianson en Like Perl, Ruby and Bash, Julia offers backtick syntax as an abstraction for dealing with processes. However, while other languages use this syntax to invoke a shell and grab the output, backticks in Julia invoke a mini-parser for it's own safe version of a shell language and they evaluate to a command literal just waiting to be run, never invoking a shell. This talk will go over the details of how command literals are parsed in Julia, what the resulting object looks like, and why the Julia approach to commands is a significant improvement over what shell wrappers in other languages provide (including and especially the POSIX shell itself). Of course, it will also include many examples of how to use command literals effectively. false https://pretalx.com/juliacon2019/talk/VANP8R/ https://pretalx.com/juliacon2019/talk/VANP8R/feedback/ Elm A Lightning Talk 2019-07-24T11:40:00-04:00 11:40 00:10 With Julia v1.0 released, It is time to reflect on what a Julian Julia package is, and why some popular packages such as Optim is not necessarily as Julian as they can be! Based on requests from the community and own experiences, I explain some guiding principles on a complete re-write of the packages in the JuliaNLSolvers organization. juliacon2019-1098-re-designing-optim Patrick Kofod Mogensen en Optim, NLsolve and LsqFit are three packages in the JuliaNLSolvers organization. They have all been around from the early Julia days, and serve some basic scientific computing needs such as minimizing a function, fitting a curve and solving a system of equations. Their age means that they are widely used and well-known. However, their age also show in much of the design and abstractions that predates many of the unique and powerful features and packages in Julia. Based on my own experience as a maintainer of these packages, and learning from the discussions on mailing lists, forums, and github, I will talk about the failures of the three packages, and how a complete rewrite of the packages is the best way forward. Hopefully, my reflections and experiences can help future package writers avoid making the same mistakes over and over again. The talk won't be heavy on the mathematical details, but will explore important things to design for from the start. Users will eventually request many of the features, but they might be difficult to retrofit, so come join the quest to find the best ways of satisfying the greedy Julia users and abusers out there! false https://pretalx.com/juliacon2019/talk/FXU7DC/ https://pretalx.com/juliacon2019/talk/FXU7DC/feedback/ Elm A Lightning Talk 2019-07-24T11:50:00-04:00 11:50 00:10 Julia is increasingly being recognized as one of the big three data science programming languages alongside R and Python. However, Julia’s data ecosystem has had less time to mature when compared to R’s or Python’s. Hence it’s not surprising that some data operations in Julia are slower than their counterparts in R and Python, e.g. group-by. This talk discusses how under-utilized fast sorting methods, such as radix sort, can be used to speed up group-by operations in Julia so that Julia’s group-by operations can match (or even surpass) the speed of optimized C-based group-by implementations in R and Python. juliacon2019-886-towards-faster-sorting-and-group-by-operations /media/juliacon2019/images/AGNHPU/sort_perf_10m100_u_LacbdxS.png Dai ZJ en false https://pretalx.com/juliacon2019/talk/AGNHPU/ https://pretalx.com/juliacon2019/talk/AGNHPU/feedback/ Elm A Talk 2019-07-24T14:30:00-04:00 14:30 00:30 SemanticModels.jl is a library for analyzing scientific and mathematical models written in julia. We apply techniques from program analysis to understand and manipulate scientific modeling code. This allows you to write programs that write novel models. juliacon2019-928-semanticmodels-jl-not-just-another-modeling-framework James FairbanksChristine R Herlihy en SemanticModels is a system for extracting semantic information from scientific code and reconciling it with conceptual descriptions to automate machine understanding of scientific ideas. We represent the connections between elements of code (variables, values, functions, and expressions) and elements of scientific understanding (concepts, terms, relations), to facilitate several metamodeling tasks, including model augmentation, synthesis, and validation. We show how SemanticModels can be used to augment scientific workflows in the epidemiological domain. SemanticModels builds on such great Julia packages as Cassette, Flux, DifferentialEquations, and LightGraphs. It conducts static and dynamic analysis of programs to increase the productivity of scientist-developers. SemanticModels is a complimentary technology to the modeling languages like ModelingToolkit.jl and other DSLs used within the DiffEq ecosystem. false https://pretalx.com/juliacon2019/talk/QFEHQS/ https://pretalx.com/juliacon2019/talk/QFEHQS/feedback/ Elm A Talk 2019-07-24T15:00:00-04:00 15:00 00:30 OmniSci (formerly MapD) is an open-source relational database built from the ground-up to run on GPUs, providing millisecond query speed on multi-billion row datasets. This talk presents OmniSci.jl, the database client for OmniSci written completely in Julia and a basic demonstration of using OmniSci and Julia together, with the aim of encouraging community collaboration on GPU accelerated analytics. juliacon2019-1073-omnisci-jl-bringing-the-open-source-gpu-accelerated-relational-database-to-julia Randy Zwitch en For this talk, I will highlight the work-to-date in bringing the functionality of OmniSci to Julia, and how all of the work of others on packages for geospatial, decimal support, Thrift and Apache Arrow make OmniSci.jl possible. Specifically, I will discuss: * Why OmniSci and Julia are a great fit (performance, LLVM) * Connecting to OmniSci from Julia * Performing basic queries in millisecond speed * Future work towards end-to-end analytics on the GPU in Julia false https://pretalx.com/juliacon2019/talk/MHUAX7/ https://pretalx.com/juliacon2019/talk/MHUAX7/feedback/ Elm A Minisymposia / Extended Presentation 2019-07-24T15:45:00-04:00 15:45 02:00 Polynomial and moment optimization problems are infinite dimensional optimization problems that can model a wide range of problems in engineering and statistics. In this minisymposium we show how the Julia and JuMP ecosystems are particularly well suited for the effortless construction of these problems and the development of state-of-the-art solvers for them. juliacon2019-1071-polynomial-and-moment-optimization-in-julia-and-jump /media/juliacon2019/images/QZBKAU/jump-logo-with-text-600ppi.png Juan Pablo VielmaLea KapelevichChris CoeyTillmann WeisserBenoît Legat en Polynomial and moment optimization problems are infinite dimensional optimization problems that can model a wide range of problems such as shape-constrained polynomial regression, optimal control of dynamical systems, region of attraction, polynomial matrix decomposition, smooth maximum-likelihood density estimation, AC power systems, experimental design, and computation of Nash equilibria. In this minisymposium we show how the [Julia](https://julialang.org) and [JuMP](https://github.com/JuliaOpt/JuMP.jl) ecosystems are particularly well suited for constructing and solving these problems. In particular, we show how the JuMP extensions [SumOfSquares](https://github.com/JuliaOpt/SumOfSquares.jl)/[PolyJuMP](https://github.com/JuliaOpt/PolyJuMP.jl) allow for an effortless construction of these problems and how they provide a flexible and customizable building block for additional packages such as JuliaMoments. We also show how various features of the Julia programming language are used in the state-of-the-art solvers Hypatia.jl and Aspasia.jl. Finally, we showcase specific uses of these tools for applications in engineering and statistics. false https://pretalx.com/juliacon2019/talk/QZBKAU/ https://pretalx.com/juliacon2019/talk/QZBKAU/feedback/ Elm B Talk 2019-07-24T11:00:00-04:00 11:00 00:30 Physician scientists conducting clinical trials are typically not statisticians or computer scientists. Perhaps, in a perfect world, they would be, or more realistically could have statisticians and computer scientists on their research team, but that is often not the case. This leads to what we refer to as the “two-field problem.” Physician-researchers require sophisticated and powerful statistical tools to address complex inferential problems, yet these tools must be intuitive and user-friendly enough not to require advanced statistical knowledge and programming skills. Using Julia, we illustrate the application of Bayesian probabilistic biostatistics to meta-analyses of treatment effects and clinical trials. This combination of Julia and Bayesian methods provides a solution to the “two-field problem.” juliacon2019-1044-probabilistic-biostatistics-adventures-with-julia-from-code-to-clinic Jeff Mills en We know that Julia solves the “two-language problem”: it is both fast and efficient (performance), and easy to use (user friendliness). Using Julia combined with the Bayesian MCMC machinery can solve what we call “the two field problem” in clinical trials, which is that clinical researchers need expertise in more than one field. Medical research - including clinical trials - is frequently conducted by physician researchers who have limited training in inferential statistics and computer programming. Typically, clinical research teams will have a biostatistician, though this may be an MS level individual who performs pre-specified “off the shelf” analyses, and generally is not someone well-versed in Bayesian inferential tools. The prevalence of “five percentitus,” i.e. looking only for and reporting p-values that are “statistically significant” (p<0.05), testifies to this fact. The advances in computing power and capabilities in the last several decades, along with the subsequent developments in Bayesian computational methods, are only just beginning to have an impact on this. As those conducting and funding clinical RCTs recognize the high costs of these studies (e.g., medication expense, time required, and potential exposure of patients to ineffective treatments), there has been greater enthusiasm for (1) improving statistical analytic methods for RCTs, and 2) using evidence-based methods to examine existing naturalistically-collected clinical data to inform clinical practice without the need for RCTs. These approaches require far greater statistical and programming knowledge and sophistication from users. Thus, there is an urgent need to provide statistical tools to clinician-researchers that are intuitive and easy to use, yet sophisticated and powerful enough “under the hood” to answer questions that simpler methods cannot. The “Bayesian machinery” of Markov chain Monte Carlo (MCMC) methods together with Julia offer a solution to this “two-field problem”. They enable exact small sample inference and hypothesis testing for complex models without requiring the restrictive assumptions necessary to obtain analytical tractability (performance), and facilitate the analysis of complex models with basic statistical concepts: frequency distributions, density plots, means, medians, modes, standard deviations, quantiles, and posterior odds (user friendliness). The talk will demonstrate application of this approach using examples from our own research that illustrate our experiences with Bayesian inferential methods for clinical research using Julia. [the number and detail of examples will be modified to suit the length of the talk]. • Reevaluating the evidence from previously conducted RCTs. • Analysis of abandoned trials. • Joint evaluation of tolerability and efficacy in RCTs. • Bayesian hierarchical modeling for meta-analysis evaluating adverse events (“side effects”) in trial participants, and examining the difference between industry and federally sponsored randomized controlled trials. false https://pretalx.com/juliacon2019/talk/M8UDFK/ https://pretalx.com/juliacon2019/talk/M8UDFK/feedback/ Elm B Lightning Talk 2019-07-24T11:30:00-04:00 11:30 00:10 At MIT’s preclinical setting (Preclinical Modeling, Imaging and Testing, PMIT), the available shared biomedical imaging instrumentation, such as magnetic resonance imaging (MRI) or x-ray micro-computed tomography (microCT) scanners, produces diverse and large data sets on a daily basis. The acquisition of an image can be fast or slow depending on the acquisition protocols and whether we are interested in a 2D slice, a 3D volume or a 4D dataset over time. The time from acquisition to visualization of the image heavily depends on the size of the dataset, the image reconstruction algorithm and the computing power available. Although image acquisition and visualization are typically tied to the manufacturer of each specific platform, image quantification is more user dependent and can suffer a significant computational burden when performing non-linear mathematical operations on a pixel-by-pixel basis over millions of high-resolution images. The quantification of an image, namely the extraction of precise numerical information from the image that is representative of a biological process tied to disease and therapy, can take days to derive for users that choose high-level, easy-to-use numerical analysis software. We will present a case study of vast improvements in quantitative image processing of large preclinical MRI datasets using Julia libraries and expand on PMIT’s efforts to develop a Julia-based platform for intelligent preclinical evaluation of therapeutics from their development at bench to their visualization in a living subject. juliacon2019-1804-slow-images-fast-numbers-using-julia-in-biomedical-imaging-and-beyond Virginia Spanoudaki en false https://pretalx.com/juliacon2019/talk/3JUN8D/ https://pretalx.com/juliacon2019/talk/3JUN8D/feedback/ Elm B Lightning Talk 2019-07-24T11:40:00-04:00 11:40 00:10 I will be talking about my work on brain tumour classification using gene expression data, and how Julia as a tool aided this process. juliacon2019-946-brain-tumour-classification-with-julia Amita Varma en In this study, I have taken up a multi-class classification problem in order to distinguish four types of brain tumours from each other, in particular, medulloblastoma, malignant glioma, Atypical Teratoid Rhabdoid Tumor (ATRT), and normal cerebellar. The dataset describes a few thousand genes, and their numerical levels of expression in each tumour sample. The aim of the study is to predict a tumour class, given the gene expression data for that tumour. The insights from this study will be particularly useful, especially for tumours like ATRT which are difficult to diagnose. Survival rates of such types of cancer are considerably higher with an early correct diagnosis. false https://pretalx.com/juliacon2019/talk/U9XTE7/ https://pretalx.com/juliacon2019/talk/U9XTE7/feedback/ Elm B Lightning Talk 2019-07-24T11:50:00-04:00 11:50 00:10 Machine learning for data Mining applications in imbalanced big data classification is very challenging task. In this talk, we have proposed a new cluster-based under-sampling approach with ensemble learning for mining real-life imbalanced big data in Julia. juliacon2019-1050-mining-imbalanced-big-data-with-julia /media/juliacon2019/images/HBBG8N/Farid_-_JuliaCon2019.jpg Dewan Md. FaridSwakkhar Shatabda en In this era of big data, classifying imbalanced real-life data in supervised learning is a challenging research issue. Standard data sampling methods: under-sampling, and over-sampling have several limitations for dealing with big data. Mostly, under-sampling approach removes data points from majority class instances and over-sampling approach engenders artificial minority class instances to make the data balanced. However, we may lose informative information/ instances using under-sampling approach, and under other conditions over-sampling approach causes overfitting problem. In this talk, we have presented a new cluster-based under-sampling approach by amalgamating ensemble learning (e.g. RandomForest classifier) for classification of imbalanced data that we implemented in Julia. We have collected actual illegal money transaction telecom fraud data, which is highly imbalanced with only 8,213 minority class instances amount 63,62,620 instances. The proposed method bifurcates the data into majority class and minority class instances. Then, clusters the majority class instances into several clusters and considers a set of instances from each cluster to create several sub-balanced datasets. Finally, a number of classifiers are generated using these balances datasets and apply majority voting technique for classifying unknown/ new instances. We have tested the proposed method on separate test dataset that achieved 97% accuracy. false https://pretalx.com/juliacon2019/talk/HBBG8N/ https://pretalx.com/juliacon2019/talk/HBBG8N/feedback/ Elm B Talk 2019-07-24T14:30:00-04:00 14:30 00:30 DataKnots is a Julia library for querying data with an extensible, practical and coherent algebra of query combinators. DataKnots is designed to let data analysts and other accidental programmers query and analyze complex structured data. juliacon2019-1027-dataknots-jl-an-extensible-practical-and-coherent-algebra-of-query-combinators /media/juliacon2019/images/HLLDQT/rabbit.png Clark C. Evans en [DataKnots](https://github.com/rbt-lang/DataKnots.jl) implements an algebraic query interface of [Query Combinators](https://arxiv.org/abs/1702.08409). This algebra’s elements, or queries, represent relationships among class entities and data types. This algebra’s operations, or combinators, are applied to construct query expressions. We seek to prove that this query algebra has significant advantages over the state of the art: * DataKnots is a practical alternative to SQL with a declarative syntax; this makes it suitable for use by domain experts. * DataKnots' data model handles nested and recursive structures (unlike DataFrames or SQL); this makes it suitable for working with CSV, JSON, XML, and SQL databases. * DataKnots has a formal semantic model based upon monadic composition; this makes it easy to reason about the structure and interpretation of queries. * DataKnots is a combinator algebra (like XPath but unlike LINQ or SQL); this makes it easier to assemble queries dynamically. * DataKnots is fully extensible with Julia; this makes it possible to specialize it into various domain specific query languages. This talk will provide a conceptual introduction to DataKnots.jl with applications in medical informatics. false https://pretalx.com/juliacon2019/talk/HLLDQT/ https://pretalx.com/juliacon2019/talk/HLLDQT/feedback/ Elm B Talk 2019-07-24T15:00:00-04:00 15:00 00:30 This talk will give a brief overview of the [Queryverse]( https://www.queryverse.org/) functionality and some new features that were added over the last year, and then dive deep into the internal design of [Query.jl]( https://github.com/queryverse/Query.jl), [TableTraits.jl]( https://github.com/queryverse/TableTraits.jl) and many other packages from the [Queryverse]( https://www.queryverse.org/). juliacon2019-972-queryverse-under-the-hood David Anthoff en This talk will start with a quick end-to-end data science example that exercises all parts of the [Queryverse]( https://www.queryverse.org/) (file IO, data manipulation and plotting). I will then briefly introduce a number of new features that were added over the course of the last year (a native Queryverse table type, various new tabular query operators, some new UI tools and the fastest Julia CSV parsing). The bulk of the talk will center on the internal design of [Queryverse]( https://www.queryverse.org/). Topics will include the monadic design of [Query.jl]( https://github.com/queryverse/Query.jl) (inherited from LINQ) that allows us to easily bridge the tabular world with many other julia data structures, the design principles behind [TableTraits.jl]( https://github.com/queryverse/TableTraits.jl) and how it manages to combine extreme simplicity with great performance, the underlying architecture in [Query.jl]( https://github.com/queryverse/Query.jl) that allows full query analysis, rewrites and optimization, and the engineering principles (in terms of backwards compatibility and testing infrastructure) that drive the [Queryverse]( https://www.queryverse.org/). false https://pretalx.com/juliacon2019/talk/QYG3BZ/ https://pretalx.com/juliacon2019/talk/QYG3BZ/feedback/ Elm B Minisymposia / Extended Presentation 2019-07-24T15:45:00-04:00 15:45 02:00 This session aims at discussing/showcasing our experience promoting diversity and inclusion in the US, Brazil, Chile and online, with the help of the Julia Computing Diversity & Inclusion Award, funded by the Sloan Foundation. juliacon2019-1035-raising-diversity-inclusion-among-julia-users Kevin S BonhamElwin van 't WoutAnna Harris en Diversity of users is fundamental for the development of an open language such as Julia. Because it is a young, but very promising programming language, the promotion of working groups that foster the spread of its usage among users from different regions, backgrounds, ages, and social contexts can shed light on bugs and potential growth because of the different perspectives brought with diversity. The Julia Computing Diversity & Inclusion Award funded five projects aimed at promoting the usage of Julia Language with different approaches, in different regions of the planet. In this session, we will share our experience in our projects, talking about how we planned, executed and evaluated the outcomes, and what we learned. For more information about individual projects funded, [see here](https://juliacomputing.com/blog/2018/11/30/DandI-grant-awards.html). false https://pretalx.com/juliacon2019/talk/GRZZBA/ https://pretalx.com/juliacon2019/talk/GRZZBA/feedback/ Room 349 Talk 2019-07-24T11:00:00-04:00 11:00 00:30 Quantum computation is the future of computing. However, writing quantum program can be hard for developers living in a classical world. We developed Yao.jl to help scientists test and explore their quantum ideas in a simple way. juliacon2019-911-yao-jl-extensible-efficient-quantum-algorithm-design-for-humans /media/juliacon2019/images/8AM9JC/logo.png Xiu-zhe (Roger) Luo en ## Introduction Yao is an open source framework for - quantum algorithm design; - quantum [software 2.0](https://medium.com/@karpathy/software-2-0-a64152b37c35); - quantum computation education. ## Motivation Comparing with state of art quantum simulators, our library is inspired by quantum circuit optimization. Variational quantum optimization algorithms like quantum circuit Born machine ([QCBM](https://arxiv.org/abs/1804.04168)), quantum approximate optimization algorithm ([QAOA](http://arxiv.org/abs/1411.4028)), variational quantum eigensolver ([VQE](https://doi.org/10.1038/ncomms5213)) and quantum circuit learning ([QCL](http://arxiv.org/abs/1803.00745)) et. al. are promising killer apps on a near term quantum computers. These algorithms require the flexibility to tune parameters and have well defined patterns such as "Arbitrary Rotation Block" and "CNOT Entangler". In Yao, we call these patterns "blocks". If we regard every gate or gate pattern as a "block", then the framework can * be flexible to dispatch parameters, * cache matrices of blocks to speed up future runs, * allow hierarchical design of quantum algorithms Thanks to Julia's duck type and multiple dispatch features, user can * easily **extend** the block system by overloading specific interfaces * quantum circuit blocks can be dispatched to some **special method** to improve the performance in specific case (e.g. customized repeat block of H gate). ## Features Yao is a framework that is about to have the following features: - **Extensibility** - define new operations with a minimum number of methods in principle. - extend with new operations on different hardware should be easy, (e.g GPUs, near term quantum devices, FPGAs, etc.) - **Efficiency** - comparing with python, julia have no significant overhead on small scale circuit. - special optimized methods are dispatched to frequently used blocks. - double interfaces "apply!" and "cache server + mat" allow us to choose freely when to sacrifice memory for faster simulation and when to sacrifice the speed to simulate more qubits. - **Easy to Use** - As a white-box simulator, rather than using a black box, users will be aware of what their simulation are doing right through the interface. - **Hierarchical APIs** from **low abstraction quantum operators** to **highly abstract** circuit block objects. The whole framework is highly **modularized**, researchers can extend this framework for different purposes. ## Author This project is an effort of QuantumBFS, an open source organization for quantum science. All the contributors are listed in the [contributors](https://github.com/QuantumBFS/Yao.jl/graphs/contributors). false https://pretalx.com/juliacon2019/talk/8AM9JC/ https://pretalx.com/juliacon2019/talk/8AM9JC/feedback/ Room 349 Lightning Talk 2019-07-24T11:30:00-04:00 11:30 00:10 Set computations with interval arithmetic allow us to write surprisingly efficient software for guaranteed unconstrained and constrained global optimisation in pure Julia. juliacon2019-955-guaranteed-constrained-and-unconstrained-global-optimisation-in-julia David P. Sanders en We will show how set computations, using interval-based methods, enable us to find the global minimum for difficult nonlinear, non-convex optimization problems of functions $f:\mathbb{R}^n \to \mathbb{R}$, even when the number of local minima is huge, with guaranteed bounds on the optimum value and on the set of minimizers. We can often also find all stationary points in a given box. We will explain the underlying ideas and some details of the Julia implementation in IntervalOptimisation.jl, which relies on spatial branch and bound, as well as showing examples. We can tackle some "weakly non-convex" functions ranging up to a few hundred variables, whereas highly oscillatory functions can be very challenging even for $n < 10$. For constrained optimization, we apply **constraint propagation**, as implemented in `IntervalConstraintProgramming.jl`, to eliminate infeasible regions and prove the existence of feasible points. We will show how the above techniques are combined to allow efficient and guaranteed calculations for optimization problems. The `CharibdeOptim.jl` package combines these methods with the heuristic Differential Evolution technique to get an efficient global optimisation tool. false https://pretalx.com/juliacon2019/talk/7BKBZJ/ https://pretalx.com/juliacon2019/talk/7BKBZJ/feedback/ Room 349 Lightning Talk 2019-07-24T11:40:00-04:00 11:40 00:10 Pyodide is a project from Mozilla to build a performant scientific Python stack running entirely in the web browser using WebAssembly. juliacon2019-985-pyodide-the-scientific-python-stack-compiled-to-webassembly Michael Droettboom en Unlike the traditional data science interaction model where the web browser only acts as a front end to computation happening on a remote server, Pyodide allows the computation to happen right within the user's web browser. This makes interactivity more performant, and allows easier sharing of notebooks without using potentially costly or privacy-violating cloud services. I hope to present this at JuliaCon as a success story in the hopes that a similar tool can be built for Julia. false https://pretalx.com/juliacon2019/talk/LHU9UM/ https://pretalx.com/juliacon2019/talk/LHU9UM/feedback/ Room 349 Lightning Talk 2019-07-24T11:50:00-04:00 11:50 00:10 High-fidelity battery modeling requires the estimation of numerous physical parameters in order to properly capture the physics of the electrochemical, thermodynamic and chemical processes that underlie the system. Using Julia, the parameters for this model were able to be estimated by speeding up the code such that a Markov Chain Monte Carlo approach (Hamiltonian Monte Carlo) could be used, combined with a high-performance computing cluster, to sample the vast search domain and reach the global error minima. juliacon2019-929-julia-for-battery-model-parameter-estimation Matthew GuttenbergShashank SripadVenkat ViswanathanWilliam L Fredericks en The particular battery model employed in this application predicts the voltage, temperature, state-of-charge, and degradation (i.e. lithium lost due to aging factors). Due to the complex interactions among these properties --- along with other dynamic, codependent cell properties --- the behavior of the cell over the course of an arbitrary load cannot be accurately characterized from an initial state without simulating these interactions over time. As a result, the model implementation discretely progresses the cell through discharge and charge using a time-step of 2 seconds, predicting forward the state properties. The only time-dependent input is a load profile, which can come in the form of the power over time or current over time associated with the discharge due to the load and charging protocol. Beyond that, user inputs are only required for the initial cell state. Looking at an individual step, the mole fraction of lithium in different parts of the cell is found using either the initial conditions or the prediction from a prior step. Calculating the open circuit potential for both the anode and cathode depends on these mole fractions and the current cell temperature. Following this step the mole fractions for the next state are calculated by approximating their rate of change, which relies on the input current, and multiplying the rate by the 2-second time-step. The state-of-charge for the next step is also calculated at this point. The cell voltage depends on a set of overpotentials on top of the open circuit potential already estimated. As with the mole fractions, these come from initial conditions or a previous step. To predict the overpotentials for the next state, properties from the current state are used to calculate the current rate of change, which is then multiplied by the time-step. Temperature is predicted for the next state in a similar manner, as is the cell voltage. The computational challenge derives in part from the vast parameter space necessary to characterize the model to a real cell based on testing data. The model depends on roughly 20 parameters for a single discharge-charge cycle to predict the state over time. On top of this, keeping track of cell degradation requires an additional 5 parameters. Working from the state-of-charge model described above, a state-of-health model can be set up using these additional parameters and running the discharge model for hundreds of cycles, updating the input parameters at the beginning of each cycle. At each state during an individual cycle, the amount of lithium lost either to reactions with the electrolyte or isolation into inactive lithium metal is added to a running total for the cycle. After a cycle completes, this total is removed from the initial lithium available to the cell. Resistance and diffusivity also change over multiple cycles, and the contribution to their decay is also maintained as a running total within each cycle. Since local minima are pervasive in this parameter space, and error-minimizing strategies are too strongly influenced by initial guesses, a Monte Carlo implementation is necessary to properly train the model. This becomes prohibitively expensive computationally within Matlab, where the model was first implemented, because each cycle lasts for up to 10,000 seconds, and up to 2,000 cycles can be required to compare the aging model to the available aging data. The search space defined by the parameters requires that the Monte Carlo be able to perform several thousand iterations. Under the Matlab implementation, each Monte Carlo iteration would take approximately 0.03 seconds. This means that the algorithm can do 1 million iterations in 500 minutes or about 8 hours. While this seems sufficient, there are 20 parameters which means that on average, there are only 50,000 changes to each variable which is likely not enough iterations per variable to properly sample the space. In addition, more complex Monte Carlo models such as the Hamilton Monte Carlo take significantly more time to run, thus limiting the number of iterations that can be run. By implementing the same code in Julia, the algorithm got a significant speed up in addition to other benefits. Compared to the Matlab implementation, the Julia implementation had one Monte Carlo iteration complete in about 0.003 seconds. This means that there was a 10X speed up, allowing for 10X more iterations to be completed in the same time. Thus, in about 8 hours, 10 million Monte Carlo iterations could be performed. In addition, Julia enabled the code to be run in parallel on Arjuna, a high-performance computing cluster at Carnegie Mellon University. This means that in 8 hours, several of these algorithms can be run in parallel in which each performs a phase space search using 10 million iterations. Since each algorithm has enough iterations to properly sample the space, the minimum error found from the collection of Monte Carlo simulations can be assumed to be the global minimum of the search space. The large amount of Monte Carlo iterations also allows for the algorithm to use a simulated annealing function to allow the algorithm to not get stuck in local minima. false https://pretalx.com/juliacon2019/talk/JYLQ8H/ https://pretalx.com/juliacon2019/talk/JYLQ8H/feedback/ Room 349 Talk 2019-07-24T14:30:00-04:00 14:30 00:30 This talk will provide an overview of the Federal Reserve Bank of New York's heterogeneous agent dynamic stochastic general equilibrium (DSGE) model development process in Julia, walking through our navigation of Julia-specific functionality in the process. Comparisons of performance relative to MATLAB and FORTRAN will be provided. juliacon2019-991-heterogeneous-agent-dynamic-stochastic-general-equilibrium-dsge-models-in-julia-at-the-federal-reserve-bank-of-new-york Rebecca Sarfati en **Abstract:** Over the past few decades, income and wealth inequality have emerged as defining fixtures of the modern U.S. economy. Born of a desire to study the differential effects of policy decisions on a variegated group of economic actors, heterogeneous agent (HA) models enable researchers to incorporate critical differentiation in household income, wealth, and consumption behavior into their analyses of economic phenomena. Yet, while great academic progress has been made developing such models, many policy institutions have been slow to shift from the “representative agent” paradigm. This is due, in large part, to computational strain surrounding HA models' solution and estimation. However, thanks to speed gains made possible by innovations in computing languages like Julia, what was once too computationally taxing for policy purposes has become both feasible to run and elegant to implement. This talk will provide an overview of the Federal Reserve Bank of New York's (NY Fed) HA dynamic stochastic general equilibrium (DSGE) model development process in Julia, walking through our navigation of Julia-specific functionality in the process. Comparisons of performance relative to MATLAB and FORTRAN will be provided. **Description:** Heterogeneous agent models, in contrast to representative agent models, allow for heterogeneity in various features among agents in an economy, at both the household and firm level. Examples of such heterogeneity might include age, risk-tolerance, skills, and discounting of the future --- features that manifest themselves in heterogeneity in the wealth distribution. Recent work in macroeconomic literature reveals the monetary and fiscal policy implications for HA models can differ widely from their representative counterparts. Such models may be implemented in either discrete or continuous time, posing challenges for their intuitive out-of-the-box deployment as well as succinct tailoring of model-specific solution methods. The solving of large-scale macroeconomic models is sufficiently complex in the representative agent case; the dimensionality of problems increases considerably with the addition of heterogeneity, especially in continuous-time, lending itself well to Julia’s strengths. In the past year, our team has ported several HA models—along with algorithms to discretize, linearize, and solve them—from both MATLAB and FORTRAN for integration into our codebase. package. This addition comes at the heals of the release of our [DSGE.jl](https://github.com/FRBNY-DSGE/DSGE.jl) package, whose other components, such as representative agent model solution, estimation, and forecasting, were the subject of past presentations at JuliaCons 2016-2018. I will discuss the respects Julia has provided us technical flexibility in constructing coherent type hierarchies, employing multiple dispatch, and utilizing distributed computing, as well as how we managed various design decisions pertaining to variable scope, typing, and parallelization, so as to optimize for memory usage and runtime. I will cover the technical constraints and considerations imposed by our production environment at the NY Fed, and offer advice for what we found accommodated our cluster setup. Finally, I will shed light on how HA models may expand the toolkit for policymakers and academics. Disclaimer: This talk reflects the experience of the author and does not represent an endorsement by the Federal Reserve Bank of New York or the Federal Reserve System of any particular product or service, The views expressed in this talk are those of the authors and do not necessarily reflect the position of the Federal Reserve Bank of New York or the Federal Reserve System. Any errors or omissions are the responsibility of the authors. false https://pretalx.com/juliacon2019/talk/K9BBNX/ https://pretalx.com/juliacon2019/talk/K9BBNX/feedback/ Room 349 Talk 2019-07-24T15:00:00-04:00 15:00 00:30 Medium-large Dynamic Stochastic General Equilibrium models such as those used for forecasting and policy analysis by central banks take a substantial amount of time to estimate using standard approaches such as Random Walk Metropolis Hastings. Our new Sequential Monte Carlo sampler in DSGE.jl makes it possible to estimate DSGE models in parallel, reducing computational time, and “online,” that is efficiently including new data in the estimation as they become available. juliacon2019-944-online-estimation-of-macroeconomic-models Ethan Matlin en In this talk, I will present DSGE.jl’s new Sequential Monte Carlo (SMC) sampler. SMC is a method of generating draws from a posterior distribution when direct sampling is not possible. In the past, modern macroeconomists have used Random Walk Metropolis Hastings for this purpose, however as our models have become more complex, Metropolis Hastings’ shortcomings have become more apparent: the algorithm produces serially correlated draws, has difficulties characterizing multimodal distributions, is slow and unable to be parallelized, and interfaces poorly with new data arrivals. SMC resolves these problems. Instead of starting from scratch with every new piece of information, we initialize the sampling algorithm at the entire posterior distribution of an older estimation. This “online estimation” allows frequent re-estimation of our models as new data become available rather than waiting months for enough new data to justify a full re-estimation. The algorithm is fast and parallelizable, reducing runtimes from days to just hours. These massive speedups make possible estimation of a new class of heterogenous agent models (which are simply infeasible to estimate using Metropolis Hastings) and allow more rigorous forecast evaluations (by allowing us to estimate a larger suite of comparison models on different data). I will discuss lessons learned regarding parallelization and improvements we’ve made to the algorithm including parameter blocking, utilization of the Chandrasekhar recursions for likelihood evaluation, and fully-adaptive hyper-parameter tuning (allowing the algorithm to flexibly accommodate the business cycle: it spends more time exploring the distribution when economic conditions are novel than when conditions are similar to those in the past). Our SMC methods may prove useful to any Julia users who conduct Bayesian estimation, and many of our developments can also be easily applied to alternative applications. Finally, I will present comparative performance benchmarks of the algorithm in Matlab, FORTRAN, and Julia and discuss approaches we’ve taken to optimize code performance. Disclaimer: This talk reflects the experience of the author and does not represent an endorsement by the Federal Reserve Bank of New York or the Federal Reserve System of any particular product or service. The views expressed in this talk are those of the authors and do not necessarily reflect the position of the Federal Reserve Bank of New York or the Federal Reserve System. Any errors or omissions are the responsibility of the authors. false https://pretalx.com/juliacon2019/talk/N3BKPS/ https://pretalx.com/juliacon2019/talk/N3BKPS/feedback/ Room 349 Talk 2019-07-24T15:45:00-04:00 15:45 00:30 Explore Flux's brand-new compiler integration, and how this lets us turn anything in the Julia ecosystem into a machine learning model. juliacon2019-962-differentiate-all-the-things /media/juliacon2019/images/JPNYCR/logo.png Mike Innes en Last JuliaCon I announced the [Zygote](https://github.com/FluxML/Zygote.jl) tool for analytical differentiation (AD) of Julia code. Flux has now uses Zygote as its default AD,* enabling both a more elegant interface and all kinds of new models that weren't possible before. Flux's new APIs are powerful and let us easily express advanced concepts like backpropagation through time. But really, Julia's power is in its awesome open-source ecosystem, with state of the art tools for differential equations, mathematical optimisation, and even colour theory! Come and see how we can take advantage of all of these tools in machine learning models, enabling "theory-driven" ML to tackle harder problems than ever. * In theory; I write this from 4 months in the past, so who knows. false https://pretalx.com/juliacon2019/talk/JPNYCR/ https://pretalx.com/juliacon2019/talk/JPNYCR/feedback/ Room 349 Lightning Talk 2019-07-24T16:15:00-04:00 16:15 00:10 RayTracer.jl is a package designed for differentiable rendering. In this talk, I shall discuss the inverse graphics problem and how differentiable rendering can help solve it. Apart from this we will see how differentiable rendering can be used in differentiable programming pipelines along with neural networks to solve classical deep learning problems. juliacon2019-977-differentiable-rendering-and-its-applications-in-deep-learning Avik Pal en false https://pretalx.com/juliacon2019/talk/JGY7KC/ https://pretalx.com/juliacon2019/talk/JGY7KC/feedback/ Room 349 Lightning Talk 2019-07-24T16:25:00-04:00 16:25 00:10 This talk will demonstrate the models described in [Neural Ordinary Differential Equations](https://arxiv.org/pdf/1806.07366.pdf) implemented in DiffEqFlux.jl, using DifferentialEquations.jl to solve ODEs with dynamics specified and trained with Flux.jl. juliacon2019-1102-neural-ordinary-differential-equations-with-diffeqflux Jesse Bettencourt en This talk will demonstrate models described in [Neural Ordinary Differential Equations](https://arxiv.org/pdf/1806.07366.pdf) implemented in DiffEqFlux.jl, using DifferentialEquations.jl to solve ODEs with dynamics specified and trained with Flux.jl. In particular it will show how to use gradient optimization with the adjoint method to train a neural network which parameterizes an ODE for supervised learning and for Continuous Normalizing Flows. These demonstrations will be contributed to the Flux model-zoo. The supervised learning demonstration will illustrate that neural ODEs can be drop-in replacements for [residual networks](https://arxiv.org/pdf/1512.03385.pdf) on supervised tasks such as image recognition. The Continuous Normalizing Flow demo will show how a neural ODE, with the instantaneous change of variables, can learn a continuous transformation from tractable base distribution to a distribution over data which can be sampled from and evaluate densities under. false https://pretalx.com/juliacon2019/talk/HANGXH/ https://pretalx.com/juliacon2019/talk/HANGXH/feedback/ Room 349 Talk 2019-07-24T16:35:00-04:00 16:35 00:30 Neural Ordinary Differential Equations (neural ODEs) are a brand new and exciting method to model nonlinear transformations as they combine the two fields of machine learning and differential equations. In this talk we discuss DiffEqFlux.jl, a package for designing and training neural ODEs, and we introduce new methodologies to improve the efficiency and robustness of neural ODEs fitting. juliacon2019-1031-fitting-neural-ordinary-differential-equations-with-diffeqflux-jl Elisabeth Roesch en A [neural Ordinary Differential Equation](https://arxiv.org/abs/1806.07366) (ODE) is a differential equation whose evolution equation is a neural network. We can use neural ODEs to model nonlinear transformations by directly learning the governing equations from time course data. Therefore, neural ODEs present a novel method for modelling time series in an elegant manner as they allow us to use sophisticated differential equations solving procedures in the field of machine learning, an area of already high and still increasing demand. In this talk we discuss [DiffEqFlux.jl](https://arxiv.org/abs/1902.02376), a package for designing and training neural ODEs. We demonstrate how to fit neural ODEs against data by using the L2 loss function, and explain how Julia's automatic differentiation is used to calculate the gradients through the differential equation solvers to compute the gradients of the loss function. While this is the "standard" method, it involves solving an ODE at each step of the optimization which can be very time consuming. Thus, we introduce new methodologies available in DiffEqFlux.jl, to improve the efficiency and robustness of the fitting. First, we demonstrate new functionalities provided by a bridge to the [two stage collocation method](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2631937/ ) of the package [DiffEqParamEstim.jl](https://docs.juliadiffeq.org/latest/analysis/parameter_estimation.html). Second, we show how to effectively use these functions in a mixed training loop to improve the speed and robustness of the fitting. Third, we demonstrate and explain a new loss function in DiffEqFlux.jl which allows for multiple shooting, and show its performance characteristics. Together, these three features improve the performance and robustness of the fitting process of neural ODEs in Julia and, thus, allow it to scale to more practical models and data. false https://pretalx.com/juliacon2019/talk/KGHF7T/ https://pretalx.com/juliacon2019/talk/KGHF7T/feedback/ Room 349 Lightning Talk 2019-07-24T17:05:00-04:00 17:05 00:10 Randomized sketching algorithms are a powerful tool for on-the-fly compression of matrices. In this talk we show how sketching can be used for approximate gradient and hessian-times-vector computations that are storage optimal. This approach gives cutting-edge low memory algorithms to address the challenge of expensive storage in optimization problems with PDE constraints. We also discuss implications for efficient adjoint computation/back-propagation. juliacon2019-1095-randomized-sketching-for-approximate-gradients-applications-to-pde-constrained-optimization Ramchandran Muthukumar en This work is motivated by the challenge of expensive storage in optimization problems with PDE constraints e.g. optimal flow control, full waveform inversion, optical tomography etc. These optimization problems are characterized by PDE constraints that uniquely determine the state of a physical system for a given control. The state matrix is typically much more expensive to store than the control matrix. The optimization algorithms effects changes in the control that move a physical system towards optimal behavior. Any first or second order algorithm requires gradient computation. As a first step we have to solve the PDE and store its solution and this is a storage bottleneck. Recently randomized algorithms have been developed for matrix approximation and Sketching is a high-performance algorithm for on-the-fly compression of matrices. We demonstrate how sketching can be used to compute approximate gradients and hessian-times-vector quantities while avoiding the storage bottleneck caused by the PDE solution. This cutting-edge algorithmic recipe has been applied successfully for linear parabolic boundary control and optimal fluid flow. We also explore its implications for efficient adjoint computation or back-propagation. false https://pretalx.com/juliacon2019/talk/ZDRQQA/ https://pretalx.com/juliacon2019/talk/ZDRQQA/feedback/ Room 349 Lightning Talk 2019-07-24T17:25:00-04:00 17:25 00:10 Using Julia and Flux.jl, we want to show how we have applied modern neural architectures like Mask RCNN and Inception to identify diseases and slums in metropolitan cities. juliacon2019-1083-machine-learning-for-social-good Dhairya Gandhi en ML has provided us with the tools to think of data as a source of insight. It isn’t a stretch to apply the same thinking towards some of the most pressing socio economic calamities we as a society are faced with. Mask RCNN is a state of the art object detection and segmentation net that was developed by FAIR and has shown tremendous leaps in terms of segmentation while being conceptually simple. We present an all-Julia Flux implementation of Mask RCNN and our methodology of setting up the segmentation task. We use satellite images of cities and try to identify regions where slums exist. Finally we share our results of our findings. Code: The code is currently private before it is released openly through contributions to various existing projects like the Flux model-zoo and Metalhead.jl. false https://pretalx.com/juliacon2019/talk/KJ9SGA/ https://pretalx.com/juliacon2019/talk/KJ9SGA/feedback/ NS Room 130 Keynote 2019-07-24T08:40:00-04:00 08:40 00:45 Steven G. Johnson is a Professor of Applied Mathematics and Physics at MIT, where he joined the faculty in 2004 and previously received a PhD in physics (2001) and BS degrees in physics, mathematics, and computer science (1995). He has a long history of contributions to scientific computation and software, including the [FFTW](http://www.fftw.org) fast Fourier transform library (for which he co-received the 1999 J. H. Wilkinson Prize) and many other software packages. He has been using, contributing to, and teaching with Julia since 2012. He created and maintains blockbuster Julia packages that you may have heard of: [PyCall](https://github.com/JuliaPy/PyCall.jl) and [IJulia](https://github.com/JuliaLang/IJulia.jl) (and Julia’s [FFTW bindings](https://github.com/JuliaMath/FFTW.jl), of course). Professor Johnson's professional research concerns wave-matter interactions and electromagnetism in media structured on the wavelength scale (“nanophotonics”), especially in the infrared and optical regimes. He works on many aspects of the theory, design, and computational modeling of nanophotonic devices, both classical and quantum. He is also a coauthor on over 200 papers and over 30 patents in this area, including the textbook *Photonic Crystals: Molding the Flow of Light*. juliacon2019-2562-keynote-professor-steven-g-johnson Professor Steven G Johnson en false https://pretalx.com/juliacon2019/talk/DRP3EF/ https://pretalx.com/juliacon2019/talk/DRP3EF/feedback/ NS Room 130 Sponsor's Address 2019-07-24T09:30:00-04:00 09:30 00:15 An address from our sponsor. juliacon2019-2567-sponsor-address-j-p-morgan-chase-co /media/juliacon2019/images/JHZRJS/jpmorgan1_dcVnHXn.png Jiahao Chen en false https://pretalx.com/juliacon2019/talk/JHZRJS/ https://pretalx.com/juliacon2019/talk/JHZRJS/feedback/ NS Room 130 Sponsor's Address 2019-07-24T09:45:00-04:00 09:45 00:05 An address from one of our sponsors. juliacon2019-2568-sponsor-address-julia-computing /media/juliacon2019/images/CYJRTK/julia1_jEsjh8N.png Stefan Karpinski en false https://pretalx.com/juliacon2019/talk/CYJRTK/ https://pretalx.com/juliacon2019/talk/CYJRTK/feedback/ NS Room 130 Lightning Talk 2019-07-24T09:50:00-04:00 09:50 00:10 As a product of the academic community, Julia has been developed with certain assumptions relating to source code availability and access. In secure environments, however, access to public (and even private) package repositories can be deliberately limited. It is still possible to use Julia in these environments: this talk will provide an overview of the challenges in deploying Julia in secure/controlled environments and discuss lessons learned from a real-world deployment on a secure system. juliacon2019-939-using-julia-in-secure-environments Seth Bromberger en This talk stems from the author's (eventually successful) attempt to deploy Julia along with associated packages on a secure network. Last year there was a fairly long discourse thread on this subject; this talk will serve as a followup to the initial attempts and will discuss lessons learned and advice for those seeking to use Julia in restricted environments. false https://pretalx.com/juliacon2019/talk/JANJFM/ https://pretalx.com/juliacon2019/talk/JANJFM/feedback/ NS Room 130 Keynote 2019-07-24T13:30:00-04:00 13:30 00:45 Arch D. Robison is a Principal Systems Software Engineer at NVIDIA, where he works on [TensorRT](https://developer.nvidia.com/tensorrt), NVIDIA's platform for high-performance deep-learning inference. He was the lead developer for KAI C++, the original architect of Intel Threading Building Blocks, and one of the authors of the book *Structured Parallel Programming: Patterns for Efficient Computation*. Arch contributed type-based alias analysis and vectorization support to Julia, including the original implementation of [SIMD in Julia 0.3](https://software.intel.com/en-us/articles/vectorization-in-julia). He's used Julia to generate [x86 assembly language](https://software.intel.com/en-us/articles/vectorization-in-julia) for a Go implementation of his video game *Frequon Invaders*. He also took 2nd place in AI Zimmermann's contest &quot;Delacorte Numbers&quot; [using Julia exclusively](https://software.intel.com/en-us/articles/computing-delacorte-numbers-with-julia). He has 21 patents and an Erd&ouml;s number of 3. juliacon2019-2563-keynote-arch-d-robison Arch D. Robison en false https://pretalx.com/juliacon2019/talk/PKLBXV/ https://pretalx.com/juliacon2019/talk/PKLBXV/feedback/ BoF: Room 353 Birds of Feather 2019-07-24T11:00:00-04:00 11:00 01:00 As the Julia community grows and becomes core tooling to many scientists and businesses, sustainably keeping members of the community as developers of free software developers is vital to the health of the ecosystem. In this discussion we will talk about the various ways we ourselves are funding or have been funded for Julia-based open source software development, and hypothesize alternative methods such as crowdfunding. juliacon2019-1204-sustainable-development-and-open-source-monetization Clark Evans en true https://pretalx.com/juliacon2019/talk/EKN9AD/ https://pretalx.com/juliacon2019/talk/EKN9AD/feedback/ BoF: Room 353 Birds of Feather 2019-07-24T14:30:00-04:00 14:30 01:00 We’ll have a birds of a feather session to discuss and brainstorm diversity and inclusion in the Julia community. All are welcome! juliacon2019-965-diversity-and-inclusion-in-julia-community Kelly ShenNathan Daly en JuliaCon 2018 was the most diverse JuliaCon yet. Though the success of this event demonstrated progress in the diversity and inclusivity of our community, the continued underrepresentation of individuals identifying as female or as racial/ethnic minorities, for example, indicates that we have a long way to go. As greater language stability increases the confidence of our community members to recruit new users and to invest further in the language and its community, interest in diversity efforts tied to the language seem to be gaining momentum. We would like to hold a birds of a feather session to discuss and brainstorm diversity and inclusion in the Julia community. true https://pretalx.com/juliacon2019/talk/PSAX8D/ https://pretalx.com/juliacon2019/talk/PSAX8D/feedback/ BoF: Room 353 Birds of Feather 2019-07-24T15:45:00-04:00 15:45 01:00 A casual chat about the virtues and concerns relating to running julia in a production enviroment. juliacon2019-2629-julia-in-production Curtis Vogt en true https://pretalx.com/juliacon2019/talk/B38TDU/ https://pretalx.com/juliacon2019/talk/B38TDU/feedback/ BoF: Room 353 Birds of Feather 2019-07-24T16:45:00-04:00 16:45 00:50 A discussion of the Julia GPU ecosystem juliacon2019-2632-juliagpu Valentin ChuravyTim Besard en true https://pretalx.com/juliacon2019/talk/BACLJQ/ https://pretalx.com/juliacon2019/talk/BACLJQ/feedback/ Other Break 2019-07-24T07:30:00-04:00 07:30 01:00 Breakfast will be held in the SMC 2nd Floor Lobby juliacon2019-2592-breakfast en false https://pretalx.com/juliacon2019/talk/VXFNVA/ https://pretalx.com/juliacon2019/talk/VXFNVA/feedback/ Other Break 2019-07-24T10:10:00-04:00 10:10 00:50 The poster session will be held in room 349 juliacon2019-2608-poster-session en Posters: - "AMLET meets Julia" by Bastin, Fabian - "JuliaDB: solving the two language problem in analytical databases" by Shashi Gowda - "Mapping the Logic Item Domain with Julia" by Francis Smart - "OrthogonalPolynomials.jl - Optimal evaluation of orthogonal polynomials in ~ 100 lines of Julia" by Miguel Raz Guzmán Macedo - "Oceananigans.jl: fast, friendly, architecture-agnostic, high-performance ocean modeling" by Ali Ramadhan - "Parallel Scenario Decomposition of Stochastic Programming" by Kibaek Kim - "ARCH Models in Julia" by Simon Broda - "Myths, Legends, and Other Amazing Adventures in CSV Parsing" by Jacob Quinn - "Occasionally Binding Constraints in DSGE Models in Julia" by Vivaldo Mendes - "Time Series Analysis and Forecasting with Julia: Nonlinear Autoregressive vs Machine Learning Models" by Diana A. Mendes - "Julia applied in the Factory of the Future" by Thijs Van Hauwermeiren - "NLPeterman.jl: Language processing from the ground up in Julia" by Mihir Paradkar - "Materials.jl for crystal plasticity" by Ivan Yashchuk - "Markov Chain-Monte Carlo Methods for Linear Algebra using Julia v.1.0" by Oscar A. Esquivel-Flores - "Modelling environment for JuliaOpt" by Manuel Marin - "BuyLibre - Cooperative Libre Software Cost-Sharing" by Clark C. Evans - "StateSpaceModels.jl -- A Julia package for time-series analysis in a state-space framework" by Raphael Saavedra - "TileDB: a data management solution tailored for data scientists" by Jake Bolewski - "Growing Machine Learning Solutions on Kubernetes with Julia" by Patrick Barker - "Econometrics.jl for econometric analysis in Julia" by José Bayoán Santiago Calderón - "Bioequivalence Analysis in Julia using Bioequivalence.jl" by José Bayoán Santiago Calderón - "Tackling Stochastic Delay Problems in Julia" by Henrik Sykora - "Julia Web Apps with Mux.jl + Heroku" by Josh Day - "A New Approach of Genre-Based Similarity for User-UserCollaborative Filtering Recommender System" by Mahamudul Hasan - "Real Time Mapping of Epidemic Spread, predict with SIR, Neural Network in Julia" by Rahul Kulkarni ### Info for presenters (This matches the email you've all been sent) We will have two poster sessions during the morning coffee breaks on Wednesday, July 24 and Thursday, July 25 from 10:10AM to 11AM in room 349. Please hang your poster in room 349 by 8:30AM on Wednesday and plan to present during both sessions. If you are unable to present on both days, please let us know. The poster boards provided will be landscape (3 feet by 4 feet) false https://pretalx.com/juliacon2019/talk/TCVVZN/ https://pretalx.com/juliacon2019/talk/TCVVZN/feedback/ Other Break 2019-07-24T12:00:00-04:00 12:00 01:15 Lunch will be held in the SMC 2nd Floor Lobby juliacon2019-2588-lunch en false https://pretalx.com/juliacon2019/talk/YCGCVE/ https://pretalx.com/juliacon2019/talk/YCGCVE/feedback/ Other Break 2019-07-24T15:30:00-04:00 15:30 00:15 A short break between sessions juliacon2019-2611-short-break en false https://pretalx.com/juliacon2019/talk/PEY7CR/ https://pretalx.com/juliacon2019/talk/PEY7CR/feedback/ Elm A Talk 2019-07-25T11:00:00-04:00 11:00 00:30 Julia and JavaScript come together like peanut butter and chocolate This talk is an overview of the JuliaGizmos ecosystem. It starts with the basics of creating a simple page, showing it in various forms, to Interact.jl and beyond. I will present work done by many people that have been aggregated in this github niche, mainly that of Mike Innes, Pietro Vertechi, Joel Mason, Travis DePrato, Sebastian Pfitzner and myself. juliacon2019-964-julia-javascript-3 Shashi Gowda en This talk is an overview of the JuliaGizmos ecosystem. It starts with the basics of creating a simple page, showing it in various forms, to Interact.jl and beyond. I will present work done by many people that have been aggregated in this github niche, mainly that of Mike Innes, Pietro Vertechi, Joel Mason, Travis DePrato, Sebastian Pfitzner and myself. •••••••••••••• Outline of the talk: 1. Showing any Julia object, serving it on a web server 2. Executing and talking to JavaScript: the `@js` syntax 3. Interact.jl -- past and future 4. Syntax: Building your own JavaScript based library with seamless Julia bindings 5. Deploying a native-looking app as a Julia script 6. A brief update on (other people's) work on transpiling Julia to JS. A common question we get asked on Slack is -- "is there a replacement for R's shiny in Julia?". The answer is YES, and you can help us build it out! false https://pretalx.com/juliacon2019/talk/7SDCJU/ https://pretalx.com/juliacon2019/talk/7SDCJU/feedback/ Elm A Lightning Talk 2019-07-25T11:30:00-04:00 11:30 00:10 We present our experience in deploying Julia web servers in production systems. We developed a custom buildpack that facilitates deploying web servers on Heroku. It is built so that any application requires almost no special code to be deployed. juliacon2019-1078-julia-web-servers-deployment Amgad NaiemMohammed El-Beltagy en ##Julia web servers deployment To deploy Julia web servers easily, we developed an open-source buildpack which is available on https://github.com/Optomatica/heroku-buildpack-julia. It just requires `Project.toml` and `Manifest.toml` in the root of the repository to be pushed and it automatically download dependencies and make the server available on [Heroku](https://heroku.com). It also precompiles all dependencies for speedy server boot time. We will present our experience in making this buildpack and how we optimized it so that the web server boot time is minimized. We compare its performance with having a docker instance and it outperforms having a docker image and it requires less maintenance overhead than having a docker image. This can help many Julia users deploying web servers in no time. false https://pretalx.com/juliacon2019/talk/L983HR/ https://pretalx.com/juliacon2019/talk/L983HR/feedback/ Elm A Lightning Talk 2019-07-25T11:40:00-04:00 11:40 00:10 [Timelineapp.co](https://timelineapp.co) is an on-line platform for financial planners. Recently its core compute engine has been migrated to the Julia language. In this talk we discuss the reasons and benefits of this decision. juliacon2019-1047-a-case-study-of-migrating-timelineapp-co-to-the-julia-language /media/juliacon2019/images/YPGRDD/timelineapp.png Bogumił Kamiński en [Timelineapp.co](https://timelineapp.co) is a platform that supports financial planners in analysis of different retirement income strategies. It interactively allows a user to specify the desired retirement income management plan and performs its backtesting to verify its profitability and risk profile. It shows the impact of asset allocation decisions, rebalancing, fees, and taxes and it prepares clients for market ups and downs. The legacy development process at Timelineapp was that quantitative analysts specified application logic using Matlab and next software developers translated it to Elixir code that was deployed to production. As the application complexity increased, even trying to squeeze out maximum performance from the legacy technology stack, the team faced the challenge that the response time per one financial scenario backtesting query would grow up to around 40 seconds. This was clearly not acceptable for an on-line application. Facing performance bottleneck the team researched different alternatives, did some benchmarks, and picked Julia. After migrating the code, it was possible to cut the time to response down to 0.6 second per query. Another benefit of moving to Julia was a dramatic simplification of the development process. In the past Matlab code had to be translated to Elixir. That was quite cumbersome and many times things got lost in translation from one programming language to the other. Now both, the quantitative analysts and the developers, write Julia. This way the code has less bugs and the time from idea and experimental calculations (by the quantitative analysts team) to deployment to production (by the software development team) is much shorter and agile. false https://pretalx.com/juliacon2019/talk/YPGRDD/ https://pretalx.com/juliacon2019/talk/YPGRDD/feedback/ Elm A Talk 2019-07-25T14:30:00-04:00 14:30 00:30 "This block will compile away," the comments say. _But will it?_ In this talk we'll see some scenarios where controlling compile-time vs runtime execution is crucial for performance, and we'll discuss some ideas that might make this control easier in Julia. juliacon2019-1085-if-runtime-isn-t-funtime-controlling-compile-time-execution Nathan Daly en Julia's ability to compile away complex logic is remarkable. Especially in recent releases, Const-propagation is a thing to behold! But we've found it can be hard to reason about _why_ some operations are compiled away (or why they aren't), and even harder to _control_ that behavior. What's more, that behavior can change as your code evolves, or Julia is updated, and it's difficult to test. In Julia, the distinction between compile-time and runtime is deliberately muddy: compilation itself happens _during runtime_; a function may be compiled once, many times or never—it might even be compiled more times than it runs. Still, there are cases where we expect a function to be compiled once, early on, and then need it to run extremely quickly, many times, in a tight loop, where controlling the ability to move work from runtime to compile-time is critical. This talk will explore a few such motivating cases we've seen at [RelationalAI](http://relational.ai), including in pieces of the [FixedPointDecimals.jl](https://github.com/JuliaMath/FixedPointDecimals.jl) library. We'll examine the options currently available in Julia for controlling compile-time execution, and their pros and cons, including some lessons-learned about the pain we've experienced with `@generated`. We'll study the approach modern C++ is taking to this problem, with its `constexpr` annotation. And we'll propose a few ideas for how we might add features to Julia that could increase our control over this fierce compiler. false https://pretalx.com/juliacon2019/talk/QXF9AM/ https://pretalx.com/juliacon2019/talk/QXF9AM/feedback/ Elm A Talk 2019-07-25T15:00:00-04:00 15:00 00:30 Transducers are composable algorithms that operate on collections of inputs. This concept is first introduced in Clojure language by Rich Hickey for a fully reusable code for mapping, filtering, concatenation, and similar operations that can be modeled a succession of steps. By this nature, transducers superficially look like iterators that are used by the majority of programming languages for a similar purpose. However, the protocol used by transducers is quite different from iterators and results in different characteristics: (1) Transducers are driven by a "generalized" [`foldl`](https://docs.julialang.org/en/v1.1/base/collections/#Base.foldl-Tuple{Any,Any}) function. It can implement a specialized looping strategy that is most friendly to the way the data is laid out in memory for a given collection (e.g., two nested loops for vector-of-vectors). (2) Some transducers like `Map`, `Filter`, `Cat` and `Scan` can support parallel execution. Importantly, this is done without re-writing any of the code for those transducers. (3) The code composed by transducers is close to the way code is written manually using raw loops. It seems to result in a good machine code generation. This also means that enabling SIMD using the `@simd` macro is straight forward. In this talk, I explain the formalism of the transducers and discuss the pros and cons for Julia ecosystem based on my experience in implementing [Transducers.jl](https://github.com/tkf/Transducers.jl). juliacon2019-969-transducers-data-oriented-abstraction-for-sequential-and-parallel-algorithms-on-containers Takafumi Arakaki en false https://pretalx.com/juliacon2019/talk/UUC9UJ/ https://pretalx.com/juliacon2019/talk/UUC9UJ/feedback/ Elm A Talk 2019-07-25T15:45:00-04:00 15:45 00:30 QsP is a sophisticated and effective way to predict the interaction between drugs and the human body, however, simulating QsP models can take a long time because of the intrinsic stiffness in transient chemical reactions. Here we take a deep look at the efficiency of various stiff ordinary differential equation solvers in the JuliaDiffEq ecosystem applied to QsP models, and utilize benchmarks to summarize how the ecosystem is progressing and what kinds of advances we can expect in the near future. juliacon2019-1055-efficient-stiff-ordinary-differential-equation-solvers-for-quantitative-systems-pharmacology-qsp Yingbo Ma en The solution of the stiff ordinary differential equation (ODE) systems resulting from QsP models is a rate-limiting step in large-scale population studies. Here we review the ongoing efficiency developments within the JuliaDiffEq numerical differential equation solver ecosystem with a focus on ODEs derived from QsP models. These models have specific features that can be specialized in order to gain additional efficiency in the integration, such as their small size (normally <500 ODEs), frequent dosing events, and multi-rate behaviors. We demonstrate how new implementations of high order Rosenbrock methods with PI-adaptive time stepping, exponential propagation iterative methods (EPRIK) with adaptive Krylov expmv calculations, and implicit-explicit singly diagonally implicit Runge-Kutta methods (IMEX SDIRK) can be advantageous over classical schemes like LSODA and Sundials CVODE on these types of models and discuss the future directions. false https://pretalx.com/juliacon2019/talk/J39LVP/ https://pretalx.com/juliacon2019/talk/J39LVP/feedback/ Elm A Talk 2019-07-25T16:15:00-04:00 16:15 00:30 The talk will introduce the use of PuMaS.jl for simulation and estimation of Nonlinear Mixed Effects Models used in systems pharmacology. juliacon2019-942-simulation-and-estimation-of-nonlinear-mixed-effects-models-with-pumas-jl /media/juliacon2019/images/38EHTQ/WhatsApp_Image_2019-03-07_at_23.00.48.jpeg Vaibhav Dixit en Pharmacokinetic/Pharmacodynamic (PKPD) models are empirical models of the physiological and pharmacological systems often used to describe the kinetics and behavior of drugs in the human body. Nonlinear Mixed Effects (NLME) statistical methods help identify the parameters of the PKPD models and quantify the differences between individuals by integrating models at the population and individual scales. In this talk I introduce PuMaS.jl, a Julia based software for simulating and estimating PKPD, physiology based PK (PBPK), quantitative systems pharmacology (QSP), etc. models used in pharmacology. I will begin by describing approximations to the marginal likelihood which are used to make the quantities efficiently computable and demonstrate on real data how these models can be fit with Optim.jl to reveal population-level characteristics. Additionally, I will demonstrate the ability to utilize DynamicHMC.jl to perform Bayesian estimation of population and individual parameters. Together, this demonstrates a Julia-based data-driven approach to handle complex problems in individualizing dosing. false https://pretalx.com/juliacon2019/talk/38EHTQ/ https://pretalx.com/juliacon2019/talk/38EHTQ/feedback/ Elm A Lightning Talk 2019-07-25T16:45:00-04:00 16:45 00:10 Electrodialysis, a prominent technology in the production of drinking water from seawater is modelled using the Julia ecosystem. A framework of partial differential equations and neural networks is solved to model the fouling of this process and to optimise its design and operation. juliacon2019-1084-an-advanced-electrodialysis-process-model-in-the-julia-ecosystem Bram De Jaegher en Electrodialysis is a separation technology that uses electric fields and ion-exchange membranes to separate charged components from solutions. Electrodialysis is a highly efficient technology with prominent applications in the production of drinking water from seawater and the recovery and upgrading of various bio-based resources. The majority of physical and electrochemical phenomena are well understood and can be described by mechanistic models. The complex and intricate interplay of various phenomena that occur at the surface of the ion-exchange membranes add an incredible amount of complexity and a mechanistic description is often too difficult. The Julia ecosystem provides a unique opportunity to couple differential equation solvers with machine learning techniques such as neural networks as a hybrid approach to model these kind of systems. Automatic differentation facilitates the optimisation procedure and is interesting from an engineering point of view. true https://pretalx.com/juliacon2019/talk/7SX9LN/ https://pretalx.com/juliacon2019/talk/7SX9LN/feedback/ Elm A Lightning Talk 2019-07-25T16:55:00-04:00 16:55 00:10 IVIVC.jl is a state of the art package for predictive mathematical modelling which correlates in vitro property (rate of drug dissolution) and in vivo response (plasma drug concentration profile). An IVIVC is meant to serve as a surrogate for in vivo bioavailability. This relationship can guide product development and support biowaivers. IVIVC.jl pipelines input bio-data to an IVIVC model with validations and it involves mathematical modelling, optimization and data visualisation accelerated with Julia. juliacon2019-1076-ivivc-jl-in-vitro-in-vivo-correlation-module-as-part-of-an-integrated-pharmaceutical-modeling-and-simulation-platform Shubham Maddhashiya en In this talk, I will introduce IVIVC.jl, a state of the art package for pharmaceutical modelling and simulation-based in Julia. In the core, IVIVC.jl uses Optim.jl as optimization library to model the in-vitro data and then correlates the model with deconvoluted in vivo data. This package establishes three levels (A, B and C) of in vitro-in vivo correlation (IVIVC). IVIVC is the relationship between parameter derived from a pharmacokinetic property produced by a dosage form and a physicochemical property of the same dosage form. The pharmacokinetic properties include maximum plasma concentration (Cmax) or area under the plasma concentration-time curve (AUC). When an IVIVC correlation is established, it is used for development and optimization of drug formulations. Using IVIVC.jl, one can accelerate drug development and can introduce a drug in the market faster. IVIVC can be used to substitute human bioequivalence studies in the initial approval process, the scale-up process, and the post-approval changes. This project is under the University of Maryland, Baltimore and the authors are me, Jogarao Gobburu and Vijay Ivaturi. false https://pretalx.com/juliacon2019/talk/9BRTVV/ https://pretalx.com/juliacon2019/talk/9BRTVV/feedback/ Elm A Lightning Talk 2019-07-25T17:05:00-04:00 17:05 00:10 Flow cytometry clustering for several hundred million cells has long been hampered by software implementations. Julia allows us to go beyond these limits. Through the high-performance GigaSOM.jl package, we gear up for huge-scale flow cytometry analysis. juliacon2019-1081-gigasom-jl-huge-scale-high-performance-flow-cytometry-clustering-in-julia /media/juliacon2019/images/9UWDLY/gigaSOM-logo-talk.png Laurent HeirendtVasco Verissimo en Recent advances in single-cell technologies offer an unprecedented opportunity to comprehensively characterize the immune system, revealing a previously unparalleled complexity in the phenotype and function of immune cells. Mass cytometry, also known as CyTOF, was recently implemented to measure up to 40 different markers in several million single cells. A typical clinical study with hundreds of patients can therefore include billions of single cells (rows) and up to 40 markers (features). Different dimension reduction methods have been implemented in commercial and open-source software, mainly written in R. The machine learning algorithm FlowSOM [1] is based on the famous Kohonen Self Organising Feature Maps (SOM) [2] and has shown various advantages over other methods. However, all current implementations have a critical limitation on the total number of cells to be analyzed . This limitation often blocks the analysis of large-scale clinical studies with several hundred million cells. Here, we present the open-source, high-level, and high-performance package GigaSOM.jl (https://github.com/LCSB-BioCore/GigaSOM.jl), which is HPC-ready and is written to handle very large datasets without limits. Julia is the natural language of choice when it comes to performing huge-scale cytometric analyses. With the GigaSOM.jl package, the possibilities for flow cytometry analysis are further broadened. The quality of the software package is assured using ARTENOLIS (https://artenolis.lcsb.uni.lu) [3]. Biological validation of the results will be performed on downsampled datasets by comparison to conventional implementations of the FlowSOM package and manual hierarchical analysis. *References* [1] Sofie Van Gassen, Britt Callebaut, Mary J. Van Helden, Bart N. Lambrecht, Piet Demeester, Tom Dhaene and Yvan Saeys. FlowSOM: Using self-organizing maps for visualization and interpretation of cytometry data. Cytometry A 2015, volume 87.7 (p. 636-645) [2] Kohonen T. The self-organizing map. Proc IEEE 1990;78:1464–1480 [3] Heirendt, Laurent; Arreckx, Sylvain; Trefois, Christophe; Yarosz, Yohan; Vyas, Maharshi; Satagopam, Venkata P.; Schneider, Reinhard; Thiele, Ines; Fleming, Ronan M. T., ARTENOLIS: Automated Reproducibility and Testing Environment for Licensed Software, arXiv:1712.05236. false https://pretalx.com/juliacon2019/talk/9UWDLY/ https://pretalx.com/juliacon2019/talk/9UWDLY/feedback/ Elm A Lightning Talk 2019-07-25T17:15:00-04:00 17:15 00:10 GWAS data are extremely high dimensional, large (>100GB), dense, and typically contains rare and correlated predictors. In this talk we discuss its unique data structures, how to efficiently represent it with Julia, how `MendelIHT.jl` in conjunction with `Distributions.jl` and `GLM.jl` fits generalized linear models for GWAS data, and the role of parallel computing. juliacon2019-961-mendeliht-jl-how-to-fit-generalized-linear-models-for-high-dimensional-genetics-gwas-data /media/juliacon2019/images/DLQMQU/gregor-mendel-3.jpg benjamin chu en **Background:** Marginal regression is widely employed by the genomics community to identify variants associated with complex traits. Ideally one would consider all covariates in tandem, but existing multivariate methods are sub-ideal to handle common issues of a modern genome wide association study (GWAS). Here we fill the gap with a new multivariate algorithm - iterative hard thresholding (IHT). **Method:** We introduce a novel coefficient estimation scheme based on maximum likelihoods, extending the IHT algorithm to perform multivariate model estimation for any exponential family. We further discuss and implement doubly-sparse and prior knowledge-aided variants of IHT to tackle specific problems in genetics, such as linkage disequilibrium. **Results:** We show how to apply IHT for any generalized linear model, and explicitly derive the updating algorithm and optimal step length for logistic and Poisson models. We provide an efficient implementation of IHT in Julia to analyze GWAS data as a module under [OpenMendel](https://github.com/OpenMendel). We tested our algorithm on real and simulated data to demonstrate model quality, algorithm robustness, and scalability. Then we investigate when and how (group)-(within-group) sparsity and knowledge-aided projections may help in discovering rare genetic variants with small effect size. Our implementation enjoys built-in parallelism, operates directly on raw genotype files, and is completely [open sourced](https://github.com/biona001/MendelIHT.jl). **Significance:** For geneticists, our method offers enhanced multivariate model selection for big data GWAS. For theorists, we demonstrate how to use IHT to find GLM coefficients, and we derive 2 variants of the thresholding operators and show when they are expected to perform better. false https://pretalx.com/juliacon2019/talk/DLQMQU/ https://pretalx.com/juliacon2019/talk/DLQMQU/feedback/ Elm A Lightning Talk 2019-07-25T17:25:00-04:00 17:25 00:10 In this talk, we will discuss implementation of various models relevant for electrochemical energy systems in order to more rapidly optimize component design and use-case specific optimization.We will show massive performance improvements gained through Julia for a variety of popularpseudo-2D porous electrode models describing Li-ion batteries. In addition, we will illustrate an example of an integrated design workflow of an aircraft power dynamics model along with a battery model, implemented within Julia. juliacon2019-1096-electrifying-transportation-with-julia Alec Bills en Modeling electric vehicle systems and their batteries helps to hasten the adoption and development of electric vehicles by clarifying their capabilities and requirements. Much progress has been made in electrifying automobiles, but less has been made in aircraft, which contribute a significant fraction of the greenhouse gas emissions from transportation. Aircraft have different battery requirements than automobiles and other modes of ground transportation. Specifically, the take-off and climb stages of flight can require discharge rates far greater than ground based systems.To study the effects of electrifying aviation, models of aircraft and batteries need to be integrated and studied together. It is essential to calculate the parameters of both the aircraft and the battery because these two systems are dependent on each other.We use Julia to model both aircraft and batteries. To model aircraft, a physics based performance model is used to calculate the energy and power requirements of the system. We use historical aircraft of various size and configurations to calculate energy and power requirements of different classes of aircraft. Our lab has modeled both eVTOL and conventional aircraft. Convert-ing the model from MATLAB to Julia yielded a massive speedup, enabling us to test many more configurations and classes of aircraft.We use several battery models depending on the size and battery requirements of the mode of transportation. For modes of that are capable of being powered by Lithium-Ion batteries, we use psuedo-2D single particle models incorporating all relevant properties of batteries, including energy, discharge rates, mass, and temperature. These models involve large systems of differential equations which can be efficiently solved using the DifferentialEquations.jl package. Porting these battery models to Julia yielded massive speedups, enabling parameter sweeps and use-case specific optimization of battery cell parameters. Larger and longer range forms of transportation have battery requirements that exceed what can be provided by Lithium-Ion batteries. For example,a fully electric commercial aircraft could require a Lithium Air battery. We also use the speed provided by Julia to increase our modeling capabilities for these forms of transportation. In thistalk, we will show an integrated model of a Lithium Air battery and an aircraft performance model. false https://pretalx.com/juliacon2019/talk/NF9XC7/ https://pretalx.com/juliacon2019/talk/NF9XC7/feedback/ Elm A Lightning Talk 2019-07-25T17:35:00-04:00 17:35 00:10 The Julia Language 1.0 Ephemeris and Physical Constants Reader for Solar System Bodies is an ephemeris reader, written in the programming language of Julia, is a new tool intended for use in astrodynamic applications. juliacon2019-966-the-julia-language-1-0-ephemeris-and-physical-constants-reader-for-solar-system-bodies Renee Spear en With computation time being a critical factor in trajectory optimization, this code has aimed for and accomplished a higher computational efficiency than the original code designed in MATLAB®. The ephemeris reader acquires necessary data for mission design from public JPL websites and calculates positions, velocities, accelerations, and other characteristics of major and small bodies at any user-defined times using the extracted data. Additionally, the second generation of this ephemeris reader introduces shape models of known asteroids as well as spherical harmonics capabilities to support gravitational potential models. This version of the ephemeris reader is also compatible with Julia 1.0 which was released in August of 2018. This second-generation version continues to support the obtainment of critical information needed for mission and trajectory design faster and with added efficiency. This lightning talk will discuss a more detailed overview as well as why Julia was chosen for this project. false https://pretalx.com/juliacon2019/talk/EKTAAY/ https://pretalx.com/juliacon2019/talk/EKTAAY/feedback/ Elm B Talk 2019-07-25T11:00:00-04:00 11:00 00:30 We will show how interval constraint propagation can give a guaranteed description of feasible sets satisfied by nonlinear inequalities via contractors. This technology can be applied to speed up guaranteed global optimization and root finding. juliacon2019-957-interval-methods-for-scientific-computing-in-julia David P. Sanders en We will give an overview of the suite of inter-related packages making up the `JuliaIntervals` organization. These are package which use **set calculations** to solve nonlinear equations, minimize nonlinear functions, and solve ordinary differential equations with results that are (in principle, modulo coding errors!) *guaranteed* to be correct. The underlying technique for calculating with sets is **interval arithmetic**. Here, mathematical operations, such as `x -> x^2` and `x + y` are defined on sets, represented as intervals of all real numbers between two endpoints. By defining these operations carefully, we can guarantee that `f(X)` is guaranteed to contain `f(x)` for all `x` in the set `X`, even though we use floating-point arithmetic for the calculations. A key technique is **interval contraint propagation**, which allows us to calculate enclosures of the *inverse* of a given function. We will show how this can accelerate optimisation and root finding using interval methods. The presentation will be based on practical applications. false https://pretalx.com/juliacon2019/talk/KDBXKD/ https://pretalx.com/juliacon2019/talk/KDBXKD/feedback/ Elm B Lightning Talk 2019-07-25T11:30:00-04:00 11:30 00:10 In the proposed talk an efficient root finding algorithm is presented through engineering applications, which are formed as implicit non-linear equation systems. juliacon2019-1021-implicit-geometry-with-multi-dimensional-bisection-method /media/juliacon2019/images/7S9BDD/s_c.png Daniel Bachrathy en Multi-Dimensional Bisection Method (MDBM.jl) is an efficient and robust root-finding package, which can be used to determine whole high-dimensional submanifolds (points, curves, surfaces…) of the roots of implicit non-linear equation systems, especially in cases, where the number of unknowns surpasses the number of equations. Engineering application will be presented from the different fields - determination of the workspace of a robot arm with collision avoidance - stability (stabilizability) chart computations - constrained parameter optimisation false https://pretalx.com/juliacon2019/talk/7S9BDD/ https://pretalx.com/juliacon2019/talk/7S9BDD/feedback/ Elm B Lightning Talk 2019-07-25T11:40:00-04:00 11:40 00:10 This talk introduces computational topology algorithms to generate the 2D/3D space partition induced by a collection of 1D/2D/3D geometric objects. Methods and language are those of basic geometric and algebraic topology. Only sparse arrays are used to compute spaces and maps (the chain complex) from dimension zero to three. juliacon2019-971-computational-topology-and-boolean-operations-with-julia-sparse-arrays Alberto Paoluzzi en This approach to computation of space arrangements may be used in disparate subdomains of geometric and visual computing, including geo-mapping, computer vision, computer graphics, medical imaging, geometric and solid modeling, and finite elements. In all such domains one must compute incidences, adjacencies and ordering of cells, generally using disparate and often incompatible data structures and algorithms. E.g., most of earlier algorithms for space decomposition and Boolean operations work with data structures optimized for selected classes of geometric objects. Conversely, we introduce a computational architecture based only on linear algebra with sparse arrays and basic matrix operations. Therefore our formulation, cast in terms of (co)chain complexes of (co)boundary maps, may be applied to very different geometric objects, ranging from solid models to engineering meshes, geographical systems, and biomedical images. In particular, we use rather general cellular complexes, with cells homeomorphic to polyhedra, i.e., to triangulable spaces, and hence possibly non convex and with holes. The main stage of our computational pipeline operates independently on each 2-cell of the input data sets, according to an embarrassingly parallel data-driven approach. It is remarkable that the approach works with collections of 2-manifolds with- or without-boundary, sets of non-manifolds, sets of 3-manifolds, etc., and not only with triangle meshes. Extending this approach to Boolean solid operations is straightforward. Among other strong points we cite: the compact representation of cellular complexes; the combinable nature of maps, allowing for multiple queries about the local topology, by a single matrix multiplication; the parallel fragmentation of input cells empowered by cell congruence; and what we call "topological gift wrapping" algorithm. false https://pretalx.com/juliacon2019/talk/3BKGNU/ https://pretalx.com/juliacon2019/talk/3BKGNU/feedback/ Elm B Lightning Talk 2019-07-25T11:50:00-04:00 11:50 00:10 The [Grassmann.jl](https://github.com/chakravala/Grassmann.jl) package provides tools for doing computations based on multi-linear algebra, differential geometry, and spin groups using the extended tensor algebra known as Grassmann-Clifford-Hestenes-Taylor geometric algebra. The primary operations are `∧, ∨, ⋅, *, ×, ⋆, ', ~` (which are the outer, regressive, inner, geometric, and cross products along with the Hodge star, adjoint, and multivector reversal operations). Any operations are truly extensible with high dimensional support for up to 62 indices and staged caching / precompilation, where the code generation enables the fairly automated task of making more definitions. The [DirectSum.jl](https://github.com/chakravala/DirectSum.jl) multivector parametric type polymorphism is based on tangent bundle vector spaces and conformal projective geometry to make the dispatch highly extensible for many applications. Additionally, interoperability between different sub-algebras is enabled by [AbstractTensors.jl](https://github.com/chakravala/AbstractTensors.jl), on which the type system is built. juliacon2019-994-geometric-algebra-in-julia-with-grassmann-jl /media/juliacon2019/images/CES8P9/grassmann.png Michael Reed en The design of [Grassmann.jl](https://github.com/chakravala/Grassmann.jl) is based on the `TensorAlgebra` abstract type system interoperability from [AbstractTensors.jl](https://github.com/chakravala/AbstractTensors.jl) with a `VectorSpace` parameter from [DirectSum.jl](https://github.com/chakravala/DirectSum.jl). Abstract tangent vector space type operations happen at compile-time, resulting in a differential conformal geometric algebra of hyper-dual multivector forms. The abstract nature of the product algebra code generation enables one to automate the extension of the product operations to any specific number field type (including symbolic coefficients with [Reduce.jl](https://github.com/chakravala/Reduce.jl) or SymPy.jl), by taking advantage of Julia's type system. With the type system, it is possible to construct mixed tensor products from the mixed tangent vector basis and its dual basis, such as bivector elements of Lie groups. `Grassmann` can be used to study unitary groups used in quantum computing by building efficient computational representations of their algebras. Applicability of the Grassmann computational package not only maps to quantum computing, but has the potential of impacting countless other engineering and scientific computing applications. It can be used to work with automatic differentiation and differential geometry, algebraic forms and invariant theory, electric circuits and wave scattering, spacetime geometry and relativity, computer graphics and photogrammetry, and much more. false https://pretalx.com/juliacon2019/talk/CES8P9/ https://pretalx.com/juliacon2019/talk/CES8P9/feedback/ Elm B Talk 2019-07-25T14:30:00-04:00 14:30 00:30 We will present Mimi.jl, a next generation platform for Integrated Assessment Modelling widely used in climate economics research. The talk will outline technical aspects of the platform, as well as its adoption and impact both on research at universities and in the US federal climate regulation process. juliacon2019-1062-mimi-jl-next-generation-climate-economics-modeling Cora KingdonDavid AnthoffLisa Rennels en In 2016, the EPA commissioned a report from the National Academy of Sciences on research priorities for improving and updating the Social Cost of Carbon, a metric used by the federal government to account for the impacts of climate change within regulatory impact analyses. One central recommendation from the ensuing National Academies [report](https://www.nap.edu/catalog/24651/valuing-climate-damages-updating-estimation-of-the-social-cost-of) was to create a common, modular computational platform to better serve modelling work in this area. Our team created the leading (and probably only) implementation following this call to action: the [Mimi Framework](https://www.mimiframework.org/). Mimi.jl is entirely implemented in Julia. This talk will present this computational platform, discuss its application, and dive into key design considerations. The main design constraints for Mimi.jl were that we needed something: a) computationally fast, b) simple enough that a lack of significant programming experience is not a barrier for users, c) that enables a modular work style for distributed, loosely coordinated teams, and d) that creates a transparent framework enabling easy replication of computational experiments. We will describe in some detail how we achieved this design using a macro based domain specific language for certain parts of the framework, while at the same time exposing the full power of the Julia language to users. We will also touch on our use of a custom Julia registry as the repository for different modules that different groups can work on, allowing us to use Julia’s package manager to solve the replication problem for computational experiments. We will also discuss a large number of specific design decisions that helped us make the system easy to use for novice programmers. We will conclude the talk with a discussion of adoption and impact of this platform. We will outline how different groups at a number of leading universities and think tanks have adopted the platform for their work and outline why we believe it will power the next generation of the US federal climate economics work in the regulatory space going forward. false https://pretalx.com/juliacon2019/talk/ZE9AVH/ https://pretalx.com/juliacon2019/talk/ZE9AVH/feedback/ Elm B Talk 2019-07-25T15:00:00-04:00 15:00 00:30 We are using Julia to develop the first Earth System Model that automatically learns from diverse data sources. juliacon2019-1074-the-climate-machine-a-new-earth-system-model-in-julia Simon ByrneCharlie Kawczynski en The [Climate Modeling Alliance (CliMA)](https://clima.caltech.edu/) aims to build the first Earth system model that automatically learns from both Earth observations and embedded high-resolution simulations. The goal is to build a more accurate climate model with quantified uncertainties. High computational performance on heterogeneous architectures, including CPUs, GPUs, and distributed computing architectures is essential for the project. The model is being developed in Julia to ensure portable performance at supercomputing scales for this ambitious scientific computing project. This talk will give an overview of the project and its motivation. We will highlight how we’re pushing Julia to scale, including lessons learnt and challenges we are facing. false https://pretalx.com/juliacon2019/talk/FXBCLP/ https://pretalx.com/juliacon2019/talk/FXBCLP/feedback/ Elm B Talk 2019-07-25T15:45:00-04:00 15:45 00:30 Symbolic terms are fundamental to a variety of fields in computer science, including computer algebra, automated reasoning, and scientific modeling. In this talk, we discuss a family of Julia packages for symbolic computation, including Rewrite.jl for term rewriting and ModelingToolkit.jl for symbolic differential equations. juliacon2019-1106-symbolic-manipulation-in-julia Harrison Grodin en The manipulation of symbolic terms is fundamental to a variety of fields in computer science, including computer algebra, automated reasoning, and scientific modeling. Through the lens of symbolic transformations, we concisely represent and efficiently apply complex properties and equivalences. In this talk, we discuss a family of Julia packages for symbolic computation, establishing the foundations of term rewriting and showcasing extensions and applications. After offering a formal definition of symbolic terms, we will examine various notions from the field of term rewriting and their implementations in Rewrite.jl. We will design sets of rewrite rules that simplify algebraic expressions into unique normal forms, based on domain-specific axioms. Building on this interpretation, we finally will explore symbolic differential equations in ModelingToolkit.jl, showcasing methods for incorporating context-aware symbolic variables and techniques for enforcing mathematical invariants. false https://pretalx.com/juliacon2019/talk/9R9A7M/ https://pretalx.com/juliacon2019/talk/9R9A7M/feedback/ Elm B Talk 2019-07-25T16:15:00-04:00 16:15 00:30 As the saying goes: _"You can solve that with Cassette"_. This is a tuitoral on how to use Cassette for building a debugger. It explains the core of MagneticReadHead.jl, and how you can build similar tools, to instrument julia code for your purposes. juliacon2019-1025-building-a-debugger-with-cassette Frames Catherine White en As the saying goes: _"You can solve that with Cassette"_. You can do anything with Cassette, and debugging is a thing, therefore Cassette can be used for it. Generally speaking, you shouldn't solve problems with Cassette that you can solve in any other way. However if you want to build a debugger, the options include building [an entire interpreter](https://github.com/JuliaDebug/JuliaInterpreter.jl), [going deep into the lowest levels of the compiler/LLVM](https://github.com/JuliaDebug/Gallium.jl/tree/v0.0.4), or using [Cassette](https://github.com/jrevels/Cassette.jl). The other options are certainly good, and indeed the interpreter work has yeilded [Debugger.jl](https://github.com/JuliaDebug/Debugger.jl/). But this talk is about doing it with Cassette. [MagneticReadHead v0.1.0](https://github.com/oxinabox/MagneticReadHead.jl/tree/v0.1.0) is usable debugger based on easy-to-use Cassette function overdubs. It is under 300 lines of code, and allowed setting breakpoints and stepping between function calls. [MagneticReadHead v0.2+](https://github.com/oxinabox/MagneticReadHead.jl) is featureful debugger based on Cassette IR passes. It is under 800 lines of code, and alloweds setting breakpoints at arbitary locations and stepping between IR statements. The talk will first explain the Cassette function overdubs used in v0.1.0 and how you can use them to fairly painlessly instrument julia code at the function call level. It will then move on the the much more complex IR passes used in current versions of MagneticReadHead. Explaining how you can recursively modify julia code at run time to instert the extra functionality needed for debugging. At first Julia IR may seem like a read-only language. It is surprisingly easy to read, but actually modifying it... the concept brings on a special kind of head pain. After this talk you will be able to experience that special pain for yourself, and hopefuly push through it to do something useful. This tuitorial type presentation is for the advanced julia user. While knowledge of Cassette is not required, it is expected that attendees are broadly familar with the idea of what IR is, even if they have no idea how to write it. Everyone is welcome to come along for the ride. false https://pretalx.com/juliacon2019/talk/Y9B87L/ https://pretalx.com/juliacon2019/talk/Y9B87L/feedback/ Elm B Lightning Talk 2019-07-25T16:45:00-04:00 16:45 00:10 Efficient performance engineering for Julia programs heavily relies on understanding the result of type-inference on your program, this talk will introduce a tool to have a conversation with type-inference. juliacon2019-936-static-walks-through-dynamic-programs-a-conversation-with-type-inference Valentin Churavy en Efficient performance engineering for Julia programs heavily relies on understanding the result of type-inference on your program, type-inference as process is sensitive to local information or call-context. Many Julia users use the information provided by `@code_typed` to analyse the behaviour of type-inference on *a* function. This method becomes cumbersome and inefficient with deeply nested programs where the user needs to reconstruct local information to inspect called methods. This talk introduces a tool that streamlines this process and allows users to take a static walk through their dynamic program. It simplifies the performance engineering process and is capable of handling code that uses tasks, threads and GPUs. false https://pretalx.com/juliacon2019/talk/WJZJXS/ https://pretalx.com/juliacon2019/talk/WJZJXS/feedback/ Elm B Lightning Talk 2019-07-25T16:55:00-04:00 16:55 00:10 Concolic testing is a technique that uses concrete execution to create a symbolic representation of a program, which can be used to prove properties of programs or do provable exhaustive fuzzing. juliacon2019-937-concolic-fuzzing-or-how-to-run-a-theorem-prover-on-your-julia-code Valentin Churavy en In this talk we will explore how to use Cassette to extract a symbolic trace from a Julia program and using that capability to prove properties of Julia programs . This also enables fuzzing and automated test-case development. false https://pretalx.com/juliacon2019/talk/RVXF7L/ https://pretalx.com/juliacon2019/talk/RVXF7L/feedback/ Elm B Lightning Talk 2019-07-25T17:05:00-04:00 17:05 00:10 Revise.jl allows you to modify code in your running Julia session. Revise was recently rewritten around JuliaInterpreter.jl and a new query interface, CodeTracking.jl, resulting in many improvements and easier access to Revise’s internal data. juliacon2019-1108-analyzing-and-updating-code-with-juliainterpreter-and-revise Tim Holy en Revise.jl serves a dynamic bridge between the text in source files and the compiled methods in your running Julia session. To faithfully bridge these two worlds, Revise needs to understand quite a bit about code. Historically, Revise analyzed expressions written in Julia’s [surface syntax](https://docs.julialang.org/en/latest/devdocs/ast/); however, recent examples revealed a number of weaknesses in this approach. To address these limitations, starting with version 2.0 Revise has leveraged JuliaInterpreter.jl to perform its analysis of code using Julia’s internal lowered-form representation. This has resulted in dramatic improvements in the number of methods that can be tracked by their signatures, and may allow new capabilities such as discovery of block-level interdependencies. At the same time, Revise’s internal data structures have been reorganized to simplify access by other packages, resulting in a lightweight standalone package CodeTracking.jl. I will describe the motivations for these changes and the solutions enabled by the new approach, and demonstrate some of the dramatic improvements this has netted for dependent packages like Rebugger.jl. false https://pretalx.com/juliacon2019/talk/RH78UW/ https://pretalx.com/juliacon2019/talk/RH78UW/feedback/ Elm B Lightning Talk 2019-07-25T17:15:00-04:00 17:15 00:10 TimerOutputs.jl is a tool that lets you annotate sections in your code so that after execution, a nicely formatted table with information about how much time and allocations were spent in each section can be shown. juliacon2019-1020-timeroutputs-jl-a-cheap-and-cheerful-instrumenting-profiler Kristoffer Carlsson en Julia has for a long time come with a built-in profiler, which is available as the Profile standard library. This profiler is a sampling profiler which means that it collects snapshots of the stacktrace at regular intervals. After execution of the profiled code, the number of traces that were collected in each function can be displayed which gives a good estimate where the code is spending its time. While sampling profiling is a very useful and cheap way of profiling code, there are a few drawbacks: Since only samples of the execution is collected, exact information of e.g. the time spent in functions or the number of calls to a function is not available. Not being able to annotate what parts of the code you care about mean that the output from the profiler is sometimes noisy and hard to interpret for non-experts. Allocations can not be attributed to certain sections of the code. TimerOutputs is a Julia package that provides an instrumenting profiler which requires you to annotate your code with labeled sections. While the code is running, TimerOutputs records timing and allocation data in these sections and can then print a summary back to the user. This can sometimes make it easier to get a high level overview of the performance characteristics of the code. An example of the output from TimerOutputs is shown below. ─────────────────────────────────────────────────────────────────────────────── Time Allocations ────────────────────── ─────────────────────── Tot / % measured: 6.89s / 97.8% 5.20GiB / 85.0% Section ncalls time %tot avg alloc %tot avg ─────────────────────────────────────────────────────────────────────────────── assemble 6 3.27s 48.6% 545ms 3.65GiB 82.7% 624MiB inner assemble 240k 1.92s 28.4% 7.98μs 3.14GiB 71.1% 13.7KiB linear solve 5 2.73s 40.5% 546ms 108MiB 2.39% 21.6MiB create sparse matrix 6 658ms 9.77% 110ms 662MiB 14.6% 110MiB export 1 78.4ms 1.16% 78.4ms 13.1MiB 0.29% 13.1MiB ─────────────────────────────────────────────────────────────────────────────── The timing and allocations for each section is presented and the call graph (e.g. that assemble calls inner assemble) is shown by indentation. This lightning talk gives a short summary of the implementation, syntax and use cases of TimerOutputs. false https://pretalx.com/juliacon2019/talk/M8G7DD/ https://pretalx.com/juliacon2019/talk/M8G7DD/feedback/ Elm B Lightning Talk 2019-07-25T17:25:00-04:00 17:25 00:10 With PackageCompiler, one can ahead of time compile binaries for Julia packages. This includes the ability to create an executable for a Julia script. In this talk, I will give a short overview of how PackageCompiler works and how it can be used to ship your Julia package or eliminate JIT overhead. juliacon2019-909-packagecompiler Simon Danisch en false https://pretalx.com/juliacon2019/talk/RMNXL7/ https://pretalx.com/juliacon2019/talk/RMNXL7/feedback/ Room 349 Talk 2019-07-25T11:00:00-04:00 11:00 00:30 If you're familiar with Julia and its ecosystem, you may have noticed something lovely but a bit puzzling: there seems to be an unusually large amount of code reuse between packages compared to other seemingly similar languages. This sharing of code comes in two forms: 1. Sharing basic types among a wide variety of packages providing disparate functionality; 2. Sharing generic algorithms that work on various implementations of common abstractions. Why does generic code in Julia "just work"? Why do Julia packages seem to share types with so little friction? Both kinds of reuse are supposed to be natural benefits of class-based object-oriented languages. After all, inheritance and encapsulation are two of the four pillars of OOP. Even more puzzling is that Julia has no encapsulation and doesn't allow inheriting from concrete types at all. Yet both kinds of code reuse are rampant. What is going on? In this talk, I make the case that both of kinds sharing stem directly from Julia's multiple dispatch programming paradigm. juliacon2019-1064-the-unreasonable-effectiveness-of-multiple-dispatch Stefan Karpinski en The former kind of sharing of types stems from the external nature of multiple dispatch: the source of many problems in class-based OOP is that methods have to live "inside of" classes. Simply by associating methods with generic functions rather than the type that they operate on, multiple dispatch avoids many of the problems that OOP has. The latter kind of sharing stems from the ability to correctly choose specialized code based on the types of all arguments of a function. There are patterns like double dispatch to try to deal with this in single dispatch languages, but they are cumbersome, brittle and opt-in, meaning that unless someone else planned for you to extend their code, you are unlikely to be able to do so. false https://pretalx.com/juliacon2019/talk/BCYWZJ/ https://pretalx.com/juliacon2019/talk/BCYWZJ/feedback/ Room 349 Lightning Talk 2019-07-25T11:30:00-04:00 11:30 00:10 Julia's embrace of multiple dispatch as a key organizing concept provides developers with all the tools they need to simply implement state machine based solutions to a wide range of problems. This presentation will explore a series of increasingly complex tasks that can all be addressed using a clever combination of types and multiple dispatch. juliacon2019-1130-julia-s-killer-app-s-implementing-state-machines-simply-using-multiple-dispatch Joshua Ballanco en In the universe of programming languages, success for any new language hangs on its ability to simplify some class of problem that exceed the capabilities of other existing languages to generate simple solutions for. The concept of a state machine is a powerful tool that programmers have used for ages to address all manner of challenges, but until now implementing a state machine has typically required either the use of involved external libraries or the design of relatively opaque algorithms and data structures. Julia changes all of that by embracing multiple dispatch and an extensible type system that, together, provide everything a programmer requires to design and develop even the most complex of state machines. This presentation will begin with a basic introduction to the concepts behind state machines and their implementation and then dive into an example of how one might use the concept of a state machine to handle the parsing of a regular expression into a Julia data structure. Continuing from there, we will look at how matching a regular expression to a string can, itself, be implemented using a state machine. All the while, we will only require Julia, its type system, and a handful of multiply dispatched methods. Finally, we will review various ways in which state machines implemented in Julia can be extended and iterated upon without requiring any new libraries or tools beyond those used in their initial implementation. We will also consider how even more complex tasks, including even an entire HTTP request/response handler, can be tackled using the exact same approach. By the end, it should be clear that the killer feature that Julia brings to the world of programming languages is the ability to develop state machines in a way that is clear, concise, performant, and infinitely flexible. false https://pretalx.com/juliacon2019/talk/JVUMQJ/ https://pretalx.com/juliacon2019/talk/JVUMQJ/feedback/ Room 349 Lightning Talk 2019-07-25T11:40:00-04:00 11:40 00:10 A package about einsum, as well as differentiable tensor network algorithms built on top of it. Why we need automatic differentiating tensor networks and how to achieve this goal. juliacon2019-990-differential-programming-tensor-networks /media/juliacon2019/images/XH89CV/ome-logo_1QI17O3.png JinGuo Liu en A tensor network is a contraction of tensors, it has wide applications in fields of physics, big data and machine learning. It can be used to represent a quantum wave function ansatz, compress data and model probabilities. Supporting automatic differentiation brings hope for many difficult problems like training project entangled pair states. We provide a unified, dispatchable interface for `einsum` as the middleware to port tensor contraction libraries and tensor network applications and a through support to back-propagation through linear algebra functions. Based on these supporting libraries, we show some tensor network algorithms as examples. References: * Differentiable Programming Tensor Networks, Hai-Jun Liao, Jin-Guo Liu, Lei Wang, and Tao Xiang [under preparation] * Unsupervised Generative Modeling Using Matrix Product States, Zhao-Yu Han, Jun Wang, Heng Fan, Lei Wang, and Pan Zhang Phys. Rev. X 8, 031012 false https://pretalx.com/juliacon2019/talk/XH89CV/ https://pretalx.com/juliacon2019/talk/XH89CV/feedback/ Room 349 Lightning Talk 2019-07-25T11:50:00-04:00 11:50 00:10 JuliaCN was founded by early Chinese Julia developers for Julia localization in Chinese. We started it by providing Chinese translation on Julia documentation known as [JuliaZH.jl](https://github.com/JuliaCN/JuliaZH.jl)/[julia_zh_cn](https://github.com/JuliaCN/julia_zh_cn). juliacon2019-913-juliacn-a-community-driven-localization-group-for-julia-in-china /media/juliacon2019/images/D7NVW8/logo.png Xiu-zhe (Roger) Luo en ## Introduction [JuliaCN](https://github.com/JuliaCN) was founded when Julia was still newly born. Its early member includes several developers in the community, e.g Jiahao Chen, Yichao Yu. We provided the first translation on Julia's documentation in v0.3, known as [julia_zh_cn](https://github.com/JuliaCN/julia_zh_cn). Later, we provided [the Chinese discourse](https://discourse.juliacn.com/) to let non-English speakers communicate freely and get support when they are in trouble. ## Activities - Annual Julia User Meetup in China: This is more like a small workshop held each year. - Holding and providing resource for Julia User Meetups - Community driven translation project: we built a transifex based translation project [JuliaZH.jl](https://github.com/JuliaCN/JuliaZH.jl) ### Project Emerged in JuliaCN Community - [Jetbrain IDE for Julia](https://plugins.jetbrains.com/plugin/10413-julia) - [Py2JI.jl](https://github.com/JuliaCN/Py2Jl.jl) false https://pretalx.com/juliacon2019/talk/D7NVW8/ https://pretalx.com/juliacon2019/talk/D7NVW8/feedback/ Room 349 Talk 2019-07-25T14:30:00-04:00 14:30 00:30 How to use abstractions to write code that will be easy to follow and change while also not significantly impacting performance juliacon2019-1069-writing-maintainable-julia-code Scott Haney en Have you ever updated an algorithm's code just to find that the algorithm has changed in unexpected ways? Have you ever started coding an algorithm just to think to yourself that you had already done something extremely similar for a different algorithm? These problems are often the case because code is not broken down into clear conceptual components that are independent from one another and easy to reuse. To illustrate how this can be accomplished we will walk through the implementation of three highly similar iterative eigenvalue/eigenvector algorithms. It will be shown that each of the three iterative algorithms consists of the same main conceptual components which will be extracted into a single method used by all three iterative algorithms. The result will be code that is easy to follow at a high level because breaking it into high level conceptual components will make it easier to read and follow. Changes will also be easier to make because finding the correct area of the code to change will be easier and there will be less risk of unexpected side effects because the other components should be independent. Finally some discussion will be made about the performance implications of introducing more abstractions and how if the abstractions are kept at the higher levels of the algorithms code it is highly unlikely that performance will be significantly impacted. false https://pretalx.com/juliacon2019/talk/J779CB/ https://pretalx.com/juliacon2019/talk/J779CB/feedback/ Room 349 Talk 2019-07-25T15:00:00-04:00 15:00 00:30 The speaker's experience writing a full-length optimization textbook with Julia-generated figures and typeset julia code, how to all works. juliacon2019-888-how-we-wrote-a-textbook-using-julia /media/juliacon2019/images/WFVWES/fig_direct_nelder_mead.png Tim Wheeler en My coauthor (Prof. Mykel Kochenderfer) and I wrote a full-length, fully-featured, academic textbook. It is full of beautiful Julia-generated figures and typeset Julia code snippets. Everything is source controlled .tex files, and everything else is generated on compile. This talk covers how we did it and why you might want to do it too. false https://pretalx.com/juliacon2019/talk/WFVWES/ https://pretalx.com/juliacon2019/talk/WFVWES/feedback/ Room 349 Talk 2019-07-25T15:45:00-04:00 15:45 00:30 Turing is a probabilistic programming language written in Julia. This talk will introduce Turing and its tooling ecosystem, as well as go over some introductory tutorials. juliacon2019-1039-turing-probabalistic-programming-in-julia /media/juliacon2019/images/MA9N8R/logo.png Cameron Pfiffer en During the course of the talk, I will introduce Turing's modeling syntax, some typical workflows, and examples of how Turing integrates with notable Julia packages such as Flux.jl or DifferentialEquations.jl. Additionally, I hope to present the status on some of the Julia Summer of Code projects, which may include Variational Inference or greater Gaussian processes integration with Stheno.jl, among others. false https://pretalx.com/juliacon2019/talk/MA9N8R/ https://pretalx.com/juliacon2019/talk/MA9N8R/feedback/ Room 349 Talk 2019-07-25T16:15:00-04:00 16:15 00:30 Stheno.jl is a probabilistic programming framework specifically designed for constructing probabilistic models based around Gaussian processes. Come to this talk to find out what that means, why you should care, and how you can use it with Flux.jl and Turing.jl to do cool things. juliacon2019-984-gaussian-process-probabilistic-programming-with-stheno-jl /media/juliacon2019/images/GEJT9H/juliacon-img.png Will Tebbutt en Gaussian processes (GPs) are probabilistic models for nonlinear functions that are flexible, easy to interpret, and enable the modeller to straightforwardly encode high-level assumptions about the properties of the function in question. In short, they're a really useful component of the probabilistic modelling tool box. Implementations to date have not made possible to fully exploit the interpretability of GPs, making it harder than necessary encode prior knowledge and interpret results. Based on the ideas in our recently proposed GP probabilistic programming framework, we have developed Stheno.jl to provide an implementation that is straightforward for the user interested in applying GPs to their problem to use, while remaining hackable for experts and researchers. This talk will provide an intuitive introduction GPs using Stheno.jl. We'll then show how Stheno.jl can be used solve extensions of a classical non-linear regression problem and explore structure in the solution, how it can be used in conjunction with Turing.jl to embed GPs as a component in a larger non-Gaussian probabilistic programme, and to explore how it can be combined with Flux.jl to hardness the complementary strengths of deep learning and probabilistic modelling. false https://pretalx.com/juliacon2019/talk/GEJT9H/ https://pretalx.com/juliacon2019/talk/GEJT9H/feedback/ Room 349 Talk 2019-07-25T16:45:00-04:00 16:45 00:30 This talk will explore the basic ideas in Soss, a new probabilistic programming library for Julia. Soss allows a high-level representation of the kinds of models often written in PyMC3 or Stan, and offers a way to programmatically specify and apply model transformations like approximations or reparameterizations. juliacon2019-1036-soss-jl-probabilistic-metaprogramming-in-julia Chad Scherrer en Probabilistic programming is sometimes referred to as “modeling for hackers”, and has recently been picking up steam with a flurry of releases including Stan, PyMC3, Edward, Pyro, and Tensorflow Probability. As these and similar systems have improved in performance and usability, they have unfortunately also become more complex and difficult to contribute to. This is related to a more general phenomenon of the “two language problem”, in which performance-critical domain like scientific computing involve both a high-level language for users and a high-performance language for developers to implement algorithms. This establishes a kind of wall between the two groups, and has a harmful effect on performance, productivity, and pedagogy. In probabilistic programming, this effect is even stronger, and it’s increasingly common to see three languages: one for writing models, a second for data manipulation, model assessment, etc, and a third for implementation of inference algorithms. Solving this “three-language problem” usually means accepting either lower performance or a restricted class of available models and inference algorithms. It doesn’t have to be this way. The Julia language supports Python-level coding with C-level performance. In Julia, Julia’s own code is “first-class”: code can be pulled apart and manipulated as a data structure. This leads to an approach for high-level representation of models, with transformations and optimizations specific to a given model or inference family. This is the approach taken in Soss, a small and extensible Julia library that provides a way to represent and manipulate probabilistic models. In this talk, we’ll discuss the need and for Soss, some of its concepts at a high level, and finally some recent advancements and upcoming opportunities. false https://pretalx.com/juliacon2019/talk/GBWC9F/ https://pretalx.com/juliacon2019/talk/GBWC9F/feedback/ Room 349 Lightning Talk 2019-07-25T17:15:00-04:00 17:15 00:10 This talk introduces a new flexible and extensible probabilistic programming system called Gen, that is built on top of Julia. Gen's extensible set of modeling DSLs can express probabilistic models that combine Bayesian networks, black box simulators, deep learning, structure learning, and Bayesian nonparametrics; and Gen's inference library supports custom algorithms that combine Markov chain Monte Carlo, particle filtering, variational inference, and numerical optimization. juliacon2019-906-gen-a-general-purpose-probabilistic-programming-system-with-programmable-inference-built-on-julia Marco Cusumano-Towner en Probabilistic modeling and inference are central to many fields. Probabilistic programming systems aim to make probabilistic modeling and inference techniques accessible to a broader audience, and to make it easier for experts in these techniques to develop more complex applications. A key challenge for wider adoption of probabilistic programming languages is designing systems that are both flexible and performant. This talk introduces Gen, a new probabilistic programming system, built on top of Julia, that includes novel language constructs for modeling and for end-user customization and optimization of inference. Gen makes it practical to write probabilistic programs that solve problems from multiple fields. Gen programs can combine generative models written in Julia, neural networks written in TensorFlow, and custom inference algorithms based on an extensible library of Monte Carlo and numerical optimization techniques. The talk will also present techniques that enable Gen’s combination of flexibility and performance: (i) the generative function interface, an abstraction for encapsulating probabilistic and/or differentiable computations; (ii) domain-specific languages with custom compilers that strike different flexibility/performance tradeoffs; (iii) combinators that encode common patterns of conditional independence and repeated computation, enabling speedups from caching; and (iv) a standard inference library that supports custom proposal distributions also written as programs in Gen. This talk shows that Gen outperforms state-of-the-art probabilistic programming systems, sometimes by multiple orders of magnitude, on problems such as nonlinear state-space modeling, structure learning for real-world time series data, robust regression, and 3D body pose estimation from depth images. false MIT-CSAIL-TR-2018-020.pdf https://pretalx.com/juliacon2019/talk/GVYCEL/ https://pretalx.com/juliacon2019/talk/GVYCEL/feedback/ Room 349 Lightning Talk 2019-07-25T17:25:00-04:00 17:25 00:10 I will present a probabilistic programming language that implements switching Kalman filters, and its applications to industrial time series processing. juliacon2019-1023-a-probabilistic-programming-language-for-switching-kalman-filters Cédric St-Jean-Leblanc en At R2 Inc., we monitor in real-time tens of thousands of sensors in industrial plants, looking for anomalous behaviour. Industrial processes are usually very well understood and predictable, making them ideal candidates for classical Bayesian analysis. Off-the-shelf modelling approaches like Stan offer great flexibility in formulating a model, but the Markov Chain Monte Carlo algorithms they use are slow on large datasets, which hinders model iteration. Kalman filters can provide much faster, exact posterior probabilities, by assuming that the uncertainties are Gaussian and that the hidden state evolution is linear. We have built a probabilistic programming language around the switching Kalman filter algorithm. It was implemented as a Julia macro, and supports Unitful time series with missing data. I will present its design, implementation and some of its applications. false https://pretalx.com/juliacon2019/talk/BD9EBF/ https://pretalx.com/juliacon2019/talk/BD9EBF/feedback/ NS Room 130 Keynote 2019-07-25T08:40:00-04:00 08:40 00:45 Heather Miller is an Assistant Professor in the School of Computer Science at Carnegie Mellon, where she is affiliated with the Institute for Software Research. Prior to joining the faculty at CMU, Professor Miller not only worked as a research scientist at [EPFL](https://www.epfl.ch/research/), but also co-founded and served as the Executive Director for the [Scala Center](https://scala.epfl.ch/), a nonprofit focused on software development, education, and research surrounding the open source Scala programming language. She continues to work on and around Scala, while pursuing research on various flavors of distributed and concurrent computation. Some of her projects underway include programming models and type systems to facilitate the design of new, functional distributed systems. juliacon2019-2561-keynote-professor-heather-miller Professor Heather Miller en false https://pretalx.com/juliacon2019/talk/JUZUDM/ https://pretalx.com/juliacon2019/talk/JUZUDM/feedback/ NS Room 130 Talk 2019-07-25T09:30:00-04:00 09:30 00:30 I'll describe some of the more fundamental issues in Julia today, as I see it, and how we can potentially solve them to get a better language. juliacon2019-1103-what-s-bad-about-julia Jeff Bezanson en As everyone knows, the problem with Julia is that it uses 1-based indexing! Well, of course that's not it, but are there any *real* problems? While there are any number of readily apparent issues involving performance, missing functionality, and so on, those are being fixed every day. Subtler issues lurk beneath the surface. In this talk I will present some of the tricker, more hidden, and more fundamental problems involving the type system, object model, and core language generally --- things that keep me up at night. For example, did you know that Julia's types are not closed under intersection, but that it would be nice if they were? The good news is that these are all things I believe we can solve --- in time --- to make Julia a meaningfully better language. false https://pretalx.com/juliacon2019/talk/ZFQHDS/ https://pretalx.com/juliacon2019/talk/ZFQHDS/feedback/ NS Room 130 Sponsor's Address 2019-07-25T10:00:00-04:00 10:00 00:05 An address from one of our sponsors. juliacon2019-2570-sponsor-address-university-of-maryland /media/juliacon2019/images/PK738L/umb1_QigHLxq.jpg Vijay Ivaturi en false https://pretalx.com/juliacon2019/talk/PK738L/ https://pretalx.com/juliacon2019/talk/PK738L/feedback/ NS Room 130 Keynote 2019-07-25T13:30:00-04:00 13:30 00:45 Steven Lee is an Applied Mathematics Program Manager for Advanced Scientific Computing Research (ASCR) within the Department of Energy (DOE), Office of Science. Most recently, Steven and an organizing committee issued a [brochure](https://www.osti.gov/biblio/1484362) and [workshop report](https://www.osti.gov/biblio/1478744) on Scientific Machine Learning: Core Technologies for Artificial Intelligence. He has also been an ASCR Program Manager within the Scientific Discovery through Advanced Computing program ([SciDAC-3](https://www.scidac.gov/) Institutes) for the projects: [FASTMATH](https://science.energy.gov/~/media/ascr/pdf/research/scidac/FASTMath-overview.pdf) - Frameworks, Algorithms and Scalable Technologies for Mathematics; and [QUEST](https://science.energy.gov/~/media/ascr/pdf/research/scidac/QUEST-overview.pdf) - Quantification of Uncertainty for Extreme-Scale Computations. Before joining the DOE, Steven was a computational scientist at Lawrence Livermore National Laboratory and Oak Ridge National Laboratory. He has also been a visiting Assistant Professor in the Department of Mathematics at MIT. He has a Ph.D. in Computer Science (UIUC) and B.S. in Applied Mathematics (Yale). juliacon2019-2564-keynote-dr-steven-lee Dr Steven Lee en false https://pretalx.com/juliacon2019/talk/SSNXAP/ https://pretalx.com/juliacon2019/talk/SSNXAP/feedback/ BoF: Room 353 Birds of Feather 2019-07-25T11:00:00-04:00 11:00 01:00 This BoF will be a forum to discuss the state of the state around performant parallelism for distributed memory programming in Julia. Performance, parallelism, productivity and portability are four P's of distributed memory parallelism that over the last 30 years have proved hard to satisfy simultaneously in a general solution. The goal of this BoF is discussion and exploration of approaches for providing performant distributed memory parallelism in Julia in ways that are portable and that reflect the productivity vision of Julia. The format will consist of a series of presentations and a discussion/Q&A section. It will look both within Julia and across other languages at the last 30 years of efforts in this space. The motivation for the BoF is that meeting the four P's well remains an unsolved problem. For now projects that seek all of performance, parallelism at scale, portability and productivity typically have to make compromises in one or more of these areas. The hoped for outcome is some shared momentum and sharing of ideas for developing Julian approaches that lessen (or eliminate) the need to compromise in any of the four P's in the future. juliacon2019-1080-performant-parallelism-with-productivity-and-portability Valentin ChuravyChris HillAlan EdelmanLucas WilcoxAndreas Noack en This BoF is motivated in part by interesting new application development efforts that are combining high-performant scientific computing style parallelism with large scale machine learning, optimization and statistical methods. The BoF will focus on current and future directions for language and library level abstractions for large distributed parallel applications in Julia. Some projects such as [Celeste](https://juliacomputing.com/case-studies/celeste.html) and [CLiMA](https://clima.caltech.edu) are employing Julia for work that scales to tens of thousands or more parallel cores. The BoF will be a forum for starting conversations and brainstorming how Julia tools for distributed parallelism might evolve in coming years to support both portable, high-performance parallelism and productive interactivity in a relatively unified way. The BoF will include short presentations from current participants in large scale scientific computing parallel efforts using Julia, it will also include short presentations from relevant tool developers as well as an open discussion time for question and answer. We anticipate covering a few interconnected themes and goals. **Blending in new ideas**. In the last 30 years, since the emergence of the message passing interface (MPI) parallel library standard for scientific computing, many projects have explored alternate parallelism paradigms. These alternates, which include UPC, X10, CoArray Fortran, Chapel, Hadoop, Spark, OCCA and many others, have introduced new ideas, but in scientific computing none have gained the broad traction of MPI in practice. One topic of interest for this BoF is where can the Julia language, library and meta-programming ecosystem usefully blend in some of the parallel programming ideas that have emerged in academic projects in the last 30 years. **Enabling interactivity front and center in large scale, high-performance parallelism**. Are there ways Julia might help bring some flavor of productive interactivity to the sorts of applications that have typically leveraged MPI for portable performance. Some debugging tools, from other languages, such as [ddt](https://developer.nvidia.com/allinea-ddt) and [totalview](https://www.roguewave.com/products-services/totalview) may provide models for how to interact explicitly with multiple concurrent streams of computation in a large parallel application under something of a REPL feel. Julia Distributed arrays, Channels and Cluster manager abstractions provide more implicit ways for interacting with parallel computation streams. Using existing components it is already possible to create elaborate applications that mix high-performance parallel simulation and distributed machine learning, for example, in a single workflow. This sort of workflow is emerging in many fields from plasma science to economics. However, current programming approaches can result in a somewhat complex mix of abstractions that are not always amenable to flexible and agile exploration in an interactive environment of the sort that is Julia's hallmark. **Catalyzing activities to discover the right APIs**. The BoF will aim to catalyze conversations and energize projects looking at the next generation of Julia ecosystem tools to support high-performance, parallel scientific computing. In this realm it is likely that many of the key abstractions/APIs are likely to be discovered somewhat organically as much as designed. The BoF seeks to be inclusive to all Julia projects that may have an interest in these areas. The organizers welcome anyone interested in presenting a slide at the BoF to [contact us](mailto:christophernhill+juliacon2019@gmail.com). We plan to gather the BoF material into a post meeting document that will be openly available. true https://pretalx.com/juliacon2019/talk/37VY3Q/ https://pretalx.com/juliacon2019/talk/37VY3Q/feedback/ BoF: Room 353 Birds of Feather 2019-07-25T14:30:00-04:00 14:30 01:00 This session is for gathering the various groups interested in Julia for healthcare purposes. Pharmacometrics, healthcare-focused biological research, and the translation of software to practice will be discussed. juliacon2019-2571-julia-in-healthcare Vijay Ivaturi en true https://pretalx.com/juliacon2019/talk/7RPM7G/ https://pretalx.com/juliacon2019/talk/7RPM7G/feedback/ BoF: Room 353 Birds of Feather 2019-07-25T15:45:00-04:00 15:45 01:00 Everything Pkg: discussion of package management, version resolution, binary artifacts, registries, manifests, configuration, etc. juliacon2019-2630-package-management-bof Stefan Karpinski en true https://pretalx.com/juliacon2019/talk/GMRBWB/ https://pretalx.com/juliacon2019/talk/GMRBWB/feedback/ BoF: Room 353 Birds of Feather 2019-07-25T16:45:00-04:00 16:45 00:50 Casual chats about the uses of Julia in Astronomy, JuliaAstro and related packages and studies. juliacon2019-2634-julia-in-astronomy Mosè Giordano en true https://pretalx.com/juliacon2019/talk/MC8TPZ/ https://pretalx.com/juliacon2019/talk/MC8TPZ/feedback/ Other Break 2019-07-25T07:30:00-04:00 07:30 01:00 Breakfast will be held in the SMC 2nd Floor Lobby juliacon2019-2591-breakfast en false https://pretalx.com/juliacon2019/talk/YX9NNS/ https://pretalx.com/juliacon2019/talk/YX9NNS/feedback/ Other Break 2019-07-25T10:10:00-04:00 10:10 00:50 The poster session will be held in room 349 juliacon2019-2607-poster-session en Posters: - "AMLET meets Julia" by Bastin, Fabian - "JuliaDB: solving the two language problem in analytical databases" by Shashi Gowda - "Mapping the Logic Item Domain with Julia" by Francis Smart - "OrthogonalPolynomials.jl - Optimal evaluation of orthogonal polynomials in ~ 100 lines of Julia" by Miguel Raz Guzmán Macedo - "Oceananigans.jl: fast, friendly, architecture-agnostic, high-performance ocean modeling" by Ali Ramadhan - "Parallel Scenario Decomposition of Stochastic Programming" by Kibaek Kim - "ARCH Models in Julia" by Simon Broda - "Myths, Legends, and Other Amazing Adventures in CSV Parsing" by Jacob Quinn - "Occasionally Binding Constraints in DSGE Models in Julia" by Vivaldo Mendes - "Time Series Analysis and Forecasting with Julia: Nonlinear Autoregressive vs Machine Learning Models" by Diana A. Mendes - "Julia applied in the Factory of the Future" by Thijs Van Hauwermeiren - "NLPeterman.jl: Language processing from the ground up in Julia" by Mihir Paradkar - "Materials.jl for crystal plasticity" by Ivan Yashchuk - "Markov Chain-Monte Carlo Methods for Linear Algebra using Julia v.1.0" by Oscar A. Esquivel-Flores - "Modelling environment for JuliaOpt" by Manuel Marin - "BuyLibre - Cooperative Libre Software Cost-Sharing" by Clark C. Evans - "StateSpaceModels.jl -- A Julia package for time-series analysis in a state-space framework" by Raphael Saavedra - "TileDB: a data management solution tailored for data scientists" by Jake Bolewski - "Growing Machine Learning Solutions on Kubernetes with Julia" by Patrick Barker - "Econometrics.jl for econometric analysis in Julia" by José Bayoán Santiago Calderón - "Bioequivalence Analysis in Julia using Bioequivalence.jl" by José Bayoán Santiago Calderón - "Tackling Stochastic Delay Problems in Julia" by Henrik Sykora - "Julia Web Apps with Mux.jl + Heroku" by Josh Day - "A New Approach of Genre-Based Similarity for User-UserCollaborative Filtering Recommender System" by Mahamudul Hasan - "Real Time Mapping of Epidemic Spread, predict with SIR, Neural Network in Julia" by Rahul Kulkarni ### Info for presenters (This matches the email you've all been sent) We will have two poster sessions during the morning coffee breaks on Wednesday, July 24 and Thursday, July 25 from 10:10AM to 11AM in room 349. Please hang your poster in room 349 by 8:30AM on Wednesday and plan to present during both sessions. If you are unable to present on both days, please let us know. The poster boards provided will be landscape (3 feet by 4 feet) false https://pretalx.com/juliacon2019/talk/GYFPM7/ https://pretalx.com/juliacon2019/talk/GYFPM7/feedback/ Other Break 2019-07-25T12:00:00-04:00 12:00 01:15 Lunch will be held in the SMC 2nd Floor Lobby juliacon2019-2589-lunch en false https://pretalx.com/juliacon2019/talk/XPVUEX/ https://pretalx.com/juliacon2019/talk/XPVUEX/feedback/ Other Break 2019-07-25T15:30:00-04:00 15:30 00:15 A short break between sessions. juliacon2019-2609-short-break en false https://pretalx.com/juliacon2019/talk/NS3ZQK/ https://pretalx.com/juliacon2019/talk/NS3ZQK/feedback/ Elm A Workshop (full day) 2019-07-26T08:30:00-04:00 08:30 08:00 The hackathon. Come work on projects, have discussions about converging ecosystems, and generally hang out. Note: both Elm A and Elm B will be used. juliacon2019-2584-hackathon en false https://pretalx.com/juliacon2019/talk/3JFX8K/ https://pretalx.com/juliacon2019/talk/3JFX8K/feedback/ Other Break 2019-07-26T12:00:00-04:00 12:00 01:15 Lunch will be held in the SMC 2nd Floor Lobby juliacon2019-2590-lunch en false https://pretalx.com/juliacon2019/talk/KLDTNJ/ https://pretalx.com/juliacon2019/talk/KLDTNJ/feedback/