David P. Sanders
A tutorial introduction to Julia for scientific computing, aimed at people who already know a scientific computing language but are new to Julia.
This will be an improved and streamlined version of my SciPy 2014 tutorial listed at julialang.org/learning, based around Jupyter notebooks.
Bio: I am an associate professor of computational physics in the Department of Physics, Faculty of Sciences, National University of Mexico (UNAM). I first heard about Julia in the summer of 2013 at SciPy, but did not really discover it until the beginning of 2014. Since then I have switched to using it full time for both teaching and research. I am an author of the `ValidatedNumerics.jl` and `BilliardModels.jl` packages. At SciPy 2014, I gave a 4-hour Julia tutorial, listed on the Learning section of the Julia web-page, which has over 20,000 views.
Iain Dunning, Joey Huchette, Miles Lubin, Madeleine Udell
Optimization provides a powerful framework for decision making: from path planning, to resource allocation, to data fitting, and everything in between. There are a variety of powerful open-source and commercial packages for solving structured mathematical optimization problems, but identifying the right framework for a given problem can be tricky. This workshop will introduce JuMP and Convex.jl, two modeling languages under the JuliaOpt organization that allow users to easily express linear, mixed-integer, conic, semidefinite, and nonlinear optimization problems in Julia. So easily, in fact, that the user may not even need to know what these problem types are. These models can then be solved using any package in the JuliaOpt ecosystem that supports the problem type. We will introduce basic syntax, provide an overview of the complementary capabilities of both JuMP and Convex.jl, and walk through a number of hands-on examples using Jupyter notebooks.
Bio: Iain Dunning, Joey Huchette, and Miles Lubin are PhD candidates at the Operations Research Center at MIT. They are early adopters of Julia and developers of JuMP. Madeleine Udell, a developer of Convex.jl, is a postdoctoral fellow at the Center for the Mathematics of Information at Caltech. She recently received a PhD in Computational and Mathematical Engineering at Stanford, and will be joining Cornell as an assistant professor in Operations Research and Information Engineering in 2016. All four are members of the JuliaOpt organization, which curates high quality optimization software in Julia.
From the very beginning, Julia has had first class support for calling native C code. On top of this functionality, language interop with other languages such as Python, Java and Ruby have been developed.
This workshop will offer a hands on tutorial on using external libraries written in C, C++, Java, Python and Ruby from within Julia
We will focus first and foremost on calling C libraries. We will describe how types are mapped, and see how to pass structs and callback functions. We will then take an indepth look at calling Python and Java code via the PyCall and JavaCall packages. Finally, time permitting, we will briefly touch upon the ability to call Ruby and C++ libraries.
Bio: Avik Sengupta has built risk and trading systems in Java for investment banks for over a decade. Three years ago he discovered Julia, and hasn't looked back since. He is a Julia contributor and the maintainer of a few Julia packages.
Arch D. Robison
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 dive into how Julia compiles your program, all the way from your source text to the machine instructions. A focus will be on the compiler’s type-inference engine and how to make it work for you instead of against you. Another focus will be how to cater to the hardware. We’ll also look at “deals with the devil” annotations (@inbounds, @fastmath, @simd) so that you understand what kind of trade you make with those annotations. Finally, we’ll look the art of writing vectorizable code, which brings many of the topics into play.
Attendees are encouraged to bring a computer with Julia installed on it so that they can try exercises that involve speeding up slow examples.
Bio: Arch was the lead developer for KAI C++, and the original architect of Intel Threading Building Blocks. 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.
With its initial focus on high-performance and scientific computing, the Julia language can be intimidating for newer users. However, using Julia is not just about being a speed demon; with a clean syntax and rapidly growing package eco-system, Julia can be used for “everyday” tasks as summary statistics, accessing web APIs and databases and interactive data visualization.
Randy will demonstrate an end-to-end example of a data analysis workflow, from downloading publicly available data to loading data into Julia, creating summaries and answering business questions using visualization (Gadfly/Plot.ly).
Bio: Randy Zwitch is a Senior Data Scientist/Data Engineer at Comcast, studying how customers consume the its product offerings using Hadoop and related big data technologies. Randy has contributed mostly unit tests to the main Julia project. He has also created several packages (UAParser, Twitter, OAuth, LogParser) and actively participates in the JuliaWeb organization.
Managing data in any language can be a hassle. Varying file formats, data layouts, character sets, compression techniques, not to mention the actual code for manipulating data.
In this talk, some old standards (ODBC, SQLite) are revisited for their on-going usefulness and stability in managing data, while some new methods are also explored that leverage the power of Julia and novel user interfaces.
Bio: Currently a technical consultant at Domo in Utah. Just graduated from Carnegie Mellon in Pittsburgh. Developing Julia for about 3 years now, and own/maintain the ODBC, SQLite, SuffixArrays, TimeZones, Dates, and Yelp packages, as well as the Sublime-IJulia package for Sublime Text. Also been involved in several significant projects involve Base Julia functionality.
This is a workshop conducted by the folks who have been working on various aspects of parallel computing in Julia - Andreas Noack Jensen, Amit Murthy, Tanmay Mohapatra, Jiahao Chen, Jake Bolewski, Alan Edelman.
This workshop will provide an overview of parallel computing in Julia. It will start with an introduction to using built-in Julia primitives for parallel processing, such as pmap, @parallel, remotecall, spawn, fetch, etc. Based on this low-level primitives, shared arrays and distributed arrays have been built. Finally we will try some Parallel Linear Algebra using packages such as ScaLapack along with some MPI programming. We will also look at the possibilities of data processing with data loaded from the Hadoop file system (HDFS) and/or S3. We will also preview the upcoming multi-threading capabilities in Julia. For some of the examples, the workshop will use additional compute resources through AWS or MIT.
Bio: Viral is one of the co-creators of Julia. Please see the LinkedIn page for more details: https://in.linkedin.com/in/viralbshah
In this workshop, I will introduce Escher’s end-user API to Julians. Participants will install Escher and build some cool web apps in a hands-on session. These will include:
Bio: I make UI tools for Julia and JuliaBox users. I brought @manipulate to your IJulia notebooks. :)