|Track 1 - Room 32-123||Track 2 - Room 32-141|
|9:00||Invitation to Intermediate-Level Julia||Introduction to Writing High Performance Julia|
|13:30||Plots with Plots||Creating, Distributing, and Testing Julia Packages with Binary Dependencies|
|15:00||AFTERNOON BREAK (W/COFFEE)|
|15:15||Parallel computing with Julia|
This is a tutorial workshop on intermediate-level Julia, suitable for anybody who has some programming experience and knows basic Julia syntax. The GitHub repository containing the workshop materials can be found here:
It follows on from the basic Invitation to Julia tutorial from JuliaCon 2015. It is recommended that you browse through that material before attending this tutorial, available at:
We will cover material from the following topics:
Composite types are the data part of "objects" in other languages. Julia is not object-oriented in the traditional sense: methods live outside objects, enabling one of the key features of Julia, multiple dispatch.
Metaprogramming is a powerful technique, and hence frightening and to be respected: it allows you to write Julia code that creates other Julia code. We will build up some examples to simplify this as much as possible.
Open source is about sharing your code. Julia provides a simple way to make a package for your own use that you can easily share with other people to get feedback and contributors. You can convert it into a registered package once it's really ready for distribution.
Bio: David P. Sanders is an associate professor of computational physics in the Department of Physics, Faculty of Sciences, National University of Mexico (UNAM), and is on sabbatical in the Julia group at MIT during 2016. David discovered Julia at the start of 2014 and now uses it exclusively in both teaching and research. He is an author of the ValidatedNumerics.jl package for rigorous numerics, and has given tutorials on Julia at SciPy 2014 and JuliaCon 2015 (see here), with collectively nearly 50,000 views on YouTube.
Arch D. Robison, Intel Corporation
This workshop is an introduction to writing high performance code in Julia. We'll start with a high level view of the hardware and Julia, and how Julia semantics differ from languages such as C/C++/Fortran. Next we'll cover how Julia compiles your program, from your source text down to the machine instructions. The key is to make Julia's type-inference work for you instead of against you, and cater to the hardware. We'll also look at "deals with the devil" annotations (@inbounds, @fastmath, @simd) so that you understand the trade you make with those annotations. Finally, we'll look the art of writing vectorizable code, which brings many of the topics together. Overall, the goal is to understand what you need to do, and what to leave to the compiler, to get high preforming code. Attendees are encouraged to bring a computer with Julia to try exercises that involve speeding up slow examples.The presentation and exercises can be found here:
Bio: Arch D. Robison was the lead developer for KAI C++, the original architect of Intel Threading Building Blocks, and one of the authors of *Structured Parallel Programming: Patterns for Efficient Computation*. He contributed type-based alias analysis and vectorization support to Julia. Arch took 2nd place in Al Zimmerman’s "Delacorte Numbers" programming contest using Julia exclusively. His Erdös number is 3.
A hands-on workshop of how to hack visualizations with Plots.jl and the various backends it supports.
Bio: Tom Breloff has spent a decade in finance building and running algorithmic trading operations. A self-proclaimed mad scientist, studying different subjects related to AGI (neuroscience, deep learning, etc), he has a heavy background in high throughput systems and data visualization in finance. Tom has a B.A. in Mathematics and B.S. in Economics from the Unversity of Rochester, and a M.S. from NYU Courant Institute.
Tony Kelman, Julia Computing
I will cover the process and tools for creating Julia packages that wrap C (or Fortran) libraries. Working through a small example I will cover how to initially get basic functionality working interactively from the REPL, then structure the code as a Julia package. We will begin working from a single development platform, then proceed to show how to build, distribute, and leverage automated testing tools to get the C library and wrapper Julia package working across common Linux distributions, Mac OS X, and Windows. The GitHub repository containing the workshop notebook can be found here:
Bio: Tony Kelman recently completed a Ph.D. in Mechanical Engineering at Berkeley, doing research in optimization based control. He began contributing to open source in 2012 with build system improvements to the COIN-OR set of optimization solver libraries. He started using and contributing to Julia in early 2014, and joined Julia Computing in late 2015.
Viral Shah, Shashi Gowda, Andreas Noack, Ranjan Anantharaman, Amit Murthy
This workshop will give an overview of tools in Julia for dealing with large amounts of data.
Building Blocks for parallel computing in Julia:
MPI and Elemental
ComputeFramework - out of core parallel computations
Bio: Prolific contributors to the Julia ecosystem.