+ 
+ 
+ SAVE THE DATE: JuliaCon 2015 will be held at the MIT Stata Center during the dates of Wednesday, June 24 through Sunday, June 28. More details forthcoming.
+Thank you for making the first-ever JuliaCon a smashing success! Recordings of the talks and discussion sessions are now up and linked to in the schedule below.
+The first-ever Julia conference will take place June 26 and 27 (Thursday and Friday) at the University of Chicago Gleacher Center in Chicago, Illinois. Expect two days of cutting-edge technical talks, a chance to rub shoulders with Julia's creators, and a weekend in a city known for its beautiful lakefront and world-class architecture.
++
| 8:00 AM | +space opens, coffee and light breakfast | +
| 8:15 AM | +opening remarks | +
+
| 8:30 AM | +Tim Holy — Image Representation and Analysis | +
| 9:10 AM | +Pontus Stenetorp — Natural Language Processing with Julia | +
| 9:50 AM | +break | +
| 10:20 AM | +breakout session — speed vs. correctness (led by Arch Robison) | +
+
| 11:10 AM | +Iain Dunning / Joey Huchette — JuliaOpt - Optimization Packages for Julia | +
| 11:50 AM | +Madeleine Udell — Convex Optimization in Julia | +
+
| 12:30 PM | +lunch | +
+
| 2:00 PM | +Douglas Bates — Fitting Statistical Models with Julia | +
| 2:40 PM | +John Myles White — Representing Data in Julia | +
| 3:20 PM | +break | +
| 3:35 PM | +Simon Byrne — Distributions.jl | +
| 4:15 PM | +Dan Wlasiuk — A Brief History of TimeSeries | +
+
| 4:25 PM | +break | +
+
| 4:40 PM | +Reid Atcheson — Rapidly Iterating from Prototype to Near-C Performance in Julia: A Finite Element Method Case Study | +
| 5:20 PM | +Avik Sengupta — Moving Julia into Production | +
| 8:00 AM | +space opens, coffee and light breakfast | +
+
| 8:30 AM | +Arch Robison — Practical Vectorization in Julia | +
| 9:10 AM | +Jeff Bezanson — Introduction to Julia Internals | +
| 9:50 AM | +Julia Core Team panel | +
| 10:20 AM | +break | +
| 10:40 AM | +Leah Hanson — TypeCheck: Static Analysis in Julia | +
| 11:20 AM | +Keno Fischer — The design and implementation of the Julia Debugger | +
| 12:00 PM | +breakout session — package ecosystem (led by Iain Dunning) | +
+
| 12:30 AM | +lunch | +
+
| 2:00 PM | +Yuri Vishnevsky — Generative Art with Julia | +
| 2:10 PM | +Michael Bean — Publishing Online Interactive Julia Models | +
| 2:50 PM | +Daniel C. Jones — Gadfly: native Julia plotting and visualization | +
| 3:30 PM | +break | +
| 3:50 PM | +Spencer Russell — Realtime Audio in Julia with AudioIO.jl | +
| 4:30 PM | +breakout session — graphics and visualization (led by Daniel C. Jones) | +
+
+ JuliaCon will be a single-track conference consisting primarily of contributed talks. All users and developers of Julia are encouraged to attend and submit a talk proposal. If you're doing something interesting with the language — academic work, commercial product, open source project, whatever — we want to hear about it. Talk proposals should include a title, abstract, estimated duration, and brief speaker bio. We have a limited amount of travel funding available for those in need, please indicate on the talk submission form if you would like to be considered for a grant. Talk proposals are now closed. If you submitted a talk, expect to hear back from us soon.
+The conference will take place at Gleacher Center, a state-of-the-art facility on the Chicago River in downtown Chicago. Gleacher Center is a short walk from Millennium Station, the Red Line, and the Loop. There are many hotels within walking distance, including the Embassy Suites, Sheraton Chicago, and Hyatt Regency.
+ +
+ Tickets are sold out. We hope to see you next year!
+Please note that we are still releasing the last few tickets to those already on the waitlist.
+The day after the main event, hack@uchicago will host a (free) Julia Hack Day at the University of Chicago's main campus in Hyde Park. Hack Day is free but requires separate registration.
+ +
+ 
+ 
+ 
+ 
+ 
+ 
+ Please email us at juliacon2014@mit.edu with any questions or concerns.
+All attendees, speakers, sponsors, and volunteers at our conference are required to agree with and follow the code of conduct. As this is a University of Chicago event, attendees should also respect the Policy on Unlawful Discrimination and Harassment.
+ +JuliaCon is dedicated to providing a harassment-free conference experience for everyone, regardless of gender, sexual orientation, disability, physical appearance, body size, race, religion, or tabs vs spaces preference. We do not tolerate harassment of conference participants in any form. Sexual language and imagery is not appropriate for any conference venue.
+ +Harassment includes offensive verbal comments, sexual images in public spaces, deliberate intimidation, stalking, following, harassing photography or recording, sustained disruption of talks or other events, inappropriate physical contact, and unwelcome sexual attention. Participants asked to stop any harassing behavior are expected to comply immediately.
+ +If a participant engages in harassing behavior, the conference organizers may take any action they deem appropriate, including warning the offender or expulsion from the conference with no refund. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact a member of conference staff immediately. Conference staff will be happy to help participants contact hotel/venue security or local law enforcement, provide escorts, or otherwise assist those experiencing harassment to feel safe for the duration of the conference. We value your attendance.
+ +We expect participants to follow these rules at all conference venues and conference-related social events.
+ +If an incident occurs please contact Stefan Karpinski <stefan@karpinski.org> or Leah Hanson <astrieanna@gmail.com>.
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+ + JuliaCon 2015 was a huge success with a packed schedule. +
Special hotel pricing available - learn more
++ The second Julia conference will + take place June 24th-27th, 2015 (Wednesday-Saturday) at the + Massachusetts Institute of Technology in Cambridge, Massachusetts. Expect + cutting-edge technical talks, hands-on workshops, a chance to rub + shoulders with Julia's creators, and a weekend in a city known for its + historical significance and colonial architecture. + Purchase tickets here. +
++
Not sure what to expect? Have a look at JuliaCon 2014's program and videos.
+ +The conference will be held in the Ray and Maria Stata Center. + The registration table, where name badges should be collected, will be located + outside room 32-123 on the ground floor. Sessions are held in either 32-123, 32-141, or 32-144. + Click the dates to see talk abstracts and speaker biographies.
+ +The doors along Vassar Street will be unlocked on Saturday
. + +
+
+ + The registration table, where name badges should be collected, will be located + outside room 32-123 on the ground floor. Sessions are held in either 32-123, 32-141, or 32-144. + Click the dates to see talk abstracts and speaker biographies.
+| 08:00 | Registration, coffee and light breakfast | |
| 08:30 | Hackathon Begins | |
| 11:30 | JSoC participants | Lightning talks about JSoC 2015 projects |
| 01:30 - 04:30 | David P. Sanders | Workshop: Invitation to Julia for scientific computing (video) (Room 32-123) |
| 03:00 | Break | |
| 06:30 | Hackathon Ends |
| 08:15 | Coffee and light breakfast | |
| 08:45 | Opening Remarks | |
| 08:55 | Gordon and Betty Moore Foundation |
| 09:00 | Kyle Barbary | JuliaAstro (video) |
| 09:10 | Daniel C. Jones | BioJulia: A modern bioinformatics framework (video) |
| 09:50 | Spencer Lyon | Methods, Models, and Moments: Julian Economics with QuantEcon.jl (video) |
| 10:30 | Break (30 Minutes) | |
| 11:00 | Katharine Hyatt | Quantum Statistical Simulations with Julia (video) |
| 11:40 | David Beach | Introducing Julia into a Python/C++ Scientific Computing Environment (video) |
| 11:50 | Art Diky | Climate classification and clustering with Julia (video) |
| 12:00 | BlackRock, Inc. |
| 12:05 | Lunch |
| 01:30 | Simon Danisch | Hypersignals, a bold vision for interactive Data Visualization (video) |
| 02:10 | Jack Minardi | 3D Printing with Julia: Presenting "Euclid", a new high performance multimaterial slicer (video) |
| 02:50 | Josef Heinen | GR.jl - Plotting for Julia based on GR (video) |
| 03:00 | Break (20 Minutes) | |
| 03:20 | Mike Innes | Building web-powered applications in Julia (video) |
| 04:00 | Zachary Yedidia | SFML.jl -- A package for the Simple Fast Multimedia Library (video) |
| 04:10 | Shashi Gowda | Escher.jl: A new way to make and deploy GUIs (video) |
| 04:20 | Viral B. Shah | JuliaBox - Julia in your browser (video) |
| 04:30 | Sebastien Martin | Taxi fleet simulation and visualization (video) |
| 01:30 | Zenna Tavares | Julia as a Probabilistic Programming Language |
| 02:10 | Chiyuan Zhang | Mocha.jl - Deep Learning for Julia (video) |
| 02:50 | Simon Kornblith | L1 regularized regression (video) |
| 03:00 | Break (20 Minutes) | |
| 03:20 | Pontus Stenetorp | Suitably Naming a Child with Multiple Nationalities using Julia (video) |
| 04:00 | John Myles White | What needs to be done to move JuliaStats forward (video) |
| 04:40 | Break |
| 5:00 | Tony Fong | Lint.jl (video) |
| 5:40 | Tony Kelman | How to support Windows: cross-platform installation and testing for Julia packages (video) |
| 5:50 | Isaiah Norton | Automatic ccall wrapper generation with Clang.jl (video) |
| 6:00 | Iain Dunning | Julia's Package Ecosystem: Past, Present, and Future (video) |
| 6:10 | Sorami Hisamoto | What’s going on at JuliaTokyo? (video) |
| 6:20 | Leah Hanson | Contributing to Julia (video) |
| 6:30 | Discussion: Contributing & Ecosystem |
| 07:00 | Hang out with other Julians |
| 08:15 | Coffee and light breakfast | |
| 08:55 | Julia Computing |
| 09:00 | Jeff Bezanson | The base language: future directions and speculations (video) |
| 09:40 | Jake Bolewski | Staged Programming in Julia (video) |
| 10:20 | Westley Hennigh | Who optimizes the optimizers? Can genetic algorithms help us to + optimize the layout of LLVM IR passes used to compile Julia code? (video) |
| 10:30 | Break (30 Minutes) | |
| 11:00 | Keno Fischer | Shaving the Yak: Why Julia now has one of the best C++ FFIs and what to do with it (video) |
| 11:40 | Mauro Werder | Traits.jl, interfaces for Julia (video) |
| 11:50 | Jacob Quinn | What Happens When: From Parse-Time to Compile-Time (video) |
| 12:00 | Douglas Bates | Mixing it up: Adventures with statistical models and sparse matrices (video) |
| 12:10 | Group photo and Lunch |
| 01:30 | Jack Poulson | Distributed-memory "direct" linear algebra and optimization (video) |
| 02:10 | Zhang Xianyi | Introduction to OpenBLAS and BLIS (video) |
| 02:50 | Break (20 Minutes) | |
| 03:10 | Viral B. Shah | The present and future of sparse matrices in Julia. (video) |
| 03:50 | David P. Sanders | Validated numerics in Julia (video) |
| 04:00 | Luis Benet | Taylor series expansions in julia (video) |
| 04:10 | Hongbo Rong, Jongsoo Park | Sparse Accelerator |
| 01:30 | Robert Moss | Using Julia as a Specification Language for the Next-Generation Airborne Collision Avoidance System (slides) (video) |
| 02:10 | Lars Ruthotto | Distributed Algorithms for Full-Waveform-Inversion (FWI) (video) |
| 02:50 | Break (20 Minutes) | |
| 03:10 | Iain Dunning | JuliaOpt: Optimization-related projects in Julia (video) |
| 03:50 | Yee Sian Ng | JuliaGeo: Working with Geospatial data in Julia |
| 04:00 | Blake Johnson | Quickly building simulations of quantum systems (video) |
| 04:10 | Kevin Damazyn and Mark Tabor | SLU-TMI - TextMining.jl (video) |
| 04:20 | Break |
| 04:40 | Simon Kornblith | JLD: Saving Julia objects to the disk in HDF5 format (video) |
| 05:20 | Avik Sengupta | Serving up : A practical guide to exposing Julia APIs on the web (video) |
| 05:30 | Tanmay Mohapatra | ProtoBuf.jl - + Interfacing Julia with Complex systems using Protocol Buffers (video) |
| 05:40 | Bob Carpenter | Stan.jl: Statistical Modeling and Inference Made Easy (video) |
| 05:50 | Eric Davies | Towards A Consistent Database Interface (video) |
| 06:00 | Discussion: Databases and Interchange |
| 04:30 | Amit Murthy | Cluster Managers and Parallel Julia (video) |
| 05:10 | Kiran Pamnany Ranjan Anantharaman | Multi-threading Julia (video) |
| 05:50 | Patrick Sanan | Using Julia on a Cray Supercomputer (video) |
| 06:00 | Julia Yang | Distilling RUM with Julia (video) |
| 06:10 | Break |
| 06:20 | Closing Remarks |
| 09:00-11:30 |
+ Iain Dunning,
+ Joey Huchette, + Miles Lubin, + Madeleine Udell | Solving optimization problems with JuliaOpt (video) (Rm. 32-123) |
| 09:00-11:30 | Avik Sengupta | Julia and the world: How to work with C/C++/Java/Python/Ruby from Julia (video) (Rm. 32-141) |
| 11:30-1:00 | Lunch |
| 01:00-04:00 | Arch D. Robison | Introduction to Writing High Performance Julia (video) (Rm. 32-123) |
| 01:00-02:30 | Randy Zwitch | Everyday Analytics and Visualization (video) (Rm. 32-141) |
| 02:45-04:15 | Jacob Quinn | Managing Data in Julia: Old Tricks, New Tricks (video) (Rm. 32-141) |
| 04:30-06:30 | Viral B. Shah | Parallel computing with Julia (Rm. 32-123) |
| 04:30-06:30 | Shashi Gowda | Making GUIs with Escher.jl (video) (Rm. 32-141) |
+
+ 
+
+ |
+
+
+ 
+
+ |
+
+
+ 
+
+ |
+
+
+ 
+
+ |
+
+
+ 
+
+ |
+
+
+ 
+
+ |
+
+
+ 
+
+ |
+
Our host hotel for JuliaCon is nearby:
+ + Hyatt Regency HotelThe hotel is within walking distance from MIT. Complimentary shuttle service will also be available. Rooms are newly renovated and with free Internet access. The guest room rates are quoted exclusive of applicable state and local taxes (which are currently 14.45%), applicable service fees, and/or hotel-specific fees in effect at the time of the event.
+ +Rooms are available from the Hyatt's website or by calling 888-421-1442. If you have problems booking a room please contact Caitlin Hanna and also please let us know.
+ +The Hyatt Cambridge is sold out for Wednesday, June 24, but rooms are still available for Thursday through Saturday.
+ + +The JuliaCon program committee is composed of entirely of volunteer organizers and can be reached at juliacon@julialang.org with any questions or comments.
++ There are three tiers of sponsorship available. +
+ If you have any questions, feel free to contact Hunter Owens of the JuliaCon program committee at hunter@hunterowens.net or 310-592-6639. +
+All attendees, speakers, sponsors, and volunteers at our conference are required to agree with and follow the code of conduct. As this is a MIT Event, attendees should also respect the Policy on Harassment.
+ +JuliaCon is dedicated to providing a harassment-free conference experience for everyone, regardless of gender, sexual orientation, disability, physical appearance, body size, race, religion, or tabs vs spaces preference. We do not tolerate harassment of conference participants in any form. Sexual language and imagery is not appropriate for any conference venue.
+ +Harassment includes offensive verbal comments, sexual images in public spaces, deliberate intimidation, stalking, following, harassing photography or recording, sustained disruption of talks or other events, inappropriate physical contact, and unwelcome sexual attention. Participants asked to stop any harassing behavior are expected to comply immediately.
+ +If a participant engages in harassing behavior, the conference organizers may take any action they deem appropriate, including warning the offender or expulsion from the conference with no refund. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact a member of conference staff immediately. Conference staff will be happy to help participants contact hotel/venue security or local law enforcement, provide escorts, or otherwise assist those experiencing harassment to feel safe for the duration of the conference. We value your attendance.
+ +We expect participants to follow these rules at all conference venues and conference-related social events.
+ +If an incident occurs please contact Stefan Karpinski <stefan@karpinski.org> or Leah Hanson <astrieanna@gmail.com>.
+
+
+
+
+
+
+
+ + JuliaCon 2015 was a huge success with a packed schedule. +
Special hotel pricing available - learn more
++ The second Julia conference will + take place June 24th-27th, 2015 (Wednesday-Saturday) at the + Massachusetts Institute of Technology in Cambridge, Massachusetts. Expect + cutting-edge technical talks, hands-on workshops, a chance to rub + shoulders with Julia's creators, and a weekend in a city known for its + historical significance and colonial architecture. + Purchase tickets here. +
++
Not sure what to expect? Have a look at JuliaCon 2014's program and videos.
+ +The conference will be held in the Ray and Maria Stata Center. + The registration table, where name badges should be collected, will be located + outside room 32-123 on the ground floor. Sessions are held in either 32-123, 32-141, or 32-144. + Click the dates to see talk abstracts and speaker biographies.
+ +The doors along Vassar Street will be unlocked on Saturday
. + +
+
+ + The registration table, where name badges should be collected, will be located + outside room 32-123 on the ground floor. Sessions are held in either 32-123, 32-141, or 32-144. + Click the dates to see talk abstracts and speaker biographies.
+| 08:00 | Registration, coffee and light breakfast | |
| 08:30 | Hackathon Begins | |
| 11:30 | JSoC participants | Lightning talks about JSoC 2015 projects |
| 01:30 - 04:30 | David P. Sanders | Workshop: Invitation to Julia for scientific computing (video) (Room 32-123) |
| 03:00 | Break | |
| 06:30 | Hackathon Ends |
| 08:15 | Coffee and light breakfast | |
| 08:45 | Opening Remarks | |
| 08:55 | Gordon and Betty Moore Foundation |
| 09:00 | Kyle Barbary | JuliaAstro (video) |
| 09:10 | Daniel C. Jones | BioJulia: A modern bioinformatics framework (video) |
| 09:50 | Spencer Lyon | Methods, Models, and Moments: Julian Economics with QuantEcon.jl (video) |
| 10:30 | Break (30 Minutes) | |
| 11:00 | Katharine Hyatt | Quantum Statistical Simulations with Julia (video) |
| 11:40 | David Beach | Introducing Julia into a Python/C++ Scientific Computing Environment (video) |
| 11:50 | Art Diky | Climate classification and clustering with Julia (video) |
| 12:00 | BlackRock, Inc. |
| 12:05 | Lunch |
| 01:30 | Simon Danisch | Hypersignals, a bold vision for interactive Data Visualization (video) |
| 02:10 | Jack Minardi | 3D Printing with Julia: Presenting "Euclid", a new high performance multimaterial slicer (video) |
| 02:50 | Josef Heinen | GR.jl - Plotting for Julia based on GR (video) |
| 03:00 | Break (20 Minutes) | |
| 03:20 | Mike Innes | Building web-powered applications in Julia (video) |
| 04:00 | Zachary Yedidia | SFML.jl -- A package for the Simple Fast Multimedia Library (video) |
| 04:10 | Shashi Gowda | Escher.jl: A new way to make and deploy GUIs (video) |
| 04:20 | Viral B. Shah | JuliaBox - Julia in your browser (video) |
| 04:30 | Sebastien Martin | Taxi fleet simulation and visualization (video) |
| 01:30 | Zenna Tavares | Julia as a Probabilistic Programming Language |
| 02:10 | Chiyuan Zhang | Mocha.jl - Deep Learning for Julia (video) |
| 02:50 | Simon Kornblith | L1 regularized regression (video) |
| 03:00 | Break (20 Minutes) | |
| 03:20 | Pontus Stenetorp | Suitably Naming a Child with Multiple Nationalities using Julia (video) |
| 04:00 | John Myles White | What needs to be done to move JuliaStats forward (video) |
| 04:40 | Break |
| 5:00 | Tony Fong | Lint.jl (video) |
| 5:40 | Tony Kelman | How to support Windows: cross-platform installation and testing for Julia packages (video) |
| 5:50 | Isaiah Norton | Automatic ccall wrapper generation with Clang.jl (video) |
| 6:00 | Iain Dunning | Julia's Package Ecosystem: Past, Present, and Future (video) |
| 6:10 | Sorami Hisamoto | What’s going on at JuliaTokyo? (video) |
| 6:20 | Leah Hanson | Contributing to Julia (video) |
| 6:30 | Discussion: Contributing & Ecosystem |
| 07:00 | Hang out with other Julians |
| 08:15 | Coffee and light breakfast | |
| 08:55 | Julia Computing |
| 09:00 | Jeff Bezanson | The base language: future directions and speculations (video) |
| 09:40 | Jake Bolewski | Staged Programming in Julia (video) |
| 10:20 | Westley Hennigh | Who optimizes the optimizers? Can genetic algorithms help us to + optimize the layout of LLVM IR passes used to compile Julia code? (video) |
| 10:30 | Break (30 Minutes) | |
| 11:00 | Keno Fischer | Shaving the Yak: Why Julia now has one of the best C++ FFIs and what to do with it (video) |
| 11:40 | Mauro Werder | Traits.jl, interfaces for Julia (video) |
| 11:50 | Jacob Quinn | What Happens When: From Parse-Time to Compile-Time (video) |
| 12:00 | Douglas Bates | Mixing it up: Adventures with statistical models and sparse matrices (video) |
| 12:10 | Group photo and Lunch |
| 01:30 | Jack Poulson | Distributed-memory "direct" linear algebra and optimization (video) |
| 02:10 | Zhang Xianyi | Introduction to OpenBLAS and BLIS (video) |
| 02:50 | Break (20 Minutes) | |
| 03:10 | Viral B. Shah | The present and future of sparse matrices in Julia. (video) |
| 03:50 | David P. Sanders | Validated numerics in Julia (video) |
| 04:00 | Luis Benet | Taylor series expansions in julia (video) |
| 04:10 | Hongbo Rong, Jongsoo Park | Sparse Accelerator |
| 01:30 | Robert Moss | Using Julia as a Specification Language for the Next-Generation Airborne Collision Avoidance System (slides) (video) |
| 02:10 | Lars Ruthotto | Distributed Algorithms for Full-Waveform-Inversion (FWI) (video) |
| 02:50 | Break (20 Minutes) | |
| 03:10 | Iain Dunning | JuliaOpt: Optimization-related projects in Julia (video) |
| 03:50 | Yee Sian Ng | JuliaGeo: Working with Geospatial data in Julia |
| 04:00 | Blake Johnson | Quickly building simulations of quantum systems (video) |
| 04:10 | Kevin Damazyn and Mark Tabor | SLU-TMI - TextMining.jl (video) |
| 04:20 | Break |
| 04:40 | Simon Kornblith | JLD: Saving Julia objects to the disk in HDF5 format (video) |
| 05:20 | Avik Sengupta | Serving up : A practical guide to exposing Julia APIs on the web (video) |
| 05:30 | Tanmay Mohapatra | ProtoBuf.jl - + Interfacing Julia with Complex systems using Protocol Buffers (video) |
| 05:40 | Bob Carpenter | Stan.jl: Statistical Modeling and Inference Made Easy (video) |
| 05:50 | Eric Davies | Towards A Consistent Database Interface (video) |
| 06:00 | Discussion: Databases and Interchange |
| 04:30 | Amit Murthy | Cluster Managers and Parallel Julia (video) |
| 05:10 | Kiran Pamnany Ranjan Anantharaman | Multi-threading Julia (video) |
| 05:50 | Patrick Sanan | Using Julia on a Cray Supercomputer (video) |
| 06:00 | Julia Yang | Distilling RUM with Julia (video) |
| 06:10 | Break |
| 06:20 | Closing Remarks |
| 09:00-11:30 |
+ Iain Dunning,
+ Joey Huchette, + Miles Lubin, + Madeleine Udell | Solving optimization problems with JuliaOpt (video) (Rm. 32-123) |
| 09:00-11:30 | Avik Sengupta | Julia and the world: How to work with C/C++/Java/Python/Ruby from Julia (video) (Rm. 32-141) |
| 11:30-1:00 | Lunch |
| 01:00-04:00 | Arch D. Robison | Introduction to Writing High Performance Julia (video) (Rm. 32-123) |
| 01:00-02:30 | Randy Zwitch | Everyday Analytics and Visualization (video) (Rm. 32-141) |
| 02:45-04:15 | Jacob Quinn | Managing Data in Julia: Old Tricks, New Tricks (video) (Rm. 32-141) |
| 04:30-06:30 | Viral B. Shah | Parallel computing with Julia (Rm. 32-123) |
| 04:30-06:30 | Shashi Gowda | Making GUIs with Escher.jl (video) (Rm. 32-141) |
|
+
+
+
+ |
+
+
+
+
+ |
+
+
+
+
+ |
+
|
+
+
+
+ |
+
+
+
+
+ |
+
+
+
+
+ |
+
|
+
+
+
+ |
+
Our host hotel for JuliaCon is nearby:
+ + Hyatt Regency HotelThe hotel is within walking distance from MIT. Complimentary shuttle service will also be available. Rooms are newly renovated and with free Internet access. The guest room rates are quoted exclusive of applicable state and local taxes (which are currently 14.45%), applicable service fees, and/or hotel-specific fees in effect at the time of the event.
+ +Rooms are available from the Hyatt's website or by calling 888-421-1442. If you have problems booking a room please contact Caitlin Hanna and also please let us know.
+ +The Hyatt Cambridge is sold out for Wednesday, June 24, but rooms are still available for Thursday through Saturday.
+ + +The JuliaCon program committee is composed of entirely of volunteer organizers and can be reached at juliacon@julialang.org with any questions or comments.
++ There are three tiers of sponsorship available. +
+ If you have any questions, feel free to contact Hunter Owens of the JuliaCon program committee at hunter@hunterowens.net or 310-592-6639. +
+All attendees, speakers, sponsors, and volunteers at our conference are required to agree with and follow the code of conduct. As this is a MIT Event, attendees should also respect the Policy on Harassment.
+ +JuliaCon is dedicated to providing a harassment-free conference experience for everyone, regardless of gender, sexual orientation, disability, physical appearance, body size, race, religion, or tabs vs spaces preference. We do not tolerate harassment of conference participants in any form. Sexual language and imagery is not appropriate for any conference venue.
+ +Harassment includes offensive verbal comments, sexual images in public spaces, deliberate intimidation, stalking, following, harassing photography or recording, sustained disruption of talks or other events, inappropriate physical contact, and unwelcome sexual attention. Participants asked to stop any harassing behavior are expected to comply immediately.
+ +If a participant engages in harassing behavior, the conference organizers may take any action they deem appropriate, including warning the offender or expulsion from the conference with no refund. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact a member of conference staff immediately. Conference staff will be happy to help participants contact hotel/venue security or local law enforcement, provide escorts, or otherwise assist those experiencing harassment to feel safe for the duration of the conference. We value your attendance.
+ +We expect participants to follow these rules at all conference venues and conference-related social events.
+ +If an incident occurs please contact Stefan Karpinski <stefan@karpinski.org> or Leah Hanson <astrieanna@gmail.com>.
+
+
+
+
+ Daniel C. Jones
+The past decade, DNA sequencing has become dramatically cheaper, faster, and more accurate. Though a revolution for molecular biology research, the increased emphasis on deep sequencing has made bioinformatics software development increasingly inaccessible to non-expert programmers. While Perl, Python, and its ilk were ideal tools ten years ago, the avalanche of data has necessitated a new generation of highly specific standalone C/C++ tools that, while efficient, lack composability and create a high barrier to entry for contributors and reviewers.
+ +With BioJulia we have begun building a Julia framework for computational biology research that is competitive in performance with C/C++ tools while retaining the accessibility and freedom afforded by traditional high-level languages. With a rigorous testing and code review regime, we have emphasized correctness along with speed, laying the groundwork for a vibrant ecosystem of open bioinformatics software.
+ + +Bio: A graduate student at the University of Washington and author of several Julia packages, most notably Gadfly.
+ +Spencer Lyon
+There was a time when economics focused on elegant models of frictionless worlds, but it’s now well understood that in order for economic models to replicate real world data series they must include many frictions. The field of economics is in the process of moving from a pen and paper science to a highly computationally intensive science. In short, economists are a huge academic community moving into the computational sphere and starting to explore the new generation of programming tools. As such, now is a very promising time for interaction between the Julia and economics communities.
+ +The goal of this talk is to introduce Julia users to some of the distinguishing features of computational economics. Among these are dynamic stochastic optimization, statistical inference and data analysis, and stochastic simulation. We will explore the QuantEcon.jl package and how Julia’s expressive type system and advanced compiler make Julia an excellent language for economists.
+ + +Bio: Spencer Lyon is a 2nd year PhD student at NYU studying economics. He has a background in physics. Spencer’s research interests are broadly contained in the subfield of macro-economics, with particular emphasis on asset pricing and international modeling. Spencer is a devoted open source hacker who hails from the Python world. He is the main author of the QuantEcon.jl package and one of the core members of the quant-econ team.
+ +Kyle Barbary
+I will discuss the state of Julia astronomy packages and the small but growing JuliaAstro organization. In the larger astronomy community, many have been moving towards Python over the last decade and this transition is still underway. I will give some perspective on the prospects for the adoption of Julia in astronomy.
+ + +Bio: I am a Cosmology Data Science Fellow at UC Berkeley and the Berkeley Institute for Data Science. I manage several JuliaAstro packages and wrote the Dierckx.jl wrapper for 1-d and 2-d splines.
+ +Katharine Hyatt
+Using high-performance computing to probe quantum systems is becoming more and more common in condensed matter physics research. Many of the commonly used languages and techniques in this space are either difficult to learn or not performant. Julia has allowed us to quickly develop and test codes for a variety of commonly used algorithms, including exact diagonalization, DMRG, and quantum Monte Carlo. Its parallel features, including MPI and GPGPU integration, make it particularly attractive for many quantum simulations. I’ll discuss what features of Julia have been most useful for us when working on these simulations and the developments we’re most excited about.
+ + +David Beach
+Numerica’s Space Situational Awareness (SSA) team develops advanced software for tracking satellites. Most of our software is written in Python, C++, or a hybrid of these. We have become accustomed to making trade-offs between ease of development and performance. In this talk, I will highlight some reasons why Julia could be a game-changer for us, with examples involving problems related to satellite tracking.
+ + +Bio: David Beach has over 15 years of experience developing scientific software, primarily in the finance and defense sectors, and currently designs simulation and target tracking software for the SSA team at Numerica. Over the past year, he's started using Julia for some small projects, and is turning into a staunch advocate.
+ +Art Diky
+We investigate an objective approach to classifying world climate. We compare linear manifold and K-means clustering methods to derive a classification of climate types using long-term monthly climate data sets. Climate clusters are compared to the Köppen-Geiger climate classification system and analyzed where climate class boundaries change.
+Julia language was a main tool used to perform climate data analysis, clustering and reporting. We used Julia to implement the linear manifold (LM) clustering algorithm, LMCLUS.jl, which performs a stochastic search to determine a best location of a bounded LM surrounded by a cluster. Julia provided an outstanding matrix multiplication performance and a parallel computation paradigm which we used in search of a best cluster subspace, along with computationally intensive sensitivity and validation analysis of the clustering results. In our research, we used NetCDF.jl for a data management, Clustering.jl for other clustering methods, Gadfly.jl and RCall.jl for visualizations.
+This is a joint work of NASA Goddard Institute for Space Studies (GISS) and Graduate Center City University manifoldof New York.
Bio: I am a PhD student in Computer Science at City University of New York (CUNY). My research interests are in the areas of machine learning, in particular unsupervised learning and pattern recognition, distributed computation and reinforcement learning. I am vivid Julia enthusiast. I wrote several Julia packages, including ManifoldLearning.jl and Evolutionary.jl, and contributed in testing and error fixing to many other packages.
+ +Simon Danisch
+How can Julia + LLVM + Vulkan(OpenGL 5.0) completely change how we program and interact with data?
+This is a talk about how a signal based event system can implement bold visions like visual debugging of large data sets, or interactive data visualization like envisioned by Bret Victor.
+I will introduce the problems that arise from interactive, high performance visualizations and how they can be solved with state of the art technology.
Bio: I develop infrastructure for Julia's 3D Graphic stack, which I want to utilize for interactive, visual programming. + +I've created the following packages for that purpose: +Romeo, +GLPlot, +GLAbstraction, +GLDraw, +GLText, +GLWindow, +ModernGL, +FixedSizeArrays
+ +Jack Minardi
+Euclid is a high performance multimaterial slicer written in Julia. At Voxel8 we have developed the first multimaterial 3D printer capable of producing fully functional electronics, and we needed a new slicer to drive it. Julia is used in production at Voxel8 to convert 3D models into a toolpath the printer executes to build up the model in a process known as “slicing”. Euclid is a command line application at its core, but we have put it in a Docker container and written a RESTful front-end to interact with it.
+ +This talk will cover our experiences using Julia in production, using Cxx.jl to interface with C++ libraries, as well as some more general 3D printing concepts like:
Bio: Jack Minardi is Co-Founder at Voxel8, where he leads the software team. Voxel8 has created the world’s first multi-material 3D printer for fabricating embedded electronics and other novel devices. Prior to working at Voxel8 Jack was a researcher in the Lewis Lab at Harvard University where he developed software for 3D printing. Jack earned a B.S. in electrical engineering from Vanderbilt University.
+ +Josef Heinen
+Julia is an accepted high-level scripting language for scientific computing and visualization, not least because of the proliferation of libraries such as Gadfly and PyPlot. However, when processing large amounts of data, in particular in combination with three-dimensional plotting (OpenGL), the existing graphics packages are too application-specific or seem to be reaching their limits. In particular, large amounts of data or the visualization of three-dimensional scenes may overwhelm the system.
+ +This presentation shows how visualization applications with special performance requirements can be designed on the basis of GR, a high-performance visualization library for Linux, OS X and Windows. The lecture also introduces a new graphics backend for PyPlot based on the GR framework. By combining the power of those libraries the responsiveness of animated visualization applications and their resulting frame rates can be improved significantly. This in turn allows the use of PyPlot in real-time environments, for example in the area of signal processing.
+ +Using concrete examples, the presentation will demonstrate the benefits of the GR framework for high-performance graphics or as a companion module for PyPlot. Based on selected applications, the suitability of the GR framework will be highlighted especially in environments where time is critical. The system’s performance capabilities will be illustrated using demanding live applications. In addition, the special abilities of the GR framework are emphasized in terms of interoperability with OpenGL, which opens up new possibilities for existing applications.
+ + +Bio: Josef Heinen is the head of the group "Scientific IT-Systems" at the Peter Grünberg Institute / Jülich Centre for Neutron Science, both institutes at Forschungszentrum Jülich, a leading research centre in Germany. The design and development of visualization systems have been an essential part of his activities over the last twenty years. He is involved in several Open Source projects like GLI or GKS. Most recently his team is engaged with the further development of a universal framework for cross-platform visualization applications (GR Framework).
+ +Mike Innes
+I’ll talk about a path less traveled by most Julia developers: making desktop and web applications. Using the nascent Blink.jl library, I’ll demonstrate just what it’s capable of via some of the graphical developer tools I’ve been working on, and I’ll show you how quick and easy it is to make user-friendly interfaces for your own applications by building some live from scratch. Finally, we should get a chance to talk about the Julia tools we want to build next, taking advantage of this technology.
+ + +Bio: I'm a Physics student from the UK who mostly works on Julia when I should be studying. I have a few more-or-less useful projects but the most popular is Juno, a Julia environment I started work on as part as Google Summer of Code, and which now has thousands of users. Recently I've also worked on bringing a much-needed documentation system to Julia 0.4.
+ +Zachary Yedidia
+The SFML library is often used for game development by small companies or hobbyists, but it can also be used to create demonstrations and animations for scientific algorithms. SFML has modules for graphics, audio, and networking. The SFML.jl package I am working on should let Julia users take advantage of SFML to create compelling games and demos easily.
+ + +Bio: Zachary Yedidia is a sophomore at Concord Academy High School. He is currently working on a Julia wrapper of SFML (the "Simple Fast Multimedia Library").
+ +Shashi Gowda
+TBC
+ + +Bio: I make UI tools for Julia and JuliaBox users.I brought @manipulate to your IJulia notebooks. :)
+ +Viral Shah
+We will introduce JuliaBox, its architecture, the things people are using it for, automatic grading in classrooms, and a roadmap for building and serving Julia applications through JuliaBox.
+ +We will describe a roadmap of how complete applications with a web UI (Canvas) and a computational backend can be built effortlessly in Julia and deployed with a single click on JuliaBox.
+ + +Bio: https://in.linkedin.com/in/viralbshah
+ +Sebastien Martin
+We are considering taxis in a city (represented using LightGraphs.jl) with customers ready to be picked up at different times and locations. We are using JuliaOpt packages to find the best actions of our taxi fleet and maximize their revenues. We then use OpenStreetMap.jl and SFML.jl to visualize the results of the simulations.
+ + +Bio: Sebastien Martin is a PhD student in Operations Research at MIT. His research focuses on Online Optimization and Transportation. The visualization part of the project was also done with the help of Brandon Zeng, sophomore in Computer Sciences at MIT.
+ +Zenna Tavares
+There has been much debate over Julia’s prospects as a viable language for statistical computing. In this talk I will offer a more exciting possibility: that Julia is uniquely well positioned for probabilistic programming. I will present Sigma.jl, a Julia package in which you can specify arbitrarily complex probabilistic models as normal Julia programs; general probabilistic inference procedures then attempt to answer any statistical question you pose about the model.
+ +Researchers typically invent entirely new languages for probabilistic programming. I will describe how we implement Sigma.jl purely as a package by exploiting Julia’s introspection and multimethod dispatch capabilities to perform static analyses, dynamically. This allows us, for instance, to use Julia’s existing linear algebra routines over random matrices. I will also outline our algorithmic approach to probabilistic inference, which combines methods from statistics, program analysis and constraint solving, and when combined with Julia enables us to address new classes of probabilistic inference problems.
+ + +Bio: Zenna Tavares is a Ph.D candidate at CSAIL of MIT in the Computer Aided Programming group. Motivated by problems in both human and artificial intelligence, he studies probabilistic programming languages, inference algorithms and the automated synthesis of programs. + +He has worked on two Julia packages: Sigma.jl for probabilistic programming, and Lens.jl, a simple package to analyse runtime behaviour of algorithms.
+ +Chiyuan Zhang
+Mocha.jl is a a flexible and efficient deep neural network library supporting multiple backends (CPU and GPU). In this talk, I will present the basic design and architecture of this library and demonstrate how to train a deep convolutional neural network in Julia.
+ + +Bio: Chiyuan Zhang is a PhD student at CSAIL, MIT. His research focus on machine learning, speech recognition, and computational neuroscience. He is the author of Mocha.jl, a flexible, feature complete and efficient deep neural network library for Julia.
+ +Simon Kornblith
+L1 regularized regression, or the Lasso, is a popular technique for building linear and generalized linear models that selects only a subset of predictors and allows fitting models with more predictors than data points. Modern statistical theory provides a way to determine which of these predictors make significant contributions to the model. I will describe three packages I’ve created that implement L1 regularized regression in Julia: Lasso.jl, LARS.jl, and GLMNet.jl, and compare their approaches and performance.
+ + +Bio: Simon Kornblith is a graduate student in Brain and Cognitive Sciences at MIT. He has used Julia in his work since 2013. He contributes to several Julia packages, including HDF5, MAT, DSP, and DataArrays, as well as to Julia itself.
+ +Pontus Stenetorp
+Naming a child is never easy, and for parents that have different native languages it poses further problems. Ideally, the name should be equally suitable for both of their native tongues, but how can one find such a name? In this talk we will take a computational approach and attempt to model the suitability of a name using approaches from Natural Language Processing and Machine Learning, and, of course, our language of choice, Julia. We will cover data collection/processing, mapping strings to phonemes, differences in languages, and the machine learning techniques necessary to modelling the suitability of a name.
+ + +Bio: Pontus is a research associate at University College London, that spends +most of his research time on Natural Language Processing and Machine Learning. He has been using Julia since 2014 due to a need for rapid prototyping and computational performance. When it comes to Julia contributions, he tends to contribute small occasional patches to the standard library.
+ +John Myles White
+At present, the core JuliaStats libraries, DataArrays and DataFrames, have little to offer that would incentivize statisticians to switch away from R. In this talk, I’ll outline a proposal for what the Julia community needs to do to convince a statistician with little-to-no engineering experience to switch languages.
+ + +Bio: Developer of many JuliaStats packages.
+ +Tony Fong
+A static code analysis package Lint.jl will be showcased and discussed. I’ll contrast this with other amazing tools such as code_warntype, Typecheck.jl. Some useful tips and tricks around the tool will be presented, such as lint-time printing and version-dependent linting.
Bio: Tony Fong is the author of Lint.jl and TermWin.jl, and a contributor to Formatting.jl and Traits.jl. His background is in physics and finance. Tony's primary reason of using Julia is modeling of lower dimension electronic systems.
+ +Tony Kelman
+A quick walk through the challenges in making Julia packages, specifically those that rely on binary dependencies, available and properly tested for Windows users. The talk will summarize some of the differences in compilers and build environments that are relevant for building scientific software, and some approaches for dealing with them, even for package developers who never use Windows themselves.
+ +Will specifically discuss and show examples of how to cross-compile common libraries, and how to use the openSUSE build service, the WinRPM.jl and BinDeps.jl Julia packages, and AppVeyor continuous integration testing.
+ + +Bio: Helped get Julia 0.3 to pass its unit tests on Windows, and keep them that way by setting up AppVeyor continuous integration for Julia. Contributor to various packages, especially in JuliaOpt.
+ +Isaiah Norton
+Clang.jl is a Julia binding to the C interface to the Clang compiler (libclang), providing access to C, C++, and Objective-C parse trees and associated information. Clang.jl provides a framework for automatic generation of Julia bindings from library headers and has been used to build packages including VideoIO.jl, and Gtk.jl. I will give a brief overview of the wrapped libclang API, the wrapper-generation system, and a wrapper generation example for a new library.
+ + +Bio: I wrote the Clang.jl package, used to generate Julia bindings for several large (C) libraries, and have contributed to a number of other packages. I am also an active contributor to base Julia.
+ +Iain Dunning
+A language can live or die depending on the strength of its package ecosystem. I’ll present a brief history of how Julia’s package ecosystem has grown over the past 3 years. I’ll then describe the current situation, including the PackageEvaluator system and pkg.julialang.org. Finally I’ll share some thoughts on future work in the area.
+ + +Bio: I've been working with Julia for over two years, and have contributed mostly packages: JuliaOpt, Coverage.jl, FactCheck.jl, Humanize.jl, GraphLayout.jl, as well as countless patches to other packages and to Julia itself. My other main contribution is the development of pkg.julialang.org and the PackageEvaluator.jl package ecosystem testing service.
+ +Sorami Hisamoto
+JuliaTokyo is a community / meetup for Julia enthusiasts in Japan.
+ +From basic tutorial to macros & parallel computing, Deep Learning to
+AI Japanese chess, and even an unofficial anime character, we are
+having a variety of activities at JuliaTokyo.
In this presentation I would like to introduce how Julia is gaining
+its popularity in Japan, what we’ve been doing at JuliaTokyo, and how
+we want to interact with the rest of the world in the future.
Bio: Sorami Hisamoto is yet another Julia enthusiast in Tokyo, Japan. He +works as a data analyst, mainly in the marketing area. Prior to that +he was doing researches in the field of Natural Language Processing.
+ +Leah Hanson
++
+ +Jeff Bezanson
+Aside from day-to-day bug fixing and feature development, a significant amount of work goes in to exploratory side projects and thinking about how Julia could be better. In this talk I will try to bring some of this into view, presenting ideas (at varying stages of development) about the future of the language and system. Topics include the type system, higher-order programming, static analysis, and miscellaneous others.
+ + +Bio: Jeff is one of the co-creators of Julia. He recently finished a PhD at MIT and is now helping to build Julia Computing.
+ +Jake Bolewski
+Julia’s compiler is implemented in three different programming languages, Scheme, Julia, and C/C++. This separation is an issue as it reduces modularity in the compiler and makes implementing new language features and optimizations difficult. As Julia begins to mature, I argue that now is the right time to start thinking about replacing parts of the compiler with Julia code. The most natural place to start is the compiler frontend which is currently written in Scheme. I will demo some work towards rewriting parts of the frontend in pure Julia. I hope to demonstrate that a pure Julia frontend will be beneficial in terms of features, performance, and opportunities for tool integration.
+ + +Bio: Jake Bolewski has been using Julia for about a year and a half and currently works in the Julia group at MIT. In a past life he was a biologist working in the area of super-resolution / single molecule microscopy.
+ +Westley Hennigh
+I’ve started a project which configures Julia to load IR passes dynamically and runs a genetic algorithm that features synapsing variable length crossover. We’ll discuss the challenges involved in measuring the performance of IR pass layouts, the algorithm, and the results so far.
+ + +Bio: Westley Hennigh has been working with Julia since late 2012. He built a system for running models written in Julia across machines in my butt, has contributed to the language, and maintains a variety of packages.
+ +Keno Fischer
+At last years JuliaCon, I presented two highly experimental projects I was working on the Julia C++ FFI, Cxx.jl and an LLDB-based debugger for Julia. Since last year, the C++ FFI has been completely
+rewritten based on staged functions, has gained an interactive C++ REPL mode and has reached a
+point where it has become useful, not only as a toy research project but has become usable for real
+applications. In this follow-on talk, I will demonstrate these new capabilities and explain how to use
+them to interact with C++ libraries. Additionally, I will given an update on the (still experimental, but improved) LLDB-based debugger, discussing what features are ready, what problems exist and what the future holds.
Bio: Originally from Germany, Keno Fischer is currently finishing is Master's and Bachelor's degrees in Physics and Mathematics at Harvard University. Keno has contributed to Julia core development for more than three years, contributing such features as the Windows port, the improved REPL as well as numerous other bug fixes and minor improvements. Additionally, he is the author of a large variety of Julia packages, including SIUnits.jl, BinDeps.jl and Cxx.jl. Since last year, Keno has also been working with Julia Computing, aiming to make Julia viable not just in research, but in industry as well.
+ +Mauro Werder
+Traits.jl is an experimental package which brings interface/trait/type-class based programming to Julia. Traits.jl implements two main features: (1) to group types, or tuples of types, into sets (traits) disconnected from the type hierarchy; and (2) to define methods which dispatch on those traits. The grouping is achieved by specifying certain constraints which a type has to fulfill, typically implementing certain functions but other constraints are allowed too. For example, a trait Plus{X,Y} could be defined as the set of all type tuples (X,Y) such that a method +(::X,::Y) exists. Note that this set is (automatically) expanded as new methods to + are added. The dispatch on traits is implemented on top of the normal type-dispatch. For example, foo{X, Y; Plus{X,Y}}(x::X, y::Y) = ... would define a method which is dispatched to for all (X,Y) ∈ Plus{X,Y}.
I will present the following: a simple example on how Traits.jl works and can be useful; its inner workings; and use-cases in Base and for packages. I hope to have a discussion on features, roadblocks, a more stable implementation, and whether something like this would be useful for Base.
+ + +Bio: I am a glaciologist, specializing in simulations of water flow at the base of glaciers. In the Julia community, I am probably mostly known for my experimental package Traits.jl which brings interface/trait/type-class based programming to Julia.
+ +Jacob Quinn
+Anyone who has poked around the Julia manual has come across a variety of terms and quick descriptions of what happens when code gets compiled. Quips of ‘macro this’, and ‘staged function that’, parse-time, compile-time, code lowering, type inference, aggressive specialization, and the list goes on.
+ +Finally, the entire process is all brought together and made sensible; fear the JIT no more.
+ + +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.
+ +Douglas Bates
++
Estimating the parameters in a ‘mixed-effects’ model (also called
+‘variance components’ or ‘hierarchical’ or ‘multilevel’) requires
+optimizing a log-likelihood. Until recently it was not possible to
+fit models with multiple non-nested sources of variability such as
+‘subject’ and ‘item’ or longitudinal data on ‘student’, ‘classroom’,
+‘school’, ‘district’, etc. The introduction of sparse matrix
+representations and some clever re-arrangement of terms in the
+log-likelihood made it possible to evaluate the log-likelihood by
+solving a large, sparse penalized least square problem. But current
+implementations can still take days to optimize this criterion for
+complicated models fit to large data sets, because the sparse matrix
+methods can’t take advantage of the special structure in the problem.
+Because Julia combines the flexibility of a high-level language with
+the capability of achieving high performance, it is possible to
+exploit these special structures, in many cases reducing the time to
+fit a model by one or two orders of magnitude. User-defined types,
+multiple dispatch, in-place evaluation, and devectorization are key
+characteristics of Julia for this application.
Bio: U. of Wisconsin - Madison
+ +Jack Poulson
+This talk will give a broad overview of recent algorithmic developments within the C++11/MPI library Elemental and ongoing efforts to expose interfaces to external languages (i.e., C, Python, and Julia). In particular, the talk will discuss recent advancements in Elemental’s distributed a priori regularized quasi-semidefinite sparse-direct solvers, their application to sparse Interior Point Methods and sparse generalized least squares problems, and progress towards interactive interfaces on large-scale machines.
+ + +Bio: Jack Poulson is the lead developer of Elemental, a distributed-memory library for direct linear algebra and optimization, and an Assistant Professor of Mathematics and Member of the Institute for Computational and Mathematical Engineering at Stanford University. He has contributed a native Julia multifrontal Cholesky (MultiFrontalCholesky.jl) and is a contributor to Elemental.jl, which will provide distributed-memory dense linear algebra, sparse-direct solvers, and Interior Point Methods to Julia.
+ +Zhang Xianyi
+The BLAS (Basic Linear Algebra Subprograms) is a fundamental interface in scientific computing. In this talk, I will introduce the OpenBLAS and BLIS projects. OpenBLAS is an optimized open source BLAS implementation based on GotoBLAS2, and the default BLAS library used in Julia. OpenBLAS supports modern Intel, AMD, and ARM processors. By hand-written or automatically generated (via the AUGEM) assembly kernels, we can achieve competitive performance with vendor BLAS libraries.
+ +BLIS is a portable framework for instantiating BLAS-like libraries. The framework was designed to isolate essential kernels of computation that, when optimized, immediately enable optimized implementations of most of its commonly used and computationally intensive operations.
+ + +Viral
+In this talk, I will describe the current status of sparse matrices in Julia. About half the talk will focus on walking the audience through the current design, and feature set. The other half will focus on tensions in the current design, what different people want from sparse matrices, and a discussion on how to take this forward.
+ + +Bio: https://in.linkedin.com/in/viralbshah
+ +David P. Sanders
+We will present features of the ValidatedNumerics.jl package, which provides tools for rigorous numerical calculations in Julia via interval arithmetic, and its application to validated computation in dynamical systems.
In particular, in combination with the BilliardModels.jl package, we will show how to solve one of the “hundred-dollar, hundred-digit challenge” problems [1,2] by computing a guaranteed trajectory of a billiard model to arbitrary precision.
[1] http://people.maths.ox.ac.uk/trefethen/hundred.html
+[2] https://www.siam.org/pdf/news/388.pdf
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.
+ +Luis Benet
+I will describe some of the design and use of TaylorSeries.jl, which is a package to manipulate Taylor expansions in one or more independent variables. Results on integrations on a three-body problem will be presented.
Bio: I am Associate Professor at the Instituto de Ciencias Físicas of the National University of Mexico (UNAM). My main fields of interest are classical and quantum chaos, random matrix theory and dynamical astronomy. Regarding Julia, I spotted a buggy behavior of `binomial` (#6154). Together with David Sanders, we develop and maintain `TaylorSeries.jl` and `ValidatedNumerics.jl`. I also use Julia to implement members of the so-called k-body gaussian embedded ensemble of random matrices. We are using Julia in our lectures.
+ +Hongbo Rong
+High-performance computing (HPC) on sparse data structures like graphs is becoming increasingly important in computational biology, web search, and knowledge discovery, etc. Unlike traditional HPC applications that deal with regular data structures, sparse computation has unique challenges: its performance is often bound by the memory bandwidth,and its parallelism is dependent on the specific input data. It is a very time-consuming process to speedup such workloads, usually taking an expert several months or years to achieve close-to-peak performance for a new architecture.
+ +We propose an external Julia package, called Sparse Accelerator, to automatically optimizes sparse applications. It co-designs compiler, library and runtime to exploit the potential.
+ + +Bio: A researcher at Programming Systems Lab in Intel. Worked on software pipelining, binary translation, and recently HPC. +Before that, a developer in Microsoft Visual Studio. Engineered local scheduler and tree register allocator in Phoenix compiler, and the C++ type system in Visual Studio 2011. +Best Paper Awards at CGO 2004 and 2014. +Developed an initial version of Julia2C. Developing a Julia package, Sparse Accelerator.
+ +Robert Moss
+This talk outlines how the FAA and the international safety community are using Julia in the development and specification of the next generation aircraft collision avoidance system. Historically, pseudocode was used with separate implementations for the validation of the system. Today, we utilize Julia to auto generate our specification document and replaced pseudocode in favor of an executable specification written in Julia.
+ + +Bio: Robert Moss is an assistant staff member at Lincoln Laboratory in the Surveillance Systems Group. He joined Lincoln Laboratory as a co-op while receiving his bachelor's degree in computer science from Wentworth Institute of Technology in 2014, where his research included modeling the rotation curve of galaxies in Julia. At Lincoln Laboratory, his research focuses on development and analysis of the next-generation airborne collision avoidance system.
+ +Lars Ruthotto and Eldad Haber
+Full waveform inversion (FWI) is commonly used in geophysical explorations. The goal of FWI is to estimate a model (velocity) of the subsurface from measurements of the ground’s responses to seismic vibrations. FWI is known to be a challenging inverse problem that contains many local minima and can be ill-posed.
+ +FWI is computationally demanding: estimating a model that accurately predicts the measurements requires a large number of simulations each of which is obtained from solving the Helmholtz equation over many sources and frequencies.
+ +This three hours hands-on workshop provides a brief introduction into FWI and the main cornerstones of inversion codes, including:
+1. Finite Volume discretization of Helmholtz equation
+1. Numerical optimization methods for solving the inverse problem.
+1. Parallelization of the optimization problem
We will show how to design an inversion code that can work well for small to medium size problems and can be scaled up to large scale problems. Special emphasis will be put on Julia’s potential to distribute the PDE solves amongst all available workers.
+ + +Bio: Lars Ruthotto is an assistant professor in the Department of Mathematics and Computer Science at Emory University. Eldad Haber is a professor at the Department of Earth and Ocean Sciences at UBC in Vancouver and NSERC Industrial Research Chair in Computational Geoscience. + +Lars and Eldad are interested in scientific computing for inverse problems, especially electromagnetic imaging in geophysical applications. They both use Julia for teaching but mostly in their research. They contributed to Julia a wrapper for MUMPS and a few iterative solvers for large linear systems.
+ +Iain Dunning
+In this talk we will present the JuliaOpt suite of packages for optimization in Julia. In particular, we will focus on how these packages interact and can be composed to solve a variety of problems.
+ +We will begin with a discussion of two different modeling systems, JuMP and Convex.jl, and how they can be used to model different types of problems. We then move to describing the MathProgBase interface, which provides a rich abstraction over a variety of solvers (both pure Julia and external commercial and open-source libraries). Finally we will discuss how the JuliaOpt stack enables both rapid development of models and solvers, and outline future plans for JuliaOpt.
+ + +Bio: I've been working with Julia for over two years, and have contributed mostly packages: JuliaOpt, Coverage.jl, FactCheck.jl, Humanize.jl, GraphLayout.jl, as well as countless patches to other packages and to Julia itself. My other main contribution is the development of pkg.julialang.org and the PackageEvaluator.jl package ecosystem testing service.
+ +Yee Sian Ng
+Traditionally, the workflow for geographic information systems (GIS) requires the storage of geospatial data within databases, that are specially indexed for performing fast spatial queries. Nonetheless, the development of libraries for high-level languages like Python, R, and Javascript has made it a lot easier to work with geospatial data through programming languages, outside of a RDBMS. I will touch on the common types of spatial operations that we care about in practice, talk about the current state of packages for working with geospatial data in Julia, and discuss what remains to be done to move development for JuliaGeo forward.
+ + +Bio: Yee Sian is a PhD student at MIT in the Operations Research Center (MIT ORC).
+ +Blake Johnson
+Powerful simulation tools are essential to early explorations of small quantum devices. I will introduce QSimulator.jl, a package to facilitate such simulations with a straightforward algebraic syntax to compose systems and interactions from a common toolbox. The package takes advantage of Julia’s parallel processing capabilities to distribute parameter sweeps across many nodes, greatly accelerating common workflows.
+ + +Bio: Blake Johnson is a physicist working on building small quantum processors with superconducting qubits. He contributed to some of the first quantum algorithm demonstrations, and has extensive experience building FPGA-based hardware for controlling quantum systems. This custom hardware enables a new class of quantum feedback experiments requiring sub-microsecond measurement-to-control latency. + +Blake is helping to build a growing set of packages relevant to quantum information processing, including Cliffords.jl for efficient simulation of a certain class of quantum circuits.
+ +Kevin Damazyn and Mark Tabor
+The SL Text Mining Initiative is an interdisciplinary project between the Computer Science and English departments. The initial focus is the construction of open source tools, in Julia, to facilitate text mining research. The project will then use these large-scale, computational tools to explore whether common delimiters of time period (namely, the concept of literary generations) operate at the level of lexical, linguistic, or stylistic patterns. Using this information, natural language processing models will be constructed to classify unseen texts into these literary generations.
+ + +Bio: Kevin: Recent SLU Computer Science (BS) graduate who currently works at Asynchrony Solutions in St. Louis. + Mark: Mark Tabor graduated from Saint Louis University with a BS in Computer Science. He is a former Marine and Iraq war veteran. His research interests involve Machine Learning and NLP.
+ +Simon Kornblith
+The JLD module, included in HDF5.jl, provides a way to save and read any Julia data structure using the hierarchical data format HDF5. JLD maps Julia types and immutables directly to HDF5 compound types, providing efficient and structured on-disk storage that is robust to changes in code and in Julia itself. I will give an overview of how this mapping works, its strengths, and its pitfalls.
+ + +Bio: Simon Kornblith is a graduate student in Brain and Cognitive Sciences at MIT. He has used Julia in his work since 2013. He contributes to several Julia packages, including HDF5, MAT, DSP, and DataArrays, as well as to Julia itself.
+ +Avik Sengupta
+The ability to expose Julia code on the internet, via HTTP, can be useful in many circumstances. In this lightning talk, we will see a practical demonstration of how to create a REST API from any Julia code, both in a pure Julia environment, as well as within a hybrid infrastructure. We will look at some the security and stability requirements for this functionality, and the options for deployment.
+ + +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. + +
+ +Tanmay Mohapatra
+Protocol buffers are a language-neutral, platform-neutral, extensible way of serializing structured data for use in communications protocols, data storage, and more.
+ +ProtoBuf.jl is a Julia implementation for protocol buffers which makes it possible for Julia applications communicate with other applications in a distributed, heterogeneous environment. For example, the Elly.jl package uses ProtoBuf extensively to integrate with HDFS and Yarn. However the use cases are many more.
+ + +Bio: https://www.linkedin.com/in/tanmaykm
+ +Bob Carpenter
+Stan.jl is the Julia interface to Stan, an open-source, imperative
+probabilistic programming language. Stan allows you to express a
+customized statistical model and conditioned on data, perform optimization
+for classical penalized maximum likelihood estimation or sampling for
+full Bayesian inference.
Bio: Bob Carpenter is a research scientist in computational statistics +(Columbia University). He designed the Stan probabilistic programming +language and is one of the Stan core developers. + +Bob has a Ph.D. in cognitive and computer science (University of +Edinburgh), worked as a professor of computational linguistics +(Carnegie Mellon University), an industrial researcher and programmer +in speech recognition and natural language processing (Bell Labs, +SpeechWorks, LingPipe). In addition to working on Stan, he's written +two books on computational linguistics, many papers, and the widely +used LingPipe natural language processing toolkit.
+ +Eric Davies
+This talk will compare and demonstrate the two proposed Julia database interfaces DBI.jl and DBAPI.jl and solicit feedback on the community’s desired direction.
+ + +Bio: Eric works in R&D at Invenia Technical Computing: a small, cutting-edge startup targeting inefficiencies in electrical grids. His interests lie in machine learning but his contributions to the Julia community have been database-related: Eric wrote and maintains PostgreSQL.jl and DBAPI.jl, and contributed to DBI.jl.
+ +Amit Murthy
+This presentation will cover
+- a short introduction to parallel Julia internals
+- writing a custom cluster manager
+- demo of a cluster manager using ZeroMQ for transport
Kiran Pamnany and Ranjan Anantharaman
+Shared memory parallelism is essential for high performance on today’s multi- and many-core architectures. We will present the threading infrastructure built into Julia, the programming model presented, and discuss design choices and alternatives.
+ +We will then present our experiences with, and the results of, applying this infrastructure to scale a number of different workloads written in Julia; often demonstrating performance comparable with C.
+ + +Bio: Kiran works at Intel's Parallel Computing Lab, on enabling HPC application scaling on large IA-based clusters. His primary research focus is parallel programming models, and the underlying low-overhead, high performance software stacks required. + +Together with the core Julia developers, Kiran has built a multi-threading infrastructure for Julia -- the ``threading`` branch on Github. + +Ranjan is completing his internship at Intel Labs, on his way to earning his undergraduate degree in computer science from BITS-Pilani, Hyderabad. He has built and analyzed some of the first multi-threaded Julia programs.
+ +Patrick Sanan
+Julia can now be used on a Cray supercomputer! We detail how, relying on recent upgrades by Amit Murty to the MPI ClusterManager. To work with Cray’s paradigm of hiding details of the compute nodes from the user, all communication is done through MPI, and master and worker threads are uniformly launched as Julia processes running on compute nodes. This has the advantage of simplicity, and takes advantage of Cray’s optimized MPI implementation. This procedure allows for extremely portable code which can use any Julia ClusterManager implementation, allowing for development on a laptop and deployment on the largest supercomputers.
+ + +Bio: Patrick Sanan is a postdoctoral researcher at USI, Lugano, working on the GeoPC PASC project to advance the state of the art of preconditioners within large geophysics simulations. He is interested in the use of Julia for HPC.
+ +Hongbo Rong
+High-performance computing (HPC) on sparse data structures like graphs is becoming increasingly important in computational biology, web search, and knowledge discovery, etc. Unlike traditional HPC applications that deal with regular data structures, sparse computation has unique challenges: its performance is often bound by the memory bandwidth,and its parallelism is dependent on the specific input data. It is a very time-consuming process to speedup such workloads, usually taking an expert several months or years to achieve close-to-peak performance for a new architecture.
+ +We propose an external Julia package, called Sparse Accelerator, to automatically optimizes sparse applications. It co-designs compiler, library and runtime to exploit the potential.
+ + +Bio: A researcher at Programming Systems Lab in Intel. Worked on software pipelining, binary translation, and recently HPC. +Before that, a developer in Microsoft Visual Studio. Engineered local scheduler and tree register allocator in Phoenix compiler, and the C++ type system in Visual Studio 2011. +Best Paper Awards at CGO 2004 and 2014. +Developed an initial version of Julia2C. Developing a Julia package, Sparse Accelerator.
+ +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.
+Avik Sengupta
+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.
+Randy Zwitch
+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.
+Jacob Quinn
+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.
+Viral
+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
+Shashi
+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. :)
+
+
+
+ A debugger for Julia
+Juno is an effort by the Julia community to provide tooling for the language and build a state of the art programming environment. As well as the various necessities, like evaluation, debugging and plotting, we aim to raise the bar for dynamic tooling in areas like interactivity, visualisation and dynamic analysis. +Juno is an effort by the Julia community to provide tooling for the language and build a state of the art programming environment. As well as the various necessities, like evaluation, debugging and plotting, we aim to raise the bar for dynamic tooling in areas like interactivity, visualisation and dynamic analysis.
+This talk will give an overview of the current Julia data manipulation and modelling ecosystem, highlight the areas that still need work, and sketch out our future plans. + +This work is supported by a grant from the Moore Foundation.
+Julia's dynamic-yet-statically-compilable type system is extremely powerful, but presents some challenges to creating generic storage containers, like tables of data where each column of the table might have different types. This package attempts to present a fully-typed `Table` container, where elements (rows, columns, cells, etc) can be extracted with their correct type annotation at zero additional run-time overhead. The resulting data can then be manipulated without any unboxing penalty, or the need to introduce unseemly function barriers, unlike existing approaches like the popular DataFrames.jl package. + +The main caveat of this approach is the extra layer of complexity for the compiler and programmer introduced by including this information in the type parameters of objects. This talk will explore how additional Julia 0.5 features such as pure functions will significantly simplify both the interface and the implementation of DataTables.
+Music Information Retrieval (MIR) is an exciting field of research with many successful real-world applications, such as automatic audio source separation, instrument recognition, chord recognition, automatic transcription and music recommender systems. In this lightning talk, I will briefly introduce MIR as a research topic, and show how Julia can be used to perform various music analysis and processing required in MIR research. The presentation will also include a demo of audio visualization and instrument classification, based on a music analysis library written in Julia that is planned to be open sourced by JuliaCon 2016.
+For a rewrite of Frequon Invaders, I needed a high performance SIMD kernel for a program written in Go, which lacks SIMD support, but does have a bare-bones assembler. Julia to the rescue! Julia turns out to be a nice language for writing a quick and dirty assembly-code generator. Subtyping and multiple dispatch enabled concisely describing instruction selection. Julia being a full programming language enabled some automatic register allocation. The exercise shows the power of Julia to quickly hack a limited “one off” program to generate code.
+I will review the basics of automatic differentiation and discuss how they are implemented in JuMP to efficiently compute derivatives of user-provided closed-form expressions and "black box" functions. I will discuss the data structures we designed in order to avoid the wrath of Julia's garbage collector and will present benchmarks comparing JuMP with competing commercial tools.
+GLVisualize is a 2D/3D graphics library entirely written in Julia. It uses OpenGL to offer state of the art rendering speeds even for animated data. This Talk will show you what the strength and weaknesses of GLVisualize are, and what you can expect from it in the future.
+Automatic differentiation (AD), a collection of methodologies for computing exact derivatives of programs, is essential for modern scientific computing. In spite of growing awareness of AD, non-expert users face substantial barriers when applying these techniques in practice. These barriers are generally attributable to limitations of the available tools: AD tools developed in low-level languages are difficult to use, and AD tools developed in high-level languages are slow. This talk presents ForwardDiff.jl, a Julia implementation of forward-mode AD that bridges the traditional gap between usability and speed by offering performance competitive with similar C++ implementations. The package leverages Julia's novel performance model to support unique features like black-box function differentiation, simultaneous directional derivative calculation, efficient composability with user-defined types, and experimental parallelism via SIMD/multithreading. The talk will walk the audience through the package's implementation and usage, as well as highlight common AD pitfalls users should avoid.
+Vulkan is the successor of OpenGL and OpenCL and offers a lot of interesting new features to do graphics and general compute on the GPU. In this talk I will give a short introduction to Vulkan and why it will matter to Julia.
+ThreeJS.jl is a Julia wrapper around the very popular threejs library for rendering 3D scenes in browsers using JavaScript. This allows the user to create 3D graphics which can be viewed in a browser using just Julia and no HTML or JS. The package can be used along with Escher, IJulia notebooks or from the REPL using Blink.jl. It supports interactivity in Escher, allowing for nice UI’s to interactively update and interact with 3D scenes and also create animations! The talk will demo a few examples to showcase these features and demonstrate the ease of use and presentation quality of web based 3D graphics. ThreeJS.jl was created as part of a JSoC 2015 project mentored by Shashi Gowda and Simon Danisch.
+NetworkViz.jl is a graph visualization package that uses ThreeJS.jl and Escher.jl to render graphs. It can be used to create interactive graph visualization applications. Eg. : 1. https://www.youtube.com/watch?v=qd8LmY2XBHg 2. https://www.youtube.com/watch?v=Ac3cneCRTZo. The package is tightly integrated with LightGraphs.jl and can be used to visualize graph operations using LightGraphs as shown in example 2. The package works decently fast for graphs with nearly 10000. I'm working on optimizing the performance to make it work with larger graphs.
+This talk provides an overview of a consulting project that had two primary goals: 1. Enable the modification of various forward communication root finding and optimization solvers available in the Julia ecosystem to be used as reverse communication solvers, wherein any objective, gradient, or Hessian functions can be evaluated external to the solver itself. 2. Allow for embedding of the Julia solver within a C/C++ application where the objective, gradient and Hessian functions are defined as part of a large pre-existing codebase. This talk will walk through the specific Julia functionality necessary to enable a variety of forward communication solvers available in different Julia packages to be called in a reverse communication manner, and show how this functionality can be embedded within a C/C++ application.
+GR is a plotting package for the creation of two- and three-dimensional graphics in Julia, offering basic MATLAB-like plotting functions to visualize static or dynamic data with minimal overhead. In addition, GR can be used as a backend for other plotting interfaces or wrappers, such as PyPlot or Plots. This presentation shows how visualization applications with special performance requirements can be designed on the basis of simple and easy-to-use functions as known from the MATLAB plotting library. The lecture also introduces how to use GR as a backend for Plots, a new plotting interface and wrapper for several Julia graphics packages. By combining the power of those packages the responsiveness of visualization applications can be improved significantly. Using quick practical examples, this talk is going to present the special features and capabilities provided by the GR framework for high-performance graphics or as a backend for Plots, in particular when being used in interactive notebooks.
+Efficient iterative methods for sparse linear systems are crucial in many research and industrial applications, for example, for solving partial differential equations (PDEs). There are different Julia packages that provide implementations of many state-of-the-art linear methods. In this lightning talk, I will give an overview about some of the packages and highlight similarities and differences in coding philosophy. I will also give a detailed comparison of their computational efficiency of using examples from numerical PDEs. The main goal of the talk is to start a discussion about the inevitable trade-offs between computational efficiency, ease of use and readability of the code.
+The talk is about component architecture in Escher.jl. I aim to describe how to build arbitrarily complex web apps from smaller components using a model-view-update pattern.
+The ability to thoroughly, but easily, test Julia code and packages is vital if they are to maintain their high quality. The Base.Test framework provides a great set of constructs to help automatically execute test cases and avoid bugs. Recently we have extended this framework with award-winning techniques from our software testing research. Together, these packages enable not only the automated execution but also the automated creation of test cases. This can help you explore the actual behavior of your Julia code to find bugs earlier and increase coverage. In this talk we give an overview of the techniques our extensions provide, and show, with examples, how they have helped us find bugs in Julia code. + +Our extensions combine the novel capabilities of a number of different testing frameworks, programming languages and research studies. The BaseTestAuto package provides the basis by extending the Base.Test implementation in Julia 0.5-dev to support repeated execution of test sets and to allow predicates that ensure not only a single but that a whole set of values have a certain property. Another package allows generators for values of any type and structure to be described; this allows for both random and targetted creation of test data. On top of this we can then build a library of generators and combinators to create data that exercises a large part of the Julia type hierarchy. Together these packages extend the type of testing that can now be done in Julia, and in our presentation we will demonstrate random testing, property-based testing, parameterized unit testing, adaptive test execution, and search-based testing for increased coverage and test diversity. Our talk is hands-on and shows the use of these techniques on real Julia code but also outlines future additions that we are working on. Our mission is to make testing in Julia as fun and powerful as possible and we hope to get support from the community in achieving this.
+In 2015, John L. Gustafson proposed a new computational representation for sets and intervals of rational numbers called Unums. This proposal provoked both excitement and criticism in the Julia community. Gustafson has recently presented an updated proposal that is a ground-up rethink of how to represent sets and intervals: Unums 2.0. I will discuss a prototype implementation of (some of) this proposal in Julia, and compare it to both the original proposal and other systems of point and interval arithmetic. Two of the most important features of the new proposal are working with the projective rationals (i.e. including a single point at infinity), and making the system of numbers closed under reciprocation (1/x). Working projectively allows including intervals that span the point at infinity, and reciprocal closure means that division can be efficiently implemented as a composition of reciprocation and multiplication. The combination of these allows a simple representation of the reciprocal of intervals that span 0, which is unusual for interval arithmetic. I will also attempt to provide a critical perspective: despite attractive properties, neither proposal is a silver bullet for numerical computing.
+The RCall package allows a Julia user to run an embedded R instance and to communicate with it. Thus the Julia user has instant access to all the data sets available in R packages and to the data manipulation facilities of R. For those working on statistical methods in Julia, RCall allows for easy checking of results in Julia against those from R functions. I will illustrate how I was able to use it in developing the MixedModels package.
+I would like to give a talk on Float-like types that extend mathematical accuracy and help to assure mathematical veracity. The talk introduces errorfree transformations and compensated arithmetic for ~128 bit precision and good options for higher precision. Aspects of design and use are explained using a few elaborated types I have written.
+The CppWrapper package helps to expose C++ libraries as a Julia module. The main difference with Cxx.jl is that the wrappers are in C++ and loaded into Julia as a shared library. This can be useful for large libraries, where the wrapping library can be precompiled. The wrapper can be bundled with the library, automatically ensuring it compiles when updating the C++ library. + +In this talk, first the use of the package will be illustrated with a simple example. Next, some aspects of the implementation will be highlighted. The package is based on a combination of ccall and embedded use of the Julia C interface, so this will be explained in detail. On the Julia side, some metaprogramming techniques -used to generate methods- will be shown. + +In summary, this talk is targeted at people who are interested in wrapping C++ libraries, want to use the Julia C interface (embedding) or see an example of metaprogramming to define new methods.
+A look at why Julia is the best language to implement APL and how the JIT fares in the face of adversities. (https://github.com/shashi/APL.jl) + +- parsing examples https://github.com/shashi/APL.jl/blob/master/src/parser.jl +- eval-apply https://github.com/shashi/APL.jl/blob/master/src/eval.jl +- what's inside a function? +- some @code_llvm samples + +see this gist for a demo https://gist.github.com/shashi/9ad9de91d1aa12f006c4
+This talk presents a picture of the data science landscape in India, tools and technologies that data scientists use widely, and how Julia language is positioned in this landscape. From here, I explain how and why JuliaCon India edition has to stay relevant and ahead of its time, and why this approach is necessary for building and sustaining the community.
+I will describe the implementation of a bounded integer type in Julia, where the bounds are encoded as type level constants. All the usual arithmetic operations on integers are implemented with the result bounds being determined once at (JIT) compile time. For example adding bounded integers with types BInt{-10,8} and BInt{-100, 20} will yield a bounded integer with type BInt {-110, 28}. + +The bounds can be any constant integer, and large bounds are automatically converted to a tuple format that allows extremely large (effectively unbounded) integers to be represented at the type level despite Julia’s current limitation that the type parameter be a “bits type”. The appropriate value type is determined from the bounds - this can be Int32, Int64, Int128 or BigInt as required. + +The implementation exploits @generated functions to make the type level decisions. + +The original motivation arose in digital hardware system modeling, but the concept is very general. The bounded integer “BInt” numeric type behaves like BigInt in that arithmetic on BInt values will never overflow, but without the runtime and storage overhead of BigInt when it can be determined that a fixed width type is sufficient.
+Discussion of Julia 1.0 roadmap
+Our research focuses on control algorithms for automotive applications. We use model predictive control (MPC) as a mathematical tool to design these algorithms, and then use Julia and Python to implement these algorithms. For experimentation, we have launched an open-source platform called Berkeley Autonomous Race Car (BARC), which is a 1/10th scale RC car equipped with hardware for autonomous driving. [ http://www.barc-project.com/ ].
+The Raspberry Pi is a $35 computer designed to help teach computing to kids. It has also turned out to be very popular among hobbyists and digital makers. Powered by a ARM processor, it now runs Julia well enough to enable some fun educational projects. This talk will demonstrate the most common activities that kids can do with a Raspberry Pi -- control Minecraft via its API, and perform physical computing via its GPIO pins to control external components. It will showcase the Julia packages used for this purpose, and discuss ways in which these can be used to teach maths, science and programming.
+JuliaBox is currently hosted on AWS but will be hosted on Google cloud in the future. This talk gives the necessary information needed for users to migrate their data. The new features available for free/paid users and the road map for future development will also be presented.
+High Performance Analytics Toolkit (HPAT.jl) is a framework for big data analytics on clusters that automatically parallelizes Julia-based analytics programs, and generates efficient MPI/C++ code. HPAT is orders of magnitude faster than systems like Apache Spark. For example, HPAT is 53x faster for Spark’s front-page logistic regression example (200 iterations, 2 billion 10-feature samples) on a 64 nodes (2048 core) system. HPAT is compiler based; it uses Julia’s metaprogramming and ParallelAccelerator under the hoods to apply many optimizations. + +I will describe how Julia programmers can take advantage of HPAT,jl and what Julia codes are handled. We’ll then compare the syntax and performance of HPAT.jl with Spark using examples and discuss how it works internally.
+We have been developing Julia programs to solve various numerical +problems arising in the areas of deterministic and stochastic partial +differential equations as well as related multiscale problems. One of +our codes is already available as the Julia package EllipticFEM and +provides a finite-element solver for elliptic partial differential +equations that is faster than MATLAB. Being faster than the mature +MATLAB implementation underlines the advantages of Julia as a system +combining a native-code compiler with access to state-of-the-art +numerical libraries. + +Furthermore, we are using Julia to solve the drift-diffusion-Poisson +system and the Maxwell equations. These codes will also be published +as Julia packages. These programs are part of our work to develop new +algorithms for stochastic partial differential equations with +applications in nanotechnology and metamaterials. + +The author acknowledges support by the FWF (Austrian Science Fund) +START project no. Y660 "PDE Models for Nanotechnology".
+Statistical algorithms are typically based around data fixed in size. Adapting methods to data which is streaming or too large to fit in memory is often nontrivial. OnlineStats.jl provides a state of the art toolkit for performing statistical analysis in these situations. All algorithms use O(1) memory and stochastic approximations are used where analytical solutions are not possible. The methods provided by OnlineStats.jl include summary statistics, density estimation, statistical learning, and more.
+Writing a Finite Element Analysis (FEA) code requires many components. We typically need a dense and sparse matrix library, linear solvers for both type of matrices, visualizations of the resulting fields on meshes etc. A typical undergraduate course in FEA will therefore use MATLAB as the programming language in which assignments are written. Since students learn FEA in MATLAB this is also what they are likely to use in an eventual PhD project. + +I will make the case that Julia can provide an alternative to MATLAB, both when it comes to teaching FEA and implementing FEA codes in a PhD project. We will look at a handful of packages that together with the base Julia library can make writing FEA codes as simple as it would be in MATLAB.
+Julia's core language performance has attracted developers for years. In terms of standardized data processing tasks, however, Julia has lagged peer tools in terms of functionality and convenience. The DataStreams package and framework aims to bring foundational tools and workflows to Julia that encourage interface consistency and automatic leveraging of Julia's built-in performance levers. The CSV, SQLite, and ODBC packages currently implement the DataStreams framework to provide foundational data processing tools for Julia data mungers.
+The motion of a spacecraft is governed by non-linear equations which makes numerical software tools indispensable for the development and operations of a space mission. Since the beginning of computational astrodynamics Fortran has been the language of choice due to the numerical performance requirements. Because Fortran is not exactly flexible and easy to work with many astrodynamicists use Matlab for prototyping algorithms. This has led to the familiar pattern of software tools being implemented twice, first in Matlab then in Fortran, or interfacing Matlab and Fortran through MEX-files and hundreds of lines of glue code. + +In this talk I will present the Astrodynamics.jl library and explore how Julia’s unique feature set enables fast and easy modeling of complex space missions while not requiring expensive licenses or juggling multiple programming languages. With Julia it is possible to seamlessly move from simple approximations to parallel high-fidelity simulations which makes it an excellent choice for designing future space missions.
+I will show how to estimate least squares models with high dimensional categorical variables. These models are useful in social sciences because they allow to control for unobserved heterogeneity at a granular level. However, these models are hard to estimate because they typically include a large number of variables. +I will start with linear models with fixed effects. These models require to solve least squares problems on sparse matrices. I will present a new package to estimate such models in Julia, FixedEffectModels.jl. +I will then discuss linear models with *interacted* fixed effects.These models require to estimate PCAs on sparse matrices. I will present a new package to estimate such models in Julia, SparseFactorModels.jl. +Finally, I will present a package to solve general high-dimensional least squares problem, LeastSquaresOptim.jl. This package, inspired by the Ceres-solver, is the backend for the two previous packages.
+We will discuss why Julia is an excellent environment for developing new +numerical types, using as examples the TaylorSeries.jl and ValidatedNumerics.jl +packages that we have developed. + +TaylorSeries.jl calculates Taylor series expansions of functions +around a point in one or more variables by a recursive evaluation of higher derivatives (an extension of automatic differentiation), and, in particular, leads to high-order integrators for ordinary differential equations (ODEs). + +ValidatedNumerics.jl provides a means to perform *rigorous* calculations using +floating-point arithmetic, with a guarantee of correctness, by calculating with +*sets* instead of numbers, in particular with intervals, and boxes that are Cartesian products of intervals in higher dimensions, that contain the correct result. We can also enclose sets that solve systems of equations and inequalities. + +We will show how these ideas can be used to obtain precise and rigorous results for dynamical systems, including iterated maps and ODEs.
+Variational inference is a fast, scalable method for fitting complex statistical models to large and high-dimensional datasets. The repertoire of available algorithms and techniques is expanding rapidly, but most models are still coded by hand. The few automated implementations (e.g., in Stan) face a dual-language problem, and so are less suited to rapid development of new ideas. VinDsl.jl aims to provide a variational inference domain-specific language -- a set of data structures and macros for defining models -- in pure Julia. As a result, existing methods can be mixed and matched and new ones prototyped quickly, creating a thoroughly hackable toolbox for machine learning researchers. In this talk, I'll give an introduction to variational inference and sketch the philosophy and features of VinDsl, ending with applications to some problems in neuroscience.
+Genome-wide association studies (GWASes) examines phenotypic variation in a sample of patients genotyped at several places on the genome. Since GWASes were introduced in 2005, researchers have performed GWASes for hundreds of traits on thousands of individuals. GWASes produce massive quantities of data that present computational and model selection challenges to their analysis. Prevalent among GWAS analyses is a noticeable failure to explain substantial portions of the observed phenotypic variance. We exploit iterative hard thresholding (IHT) to effectively select genetic markers informative for continuous traits. Preliminary tests suggest that our implementation effectively controls type I errors better than both LASSO- and MCP-penalized linear regression. Our scalable implementation enables GWAS analysis on both desktop machines and computing clusters.
+We relax parametric inference to a non-parametric representation over the Bayes tree, towards more general factor graph solutions. We use Gaussian Mixture models to represent a wider class of constraint beliefs, including multi-hypothesis inference. The Bayes tree factorization maximally exploits the structure of the true joint posterior, thereby minimizing computation. We use approximate non-parametric belief propagation over the cliques of the Bayes tree to reduce the computational complexity. Robotic navigation and mapping is our focused application. Our implementation has been written entirely in the Julia language, exploiting high performance and parallel computing.
+Mendel (https://www.genetics.ucla.edu/software/mendel) is a comprehensive statistical genetic analysis program, developed by biomathematician Kenneth Lange (http://people.healthsciences.ucla.edu/institution/personnel?personnel_id=45702) and his colleagues at UCLA. The current version of Mendel consists of more than 75,000 lines of dense Fortran 2008 code. Documentation exceeds 300 pages. Software development in statistical genetics is currently chaotic, and some consolidation is inevitable. The challenge is to accomplish this in a manner that enhances rather than stifles creativity. OpenMendel is an open source project that rewrites Mendel using the elegant and efficient language Julia. Its code base will serve as a platform for the truly large genetics studies now being launched and enables researchers to quickly tailor it to their specific needs. This talk outlines the vision and status of the OpenMendel project.
+Lora is a package for Monte Carlo methods in Julia. The package has been supporting geometric MCMC algorithms for the last two years. It has been refactored over the last six months to allow more efficient memory management and execution time by allocating necessary resources at the beginning of the simulation thus avoiding unnecessary reallocations and by using meta-programming to tailor methods to user-defined simulation settings. Furthermore, graphs are used for model specification, Gibbs sampling has been accommodated, output management has been improved and forward as well as reverse mode automatic differentiation capabilities have been added to MCMC samplers. + +The roadmap of Lora includes adding documentation for existing functionality, capabilities for state of the art Monte Carlo integration, sequential and variational Monte Carlo algorithms, and other parallel-based MCMC sampling schemes. The overarching goal is to turn Lora into a powerful framework that can be used for tackling challenging applied problems. Along these lines, a contract has been signed with Springer to author a book on Monte Carlo methods with Julia (using Lora), and a collaboration with NASA has been set up for using MCMC inference for exoplanet discovery. Such collaboration will be particularly useful because it entails complex models with constrained parameters, so it will provide further feedback to help Lora meet the challenges of non-trivial applications.
+This talk will describe how researchers in the Federal Reserve Bank of New York’s DSGE Team use Julia for macroeconomic modeling. In collaboration with the QuantEcon team, we ported our code for solving dynamic stochastic general equilibrium (DSGE) models to Julia, releasing the source code in the DSGE.jl package in December. DSGE models describe how economic agents behave, given some assumptions about the underlying environment, including fiscal and monetary policy regimes, price rigidities, credit frictions, and various economic shocks. The FRBNY model is a relatively large model of the U.S. economy, has been used for research on the dynamics of inflation during the great recession, the effects of forward guidance, and much more. + +The DSGE.jl package facilitates the solution and Bayesian estimation of DSGE models. We provide the FRBNY model as one example, but give details on how users can define completely different models. In this talk, I will give a brief overview of the model and our experience porting the code from MATLAB to Julia (including perspective on using Julia in a "production" setting at a public policy institution). Finally, I will touch on the Julia features our team has found most useful for economic modeling
+BioJulia is a collaborative and open source project to make an infrastructure for bioinformatics. Although we have developed many features, we still lack common tools that are indispensable in the real world. In the project this year, we will implement new tools including online sequence search, data structure for reference genomes, BAM and CRAM parsers, VCF and GFF3 parsers, and integration with genome browsers and biological databases. These things will enable you to use the Julia language in your bioinformatics work and will make it much easier to develop new algorithms and softwares. In this talk, I will present what happened in the recent BioJulia project and what will happen in it for the next months.
+In 1959 C.P. Snow's famous lecture, "The Two Cultures", decried the failure of educated people in the sciences and humanities to work together. Today we have a similar divide opening between those who write software for science and those who write it for "everything else". In this talk, we'll review the current state of affairs and look at what Julia might do to remedy the situation. The hope is that Julia can be a great programming language not just for science, but for programmers everywhere.
+Graph visualization is one of the fundamental parts of many modern applications like network analysis. Currently, many packages are available in Julia that can be used for visualizing graphs. But all these packages are tailored to work with a specific backend and it is tedious to write separate code for each package as the requirement changes. To tackle this issue, in this project, we will extend GraphLayout.jl (an existing graph visualization package that uses Compose.jl) to be backend-agnostic. The result will facilitate many applications to use the package and switch between backends used to visualize graphs with minimal changes in the code used. GraphLayout.jl will be modified to generate an intermediate Geometric Type, similar to what is discussed in this issue in GeometryTypes.jl using StructsOfArrays. Therefore, any backend that supports this type can be used to render graphs. Completion of this project will eliminate the redundant code present in visualization packages created for different backends.
+I hope to develop a package, ParallelGraphs, that enables the analysis and manipulation of massive graphs in a distributed environment. The package will support vertex and edge properties through N-Dimensional sparse arrays. The package will be integrated with LighGraphs.jl and ComputeFramework for the serial and parallel execution of graph algorithms. I hope to also incorporate a query model that will let data scientists issue SQL like queries on the graph structure.
+Apple's Accelerate, Yeppp!, and Intel's VML provide high-performance implementations of many common vector functions and operations. Traditionally, use of these libraries required specific intervention by the programmer, and familiarity with Julia's C interface. By taking advantage of Julia's LLVM backend, and detailed benchmarking on package install, I aim to dynamically map Julia functions to the fastest vectorized equivalents available on a specific Julia installation. By building a common interface to these libraries, the same code that was written on OS X linking against Accelerate, can automatically be run without change on Windows linking against VML, and can automatically be run without change on Linux linking against Yeppp!.
+This project is about implementing HTTP/2 for HTTPServer.jl and Requests.jl, as well as implementing a heuristic for Mux.jl for HTTP/2’s “server push”. In the end, It is expected that Mux.jl, HTTPServer.jl and Request.jl users can seamlessly transit to HTTP/2 with little changes on their sides.
+A short talk about my Google Summer of Code project to create a Julia program for completing interactive tutorials, being available in the REPL and in Juno, with a webpage interface as a stretch goal. Paired with this will be a tool for creating these lessons, and a central repository from which students can download tutorials and to which tutorial creators can upload.
+Documenting packages with JuliaDocs/Documenter.jl -- what it can do for you and an overview of the latest developments.
+An algorithmic sampling of getting Julia to run fast + +Possible subtopics include: type-inference, high-level optimizations, call devirtualization, caching, static compilation, llvm translation, "exotic" hardware runtime, future development plans
+Many problems in applied sciences are posed as optimization problems over the complex field such as phase retrieval from sparse signals, designing an FIR filter given desired frequency response, optimization problems in AC power systems, frequency domain analysis in signal processing and control theory. +The present approach is to manually convert the complex-domain problems to real-domain problems and pass to solvers. This process can be time-consuming and non-intuitive sometimes. The correct approach to such problem would be to make existing packages deal with complex-domain optimization hence making it easier for the optimization community to deal with complex-domain optimization problem. I am extending the above functionality in Convex.jl (a julia package for disciplined convex programming).
+Pre-solving is the process of detecting redundancy in the optimization problem and removing them so that optimization problems that are fed to solvers are properly formulated. The reduced optimization problem is now solved by the solver. This has the two-fold benefit of speeding up the optimization process and +also higher accuracy in solutions. Since smaller problems are fed to the solver (eg. SCS) , the bottleneck call to the solver has now become faster
+ODE.jl is an ever increasing store house of numerical solvers of ordinary differential equations available to Julia users. While many solvers are in ODE.jl, there are still well-known and well-performing solvers which are awaiting a native Julia implementation (especially implicit solvers for stiff ODEs). Here we review an implicit and adaptive step-size solver based on the Adam-Bashforth-Multon method which we have implemented in the Julia Language. Although development is still ongoing and final revisions are necessary before merging into ODE.jl, we present preliminary performance results of the solver using the ever expanding IVPTestSuite.jl package. + +EDIT
+The ideal keypoint detector finds salient image regions such that they are repeatably detected despite change of viewpoint and more generally it is robust to all possible image transformations. Similarly, the ideal keypoint descriptor captures the most important and distinctive information content enclosed in the detected salient regions, such that the same structure can be recognized if encountered. The primary aim of my GSoC project is to develop ImageFeatures.jl, a package for keypoint extraction. I am also working on the exposure correction functions of Images.jl.
+Linear equations and linear algebra in general have a wide range of applications, some of them even critical, for this and other cases really good approximations are required and using the ‘\’ operator is not an option. For this situations iterative solver packages are the way to go, these contain a collection of methods which could be configured to accomplish better and more reliable approximations. + +Nevertheless, there isn’t yet a clear common API for these packages in Julia. In some cases when solving equations you would like to have just the approximation, in other cases however you would like more information about the convergence of the iterative process, like the residual norm of each iteration. + +There is one last case not present in most linear algebra packages, the ability to query information out of a running method, this would prove most useful when the calculation takes a long time, if it is bound to end at all. This could make the user to feel confused about what is going on and tempting him to end the execution. + +Here I show the current work and ideas aimed improve the usability of the IterativeSolvers.jl.
+A Julia environment that introduces a new approach to configuration of a Julia project structure and dependency management. + +The Julia language comes with a global language dependency management functionality. We introduce an environment structure which will allow organizing dependencies on a local level (i.e. directory). The environment will provide developers with a project-level dependency management which guarantees a precisely reproducible self-contained project source tree. + +This work is the part of the larger effort to redesign the package dependency management for the Julia language.
+ComputeFramework is a package that has a scheduler similar to that of Dask (dask.pydata.org) which minimizes memory footprint in parallel programs allowing processing of huge amounts of data even on a single machine with limited RAM.
+Airborne laser scanning provides a good way to create accurate, high resolution, three dimensional maps of large areas. The most basic data product is generally a swath of point sampled geometry below the aircraft, containing a million 3D point samples or so per second of flight. Absolute accuracy and consistency between overlapping flights depends on accurate positioning, with point cloud errors on the order of several centimeters for a typical high end GPS and inertial navigation system. + +Accuracy can be further improved by matching point clouds from distinct scans in overlapping areas, using these to infer an improved position solution via a large scale optimization. We have built and contributed to several Julia modules while tackling this problem, including Proj4, Geodesy, and others which we hope to release in the future. + +In this talk I present our work on an improved API for Geodesy, showing how Julia’s highly parameterizable types ease the difficulty of working in multiple geospatial coordinate systems. A minimal traits-based system allows users to define their own point types and transform them with Geodesy in a non-intrusive way. As a concrete use case, I’ll present our results from running large scale trajectory optimizations, and demonstrate the improvements with visualizations of some interesting laser scans.
+Did you know that your Julia programs could be running much, much faster than they do now? Recently, the High Performance Scripting team at Intel Labs released ParallelAccelerator.jl, a Julia package that leverages parallel compute resources (such as the multicore computer you probably already have on your desk) and compile-time and run-time optimizations to drastically speed up Julia programs, especially those that do lots of numeric array operations. + +In this talk, we'll see some examples of how to use the ParallelAccelerator package, see what kind of speedups are possible, and then take a look at what ParallelAccelerator is doing under the hood. Finally, we'll step back and discuss the future of parallelism in Julia. + +This talk will be of interest to people interested in compilers, macros, parallel computing, array- or vector-style programming, and anyone interested in making their Julia code run faster!
+Combined simulations, i.e. solving a mixture of discrete-events (implemented as processes or agents) and continuous-time models (systems of differential equations), is a challenging topic. The two paradigms are almost orthogonal and most simulation software is written with one specific purpose in mind. In this talk, I will show how both can fit naturally in the SimJulia.jl package. The differential equations are efficiently integrated with a quantized state system solver. The pitfall of the mainstream ODE solvers, the time discretization, is replaced by a state discretization. The resulting discrete state-machine can easily be implemented as an event-driven model. This allows to make and solve sophisticated models, eg. a pilot ejection system, which are otherwise very hard to do. Julia has some unique features that ease the coding of both the discrete-event kernel and the state quantizer.
+High performance computing (HPC) on large distributed memory systems is today an irreplaceable tool in computational physics. To solve complex systems of partial differential equations (PDEs) such as e.g. the Einstein equations, today's discretization methods employ irregular grids and adaptive methods that are difficult to map onto modern HPC architectures in an efficient manner. + +FunHPC (Functional High Performance Computing) is both a promising proof of concept as well as an existing Julia package for scalable distributed computing. It is based on a partitioned global address spaces, latency hiding, ephemeral threads, and lightweight synchronization primitives. + +FunHPC targets PDE discretization methods with irregular, hierarchical data structures. I will describe the ideas behind and demonstrate an implementation of this approach via examples.
+QuDynamics is a Julia package which provides a framework for solving dynamical equations arising in Quantum Mechanics. The current version includes support for solving Schrodinger equations, Liouville von Neumann equations and Lindblad master equations with methods which have been integrated from various other Julia packages like ODE.jl, ExpmV.jl, Expokit.jl. The aim of the talk is to introduce QuDynamics with some examples, and focus on ongoing work to equip QuDynamics with additional features such as Monte-Carlo parallelization, addition of new solvers among many others. + +The repo is being maintained at + +https://github.com/JuliaQuantum/QuDynamics.jl.
+Consistent with Julia's philosophy of having *both* performance and safety, it is important to have bounds checks on array accesses by default, as well as a means to eliminate such checks when the compiler or user can prove that they are unnecessary. Julia v0.5 introduces a new mechanism for user-extensible bounds checking and elimination via simple call-site decoration. In this talk, I will discuss the design approach and show off some of the internals of the implementation. Finally, I will show how to take advantage of this new feature for custom array types.
+Datasets in many research disciplines involve large networks; examples include biological datasets, transportation networks, and social media networks. In this talk, we will describe how we are using Julia in our research into new network algorithms and why we created the MatrixNetworks.jl package to bridge between the linear algebra routines in Julia and the network algorithms. We will discuss algorithms that we have recently created for graph diffusions and network alignment methods where having methods that interface between these representations is essential.
+In this talk, we present Yeppp!, a high-performance mathematical library providing vectorized elementary operations and transcendental functions. We compare the performance of Yeppp! with libraries such as Intel MKL and code generated by the optimizing compilers LLVM and GCC. We demonstrate that the SIMD-vectorization and software pipelining techniques used in Yeppp! permit higher throughput compared to similar offerings, and we directly compare implementations of element-wise floating point addition in unoptimized assembly, code generated by LLVM and GCC, and Yeppp!. The experiments reveal that Yeppp!’s implementation outperforms alternative implementations.
+Julia has the beautiful REPL, and adapting it easily to all kinds of system. +Demonstrate how can interactive debugging, scripting with Julia for iOS App development.
+There exist many well-establish scientific libraries written C and Fortran which, taken together, form a software stack that supports high performance applications. This talk describes the wrapping of the Portable Extensible Toolkit for Scientific Computation (PETSc), a library for solving sparse linear and non-linear problems, such as those that arise from discretizing partial differential equations, on distributed memory systems. With 3,674 functions defined in its header files, wrapping the library is a significant challenge. The Clang.jl package is used to generate Julia Exprs for the C functions, which are then modified by a re-writer function to a more Julian form. In order to support matrices containing real and complex data, the package builds and links to 3 versions of PETSc simultaneously. To present the user with a unified interface, new Vector and Matrix types are defined that present the AbstractArray interface and contain additional functionality such as control over assembly of distributed-memory data structures and mapping local indices to global indices. Similarly, the iterative solver interface supports default usage as an A \ b solver, but also contains a wide variety of options for pre-conditioning and the choice of Krylov method. An overview of the present state of the wrappers and future work will be given.
+jInv is a Julia framework for the solution of large-scale PDE constrained optimization problems. It supports linear and nonlinear PDE constraints and provides many commonly used tools in inverse problems such as different misfit functions, regularizers, and efficient methods for numerical optimization. Also, it provides easy access to both iterative and direct linear solvers for solving linear PDEs. A main feature of jInv is the provided easy access to parallel and distributed computation supporting a variety of computational architectures: from a single laptop to large clusters of cloud computing engines. Being written in the high-level dynamic language Julia, it is easily extendable and yet fast. I will outline jInv's potential using examples from geophysical imaging with both linear and nonlinear PDE forward models.
+Accelerated computing has become increasingly popular in the scientific community over the past few years. However, a common challenge is the dearth of easy high-level APIs. This talk is about using the package ArrayFire.jl to write accelerated kernels in Julia with easy Julian APIs. It is designed to mimic Base Julia in its versatility and ease of use, and allows you to switch between three backends: CPU, OpenCL and CUDA, without changing any code. This talk would demonstrate those capabilities and interesting applications using ArrayFire.
+
+
+
+
+
+
+
+ The third Julia conference will take place June 21st-25th, 2016 at the + Massachusetts Institute of Technology in Cambridge, Massachusetts. + Expect cutting-edge technical talks, hands-on workshops, a chance to rub + shoulders with Julia's creators, and a weekend in a city known for its + historical significance and colonial architecture. + Looking forward to seeing you there!
+ + +| Tuesday, June 21 | Workshops | +
| Wednesday-Friday, June 22-24 | Talks | +
| Saturday, June 25 | Hackathon | +
The JuliaCon 2016 committee is happy to announce the following keynote speakers:
+ +
Timothy E. Holy is Associate Professor of Neuroscience at Washington University in St. Louis. In 2009 he received the NIH Director’s Pioneer award for innovations in optics and microscopy. His research interests include imaging of neuronal activity and his lab was probably one of the first to adopt Julia for scientific research. He is a long time Julia contributor and a lead developer of Julia’s multidimensional array capabilities as well as the author of far too many Julia packages.
Thomas J. Sargent is Professor of Economics at New York University and Senior Fellow at the Hoover Institution. In 2011 the Royal Swedish Academy of Sciences awarded him the Nobel Memorial Prize in Economic Sciences for his work on macroeconomics. Together with John Stachurski he founded quant-econ.net, a Julia and Python based learning platform for quantitative economics focusing on algorithms and numerical methods for studying economic problems as well as coding skills.
Guy L. Steele Jr. is a Software Architect for Oracle Labs and Principal Investigator of the Programming Language Research project. The Association for Computing Machinery awarded him the 1988 Grace Murray Hopper award. He has co-designed the programming language Scheme, which has greatly influenced the design of Julia, as well as languages such as Fortress and Java.
Talks in previous years tackled problems in such diverse fields as bioinformatics, economics, numerical optimization, parallel computing, web development, and more. For an example of what to expect, check out this random talk from last year's JuliaCon:
+The conference will be held in the Stata Center in rooms 123, 141, and 144.
+ +The arrows below point to the entrances that will be unlocked for the hackathon on Saturday:
+
The JuliaCon committee is composed entirely of volunteer organizers
+ and can be reached at juliacon@julialang.org
+ with any questions or comments.
Accommodations for the conference can be found on MIT's + Where To Stay and + Bed and Breakfast pages. + If none of the locations on these pages suit you, here are a few additional B&B-style locations:
+ +Want to be a JuliaCon 2016 sponsor? Three different sponsorship tiers are available: +
| Sponsorship | +Tier | +Complimentary Tickets | +Speaking Slot | +
|---|---|---|---|
| $15000 | +Platinum | +3 tickets (Conference + Workshop) | +15 minutes | +
| $5000 | +Gold | +2 tickets (Conference + Workshop) | +10 minutes | +
| $2000 | +Silver | +1 ticket (Conference + Workshop) | +5 minutes | +
For further details on sponsorship, please contact the JuliaCon committee.
+JuliaCon 2016 Platinum sponsors: +
+ JuliaCon 2016 Gold sponsors: +
+ JuliaCon 2016 Silver sponsors: +
+ 
+ 
+ ...along with a generous personal donation from Jeffrey Sarnoff.
+With 100+ attendees for JuliaCon 2014 and JuliaCon India, and 200+ attendees for last + year's JuliaCon at MIT, we hope that this year we'll be able to meet even more of you and + further grow our awesome community of scientists, hackers and engineers. Come join us!
+In the meantime, feel free to check out previous JuliaCons by following the links below:
+ +All attendees, speakers, sponsors, and volunteers at our conference are required to agree with and follow the code of conduct. As this is a MIT Event, attendees should also respect the Policy on Harassment.
+ +JuliaCon is dedicated to providing a harassment-free conference experience for everyone, regardless of gender, sexual orientation, disability, physical appearance, body size, race, religion, or tabs vs spaces preference. We do not tolerate harassment of conference participants in any form. Sexual language and imagery is not appropriate for any conference venue.
+ +Harassment includes offensive verbal comments, sexual images in public spaces, deliberate intimidation, stalking, following, harassing photography or recording, sustained disruption of talks or other events, inappropriate physical contact, and unwelcome sexual attention. Participants asked to stop any harassing behavior are expected to comply immediately.
+ +If a participant engages in harassing behavior, the conference organizers may take any action they deem appropriate, including warning the offender or expulsion from the conference with no refund. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact a member of conference staff immediately. Conference staff will be happy to help participants contact hotel/venue security or local law enforcement, provide escorts, or otherwise assist those experiencing harassment to feel safe for the duration of the conference. We value your attendance.
+ +We expect participants to follow these rules at all conference venues and conference-related social events.
+ +If an incident occurs please contact Stefan Karpinski <stefan@karpinski.org> or Katharine Hyatt <kslimes@gmail.com>.
+
+
+
+
+
+
+
+ The third Julia conference will take place June 21st-25th, 2016 at the + Massachusetts Institute of Technology in Cambridge, Massachusetts. + Expect cutting-edge technical talks, hands-on workshops, a chance to rub + shoulders with Julia's creators, and a weekend in a city known for its + historical significance and colonial architecture. + Looking forward to seeing you there!
+ + +| Tuesday, June 21 | Workshops | +
| Wednesday-Friday, June 22-24 | Talks | +
| Saturday, June 25 | Hackathon | +
The JuliaCon 2016 committee is happy to announce the following keynote speakers:
+ +Timothy E. Holy is Associate Professor of Neuroscience at Washington University in St. Louis. In 2009 he received the NIH Director’s Pioneer award for innovations in optics and microscopy. His research interests include imaging of neuronal activity and his lab was probably one of the first to adopt Julia for scientific research. He is a long time Julia contributor and a lead developer of Julia’s multidimensional array capabilities as well as the author of far too many Julia packages.
Thomas J. Sargent is Professor of Economics at New York University and Senior Fellow at the Hoover Institution. In 2011 the Royal Swedish Academy of Sciences awarded him the Nobel Memorial Prize in Economic Sciences for his work on macroeconomics. Together with John Stachurski he founded quant-econ.net, a Julia and Python based learning platform for quantitative economics focusing on algorithms and numerical methods for studying economic problems as well as coding skills.
Guy L. Steele Jr. is a Software Architect for Oracle Labs and Principal Investigator of the Programming Language Research project. The Association for Computing Machinery awarded him the 1988 Grace Murray Hopper award. He has co-designed the programming language Scheme, which has greatly influenced the design of Julia, as well as languages such as Fortress and Java.
Talks in previous years tackled problems in such diverse fields as bioinformatics, economics, numerical optimization, parallel computing, web development, and more. For an example of what to expect, check out this random talk from last year's JuliaCon:
+The conference will be held in the Stata Center in rooms 123, 141, and 144.
+ +The arrows below point to the entrances that will be unlocked for the hackathon on Saturday:
+
The JuliaCon committee is composed entirely of volunteer organizers
+ and can be reached at juliacon@julialang.org
+ with any questions or comments.
Accommodations for the conference can be found on MIT's + Where To Stay and + Bed and Breakfast pages. + If none of the locations on these pages suit you, here are a few additional B&B-style locations:
+ +Want to be a JuliaCon 2016 sponsor? Three different sponsorship tiers are available: +
| Sponsorship | +Tier | +Complimentary Tickets | +Speaking Slot | +
|---|---|---|---|
| $15000 | +Platinum | +3 tickets (Conference + Workshop) | +15 minutes | +
| $5000 | +Gold | +2 tickets (Conference + Workshop) | +10 minutes | +
| $2000 | +Silver | +1 ticket (Conference + Workshop) | +5 minutes | +
For further details on sponsorship, please contact the JuliaCon committee.
+JuliaCon 2016 Platinum sponsors: +
+ JuliaCon 2016 Gold sponsors: +
+ JuliaCon 2016 Silver sponsors: +
+
+
+ ...along with a generous personal donation from Jeffrey Sarnoff.
+With 100+ attendees for JuliaCon 2014 and JuliaCon India, and 200+ attendees for last + year's JuliaCon at MIT, we hope that this year we'll be able to meet even more of you and + further grow our awesome community of scientists, hackers and engineers. Come join us!
+In the meantime, feel free to check out previous JuliaCons by following the links below:
+ +All attendees, speakers, sponsors, and volunteers at our conference are required to agree with and follow the code of conduct. As this is a MIT Event, attendees should also respect the Policy on Harassment.
+ +JuliaCon is dedicated to providing a harassment-free conference experience for everyone, regardless of gender, sexual orientation, disability, physical appearance, body size, race, religion, or tabs vs spaces preference. We do not tolerate harassment of conference participants in any form. Sexual language and imagery is not appropriate for any conference venue.
+ +Harassment includes offensive verbal comments, sexual images in public spaces, deliberate intimidation, stalking, following, harassing photography or recording, sustained disruption of talks or other events, inappropriate physical contact, and unwelcome sexual attention. Participants asked to stop any harassing behavior are expected to comply immediately.
+ +If a participant engages in harassing behavior, the conference organizers may take any action they deem appropriate, including warning the offender or expulsion from the conference with no refund. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact a member of conference staff immediately. Conference staff will be happy to help participants contact hotel/venue security or local law enforcement, provide escorts, or otherwise assist those experiencing harassment to feel safe for the duration of the conference. We value your attendance.
+ +We expect participants to follow these rules at all conference venues and conference-related social events.
+ +If an incident occurs please contact Stefan Karpinski <stefan@karpinski.org> or Katharine Hyatt <kslimes@gmail.com>.
+
+
+
+
+
+
+
+ Please see here for Tuesday workshop schedule.
+ +Most talks are 30 minutes long (plus 5 minutes for questions).
+⚡ denotes a lightning talk. These talks are 8 minutes long (plus 2 minutes for questions).
+ + +
+
+
+
+
+
+
+ | Track 1 - Room 32-123 | Track 2 - Room 32-141 | |
|---|---|---|
| 8:30 | LIGHT BREAKFAST | |
| 9:00 | Invitation to Intermediate-Level Julia | Introduction to Writing High Performance Julia |
| 12:00 | LUNCH | |
| 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 | |
| 17:15 | END |
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: +
| https://github.com/dpsanders/invitation_to_julia | (workshop materials) |
+ 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: +
| https://www.youtube.com/watch?v=gQ1y5NUD_RI | (video) |
| https://github.com/dpsanders/invitation_to_julia | (IJulia notebooks) |
+ 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: +| http://www.blonzonics.us/julia/juliacon-2016 | (workshop materials) |
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. +
+Tom Breloff
+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: +
| https://github.com/tkelman/JuliaCon2016workshop | (workshop materials) |
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: +
Multi-Threading Julia: +
GPUs +
MPI and Elemental +
ComputeFramework - out of core parallel computations +
Bio: + Prolific contributors to the Julia ecosystem. +
+
+
+
+
+ JuliaCon is dedicated to providing a harassment-free conference +experience for everyone, regardless of gender, gender identity and +expression, sexual orientation, disability, physical appearance, body +size, race, age, religion, text editor choice, or tabs vs spaces +preference. We do not tolerate harassment of conference participants +in any form. Offensive or sexual language and imagery is not +appropriate for any conference venue, including formal talks and +networking between sessions. Conference participants violating these +rules may be sanctioned or expelled from the conference (without a +refund) at the discretion of the conference organizers.
+ +Harassment includes, but is not limited to:
+ +Participants asked to stop any harassing behavior are expected to +comply immediately If a participant engages in harassing behavior, +event organizers retain the right to take any actions to keep the +event a welcoming environment for all participants. This includes +warning the offender or expulsion from the conference with no +refund. Event organizers may take action to redress anything designed +to, or with the clear impact of, disrupting the event or making the +environment hostile for any participants. We expect participants to +follow these rules at all event venues and event-related social +activities. We think people should follow these rules outside event +activities too!
+ +If someone makes you or anyone else feel unsafe or unwelcome, please +report it as soon as possible. Harassment and other code of conduct +violations reduce the value of our event for everyone. We want you to +be happy at our event. People like you make our event a better +place. You can make a report either personally or anonymously.
+ + + +You can make a personal report by calling or messaging this phone +number: (TBD) or this email address +juliacon@julialang.org (private group of the committee). +This phone number will be continuously monitored for the duration of the event.
+ +When taking a personal report, our staff will ensure you are safe and +cannot be overheard. They may involve other event staff to ensure your +report is managed properly. Once safe, we’ll ask you to tell us about +what happened. This can be upsetting, but we’ll handle it as +respectfully as possible, and you can bring someone to support +you. You won’t be asked to confront anyone and we won’t tell anyone +who you are.
+ +Our team will be happy to help you contact hotel/venue security, local +law enforcement, local support services, provide escorts, or otherwise +assist you to feel safe for the duration of the event. We value your +attendance.
+ +Diversity Coordinator: Erica Moszkowski erica.moszkowski@gmail.com
+ + + +© 2014-2020 JuliaCon.org All rights reserved. + Fork this site on Github or + open a bug report.
+ +
+ 
+ + + + +
++
+
+ + + University of California Berkeley and Lawrence Berkeley Laboratory + +
++
+
+ + + Lawrence Berkeley Laboratory + +
++
+
+ + + Stanford University + +
++
+Andreas Noack (executive chair), Valentin Churavy (program chair), Jiahao Chen, David Anthoff, Alex Arslan, Alan Edelman, Shashi Gowda, Katharine Hyatt, Stefan Karpinski, Kevin Keys, Simon Kornblith, Jonathan Malmaud, Erica Moszkowski (diversity chair), Jarrett Revels, Viral B. Shah, David P. Sanders, and Pontus Stenetorp
++ The JuliaCon committee is composed entirely of volunteer organizers + and can be reached at juliacon@julialang.org + with any questions or comments. +
+ + +Pauley Ballroom is upstairs in the Martin Luther King Jr. Student Union Building within the UCB campus. Here's a map: +
+ + + +
+
+
+
+ 
+
+ 
+ 
+
+ 
+
+
+ 
+
+ © 2014-2020 JuliaCon.org All rights reserved. + Fork this site on Github or + open a bug report.
+ +© 2014-2020 JuliaCon.org All rights reserved. + Fork this site on Github or + open a bug report.
+ +This is an introductory tutorial on Julia as it is today, aimed at people with experience in another language, and who want to get up to speed quickly as Julia heads towards its first stable version.
+ + +David P. Sanders is associate professor of computational physics in the Department of Physics of the Faculty of Sciences at the National University of Mexico in Mexico City.
+His previous Julia tutorials on YouTube have over 75,000 views. He is a principal author of the ValidatedNumerics.jl package for interval arithmetic, and IntervalConstraintProgramming.jl for constraint propagation.
Over the last few years we have seen Deep Learning rise to prominence not just in academia with state-of-the-art results for well-established tasks, but also in industry to leverage an ever-increasing amount of data becoming available. Due to the computationally heavy nature of Deep Learning approaches, Julia is in a unique position to serve as the language of choice for developing and deploying deep machine learning models. +In this workshop we will introduce Deep Learning for a general audience – assuming only high school-level mathematics to gain a practical understanding of the topics covered. We will first introduce the history and theoretical underpinnings of Deep Learning. After this we will proceed to introduce the lay of the land in terms of libraries and frameworks in Julia – demonstrating to the audience how one can implement state-of-the-art Deep Learning models for various forms of data. After attending the workshop the audience will have an understanding of how they can use Julia for Deep Learning and adapt these approaches to their own data. +The organisers of the workshop have between them many years of experience of teaching, research, and working with and implementing Deep Learning frameworks in Julia and other programming languages.
+ + +Mike Innes is a software engineer at Julia Computing, where he works on the Juno IDE and the machine learning ecosystem. +Jon Malmaud is a PhD candidate at MIT’s Brain and Cognitive Science Department, where he works on AI and Deep Learning. He’s also a core contributor to the Julia language, and created Julia’s TensorFlow bindings. +Pontus Stenetorp is a research associate at University College London, that spends most of his research time on Natural Language Processing and Machine Learning – with a particular focus on Deep Learning. He has been using Julia since 2014 due to a need for rapid prototyping and computational performance. When it comes to Julia contributions, he tends to contribute small occasional patches to the standard library.
+ +Start using Julia to do simulations of quantum systems with many interacting particles! We will write a single-core exact diagonalization code which can handle a variety of models from quantum physics, using Julia to make it readable and performant. We’ll tour the Julia package ecosystem for useful packages that will help us store our results to share with others and get to the interesting physics. Then, we’ll use some of Julia’s parallel features to scale up our code to do many-body simulation on many-core and many-node systems in a convenient, reproducible, and fast way. You need not ever have written any Julia before. We’ll use physics examples as natural motivation to explore Julia’s capabilities, but no background in quantum mechanics is required. We will introduce the models as we go.
+ + +5th year physics graduate student, sometimes Julia contributor
+ +This interactive workshop will introduce a couple of tools and packages for GPU programming in Julia: how to set-up a working environment, basic usage, and optimization. Participants will be able to follow along using their own system, or on a cloud-based JuliaBox instance.
+Contributors to the JuliaGPU ecosystem
+ +After attending this workshop, you will have the skills needed to integrate Julia in real-world environments. Not only that, you will understand at least one strategy for distributing Julia data analysis at production scale on large data sets and streaming data. +The Roadmap of the workshop will include:
+Daniel (@dwhitena) is a Ph.D. trained data scientist working with Pachyderm (@pachydermIO). Daniel develops innovative, distributed data pipelines which include predictive models, data visualizations, statistical analyses, and more. He has spoken at conferences around the world (Datapalooza, DevFest Siberia, GopherCon, and more), teaches data science/engineering with Ardan Labs (@ardanlabs), maintains the Go kernel for Jupyter, and is actively helping to organize contributions to various open source data science projects.
+ +I am the developer of NLOptControl.jl, a JuliaOpt tool that is an extension for JuMP.jl. NloptControl.jl is used for formulating and solving nonlinear optimal control problems. A current limitation of optimization modeling software, such as JuMP is that it does not allow for ease of adding integral constraint equations. +NLOptControl.jl also provides an implementation of the pseudo-spectral method written in written in julia which is extremely fast. While I have not yet benchmarked it against GPOPSii (a commercial software that also uses this method to solve optimal control problems), I hope to have made some comparisons to help motivate my users during juliaCon2017. NLOptControl.jl is an extension of JuMP.jl, and with that comes the a tremendous amount of power. For instance, have you ever struggled calculating Hessians and Jacobians? Well those days are over because NLOptControl.jl takes care of that for you by simply utilizing JuMP and the automatic differentiation capabilities of ReverseDiffSparse.jl. +Workshop Details The workshop will give people interested in nonlinear optimal control guidance and hands-on experience using a very high level tool that is fast, concise, and powerful. The workshop will be organize into two parts; background information and hands-on experience. The background information section will explain the basics of nonlinear optimal control problems, why I got started with julia, and then show some examples including the Autonomous Vehicle Control problems that I am solving. Then during the hands-on part, users will solve optimal control problems from start to finish and the results will be automatically plotted.
+Mechanical Engineering Ph.D. 4th year student
+ +In this workshop we will introduce the two main packages organized under the JuliaNLSolvers umbrella: Optim.jl for optimization and NLsolve.jl for solving systems of equations. We will look at the types of problems the packages solve, what the interfaces are like, and work on practical examples. A strong mathematical background is not needed, but some understanding of calculus is required to follow the discussion of the different methods.
+ + +Ph.D. student in economics, JuliaNLSolvers owner and developer, Julia nerd.
+ +DifferentialEquations.jl is a highly extendable high-performance library for solving a vast array of differential equations in Julia. The purpose of this workshop is to introduce the participants to DifferentialEquations.jl, focusing on the new types of problems that are able to be explored through this software and how Julia has made this possible. We will start with a tutorial of the ordinary differential equation solvers. Users will be shown how to use the common solver interface to solve and analyze equations using the solvers from OrdinaryDiffEq.jl, Sundials.jl, ODE.jl, LSODA.jl, and ODEInterface.jl. Next, the capabilities will be explored in further depth, and users will walk through solving hybrid differential equations continuous + discrete components), using arbitrary precision and unitful arithmetic, and solving equations with discontinuous events. After that, the tutorial will show users how to branch out to other forms of differential equations, showing how the same interface allows them to use the unique high-order adaptive Runge-Kutta methods for stochastic differential equations and the fast high-order methods for delay differential equations. Lastly, participants will be walked through the analysis add-on tools, using Optim.jl to perform parameter estimation of ordinary differential equation models, identify sensitive parameters, and quantify numerical uncertainties of solutions. Users will leave the workshop with an expanded view of what kinds of problems can be solved with DifferentialEquations.jl and with the knowledge of how to solve them.
+ + +Chris Rackauckas is a 4th year Ph.D. student in Mathematics at the University of California, Irvine. He is the principal author of many Julia packages, including the JuliaDiffEq packages (DifferentialEquations.jl) and ParallelDataTransfer.jl, and has contributed to numerous other packages related to scientific computing. Chris is also actively engaged in the Julia community as the author of the StochasticLifestyle blog and the tutorial “A Deep Introduction to Julia for Data Science and Scientific Computing”.
+ +Julia uses a unique mix of techniques adopted from conventional static and dynamic to provide a special blend of high-performance and flexible compute kernels. This allows it to simultaneously have a fully ahead-of-time-compiled code model – while permitting (even encouraging) code updates at runtime – and a fully runtime-interpreted interface – while permitting extensive compile-time optimization. In this talk, I will examine some of the trade-offs and limitations this requires of user code, especially on common first-class code evaluation features – such as eval and incremental pre-compilation – as well as advanced features – such as @generated functions and @pure. We will also try to take a look at the internal layout and implementation of some of these data structures, and how the compiler works to maintain their correctness over time, despite other changes to the system.
I’ve been a Julia contributor since before it was cool. Now, I’m working for Julia Computing, as the static compilation champion, compiler correctness fiend, and performance cliff jumper.
+ +Increasingly organizations are using cloud platforms to store their data and perform analytics driven by cost, scale, and manageability considerations. Business applications are being retooled to leverage the vast enterprise / public data, artificial intelligence (AI), and machine learning (ML) algorithms. To build and deploy large scale intelligent applications, data scientists and analysts today need to be able to combine their knowledge of analytical languages and platforms like Julia with that of the cloud. +In this talk, data scientists and analysts will learn how to build end-to-end analytical solutions using Julia on scalable cloud infrastructure. Developing such solutions usually requires one to understand how to seamlessly integrate Julia with various cloud technologies. After attending the talk, the attendees should have a good understanding of all the major aspects needed to start building intelligent applications on the cloud using Julia, leveraging appropriate cloud services and tool-kits. We will also briefly introduce the Azure Data Science Virtual Machine DSVM which provides a comprehensive development/experimentation environment with several pre-configured tools to make it easy to work with different cloud services (SQL Data Warehouse, Spark, Blobs etc.) from Julia and other popular data analytics languages. Join this demo heavy session where we cover the end to end data science life-cycle and show how you can access storage and compute services on the Azure cloud using Julia from the DSVM. A self-guided tutorial building upon the examples in the demo will be published online for attendees to continue their learning offline.
+ + +Udayan is a Software Engineer with Algorithms and Data Science group at Microsoft. Before coming to Microsoft, he was designing predictive algorithms to detect threats and malignant apps at a mobile security startup in Chicago. He has a MS and a Ph.D. in Computer Engineering from University of Florida, Gainesville, FL. His research was focused on Trust, Privacy and Behavior mining in Mobile Networks. +Paul is a senior software engineer in Microsoft’s Algorithms and Data Science group, where he is the lead engineer for the Data Science Virtual Machine and works on a variety of solutions for easier machine learning and data science. He was previously the project lead for the Planner service in Office 365. While on Planner he also worked on disaster recovery, topology, storage, and several other core service components. He holds computer science degrees from Clemson and Duke.
+ +Laurent Heirendt, Sylvain Arreckx, Ines Thiele, Ronan M.T. Fleming +Systems Biologists in the COnstraint-Based Reconstruction and Analysis (COBRA) [7] community are gearing up to develop computational models of large and huge-scale biochemical networks with more than one million biochemical reactions. The growing model size puts a strain on efficient simulation and network exploration times to the point that accelerating existing COBRA methods became a priority. Flux balance analysis and its variants are widely used methods for predicting steady-state reaction rates in biochemical reaction networks. The exploration of high dimensional networks has long been hampered by performance limitations of current implementations in Matlab/C (The COBRA Toolbox [8] and fastFVA [3]) or Python (cobrapy [2]). Julia [1] is the language that fills the gap between complexity, performance, and development time. DistributedFBA.jl [4], part of the novel COBRA.jl package, is a high-level, high-performance, open-source Julia implementation of flux balance analysis, which is a linear optimization problem. It is tailored to solve multiple flux balance analyses on a subset or all the reactions of large and huge-scale networks, on any number of threads or nodes using optimization solver interfaces implemented in MathProgBase.jl [5]. Julia’s parallelization capabilities led to a speedup in latency that follows Amdahl’s law. For the first time, a flux variability analysis (two flux balance analyses on each biochemical reaction) on a model with more than 200k biochemical reactions [6] has been performed. With Julia and COBRA.jl, the reconstruction and analysis capabilities of large and huge-scale models in the COBRA community are lifted to another level. +Code and benchmark data are freely available on github.com/opencobra/COBRA.jl +References:
+ +Laurent Heirendt was born in 1987 in Luxembourg City, Luxembourg (Europe). He received his BSc in Mechanical Engineering from the Ecole Polytechnique Fédérale de Lausanne, Switzerland in 2009. A year later, he received his MSc in Advanced Mechanical Engineering from Imperial College London in the UK, where his research and thesis focused on developing a general dynamic model for shimmy analysis of aircraft landing gear that is still in use today. He received his Ph.D. in 2014 in Aerospace Science from the University of Toronto, Canada. He developed a thermo-tribomechnical model of an aircraft landing gear, which led to a patent pending design of a critical aircraft landing gear component. He then worked in industry and oversaw the structural analysis of large aircraft docking structures. +Recently, Laurent started as a Research Associate at the Luxembourg Centre for Systems Biomedicine, where he works in the numerical optimization of large biochemical networks using Julia. Besides his mother tongue Luxembourgish, he is fluent in English, French and German, and he is currently learning Brazilian Portuguese.
+ +How can we find all solutions of a system of nonlinear equations, the “feasible set” satisfied by a collection of inequalities, or the global optimum of a complicated function? These are all known to be hard problems in numerical analysis.
+In this talk, we will show how to solve all of these problems, in a guaranteed way, using a collection of related methods based on interval arithmetic, provided by the IntervalArithmetic.jl package. The starting point is a simple dimension-independent bisection code, which can be enhanced in a variety of ways. This method is rigorous: it is guaranteed to find all roots, or to find the global minimum, respectively.
+One key idea is the use of continuous constraint propagation, which allows us to remove large portions of the search space that are infeasible. We will explain the basics of this method, in particular the “forward-backward contractor”, and describe the implementation in the IntervalConstraintProgramming.jl package.
+This package generates forward and backward code automatically from a Julia expression, using metaprogramming techniques. These are combined into “contractors”, i.e. operators that contract a box without removing any portion of the set of interest. These, in turn, give a rigorous answer to the question whether a given box lies inside the feasible set or not. In this way, a paving (collection of boxes) is built up that approximates the set.
David P. Sanders is associate professor of computational physics in the Department of Physics of the Faculty of Sciences at the National University of Mexico in Mexico City.
+His video tutorials on Julia have a total of 75,000 views on YouTube. He is a principal author of the ValidatedNumerics.jl package for interval arithmetic, and IntervalConstraintProgramming.jl for constraint propagation.
Information in the brain is processed by the coordinated activity of large neural circuits. Neural network models help to understand, for example, how biophysical features of single neurons and the network topology shape the collective circuit dynamics. This requires solving large systems of coupled differential equations which is numerically challenging. +Here, we introduce a novel efficient method for numerically exact simulations of sparse neural networks that bring to bear Julia’s different data structures and high performance. The new algorithm reduces the computational cost from O(N) to O(log(N)) operations per network spike. This is achieved by mapping the neural dynamics to pulse-coupled phase oscillators and using mutable binary heaps for efficient state updates. Thereby numerically exact simulations of large spiking networks and the characterization of their chaotic phase space structure become possible. For example, calculating the largest Lyapunov exponent of a spiking neural network with one million neurons is sped up by more than four orders of magnitude compared to previous implementations in other programming languages (C++, Python, Matlab).
+ + +Rainer just finished his Ph.D. in at the Max Planck Institute for Dynamics and Self-Organization (Göttingen) on ‘Chaotic neural circuit dynamics’ after studying physics at various places. He has been using Julia since 2014, as it minimizes both programming time and CPU time and allows easy debugging, profiling and visualization under one roof.
+ +The Shearlet Transform was proposed in 2005 by the Professor Gitta Kutyniok (http://www3.math.tu-berlin.de/numerik/mt/mt/www.shearlet.org/papers/SMRuADaSO.pdf) and her colleagues as a multidimensional generalization of the Wavelet Transform, and since then it has been adopted by a lot of Companies and Institutes by its stable and optimal representation of multidimensional signals. Shearlab.jl is a already registered Julia package (https://github.com/arsenal9971/Shearlab.jl) based in the most used implementation of Shearlet Transform programmed in Matlab by the Research Group of Prof. Kutyniok (http://www.shearlab.org/software); improving it by at least double the speed on different experiments. +As examples of applications of Shearlet Transform one has Image Denoising, Image Inpaiting and Video Compression; for instance I used it mainly to reconstruct the Light Field of a 3D Scene from Sparse Photographic Samples of Different Perspectives with Stereo Vision purposes. A lot of research institutes and companies have already adopted the Shearlet Transform in their work (e.g. Fraunhofer Institute in Berlin and Charité Hospital in Berlin, Mathematical Institute of TU Berlin) by its directional sensitivity, reconstruction stability and sparse representation.
+ + +Ph.D. student in Mathematics at the Technical University of Berlin (TUB) with Professor Gitta Kutyniok as advisor; major in Mathematics and Physics from National University of México (UNAM); ex Data Scientist of a mexican Open Governance Start Up (OPI); with experience in Data Mining, Machine Learning, Computational Harmonic Analysis and Computer Vision. Currently developing Light Field Reconstruction algorithms using Digital Signal Processing tools for 3D Imaging and Stereo Vision. Is known by his colleagues for using Julia on everything. It was introduced to Julia by Professor David Philip Sanders and after both gave a course on Computational Statistical Physics using Julia at the National University of México (UNAM) which convinced him to adopt Julia as his main programming language.
+ +Flux.jl is a new Julia package for machine learning. It aims to provide strong tooling and support for debugging, high-level features for working with very complex networks, and state of the art performance via backends like TensorFlow or MXNet, while also providing a very high level of interoperability so that approaches can easily be mixed and matched. This talk will introduce Flux from the ground up and demonstrate some of its more advanced features.
+ + +I work with Julia Computing on Julia’s IDE, Juno, as well as various projects within the machine learning ecosystem.
+ +The web is eating the world, but building modern web applications can be an intimidating task. Successful online products must be fast, beautiful and usable. Responsive, maintainable and extendable. Provide simple and flexible web APIs. Be secure. Reach virtually 100% uptime while being easy to debug, extend and update, requiring powerful logging, intelligent caching and rapid scaling strategies. +Julia as a language has an enormous potential in the web space thanks to its concise and friendly syntax, the powerful REPL, Unicode support, cross-platform availability, the efficiently compiled code and its parallel and distributed computing capabilities. And Julia’s ecosystem already provides low level libraries like HttpServer and WebSockets. But they leave the developers having to spend large amounts of time writing glue and boilerplate code: a tedious, expensive and error prone task. +Genie is a new web framework that leverages Julia’s unique combination of features and its extensive collection of packages to empower developers to create high-performance web apps in less time and with less code. It glues low level libraries and contributes its own middlewares to expose a coherent and efficient workflow and a rich API for building web applications. +This talk will give you the guided tour of Genie, introducing the MVC stack and its main components and showing you how to quickly bootstrap a new Genie app and how to easily implement CRUD operations to expose resources over the internet, in an efficient and secure manner. You will see how easy it is to use Genie’s API in tandem with Julia’s modules system to hook up your code - allowing you to focus on your software’s value proposition instead of wasting precious time dealing with the low level details of transporting bytes over the wire.
+ + +Web developer since 2000. Architecting and building multi-tier, performance critical web apps handling large amounts of real time data since 2008. PHP, Ruby, JavaScript, F#, Elixir. Now using Julia and Genie to tackle web development’s own two-language problem (productive-slow-interpreted vs unproductive-fast-compiled). +CTO at OLBG. Startup devotee and serial tech founder. IronHack mentor, organizer of Barcelona Julia and Barcelona on Rails. Creator of Genie.jl.
+ +GLVisualize is a visualization framework written purely in Julia + OpenGL. There are a lot of new changes that I want to talk about:
+Developer of GLVisualize & GPUArrays
+ +Many projects in research and development require analysis of tabular data. For example, medical records can be viewed as a collection of variables like height, weight, and age for different patients. The values may be boolean (yes or no), numerical (100.3), categorical (A, B, O), or ordinal (early, middle, late). Some values may also be missing. However, analysis and feature extraction is made easier by knowing relationships between variables, for example, that weight increases with height. GraphGLRM is a framework that leverages structure in data to de-noise, compress, and estimate missing values. Using Julia’s flexibility and speed, we developed this package quickly and with sufficient performance for real-world data processing needs. GraphGLRMs are now robust and versatile enough to work with sparse, heterogeneous data. We will also discuss updates to Julia data structures and tooling that would ease package development and further empower the GraphGLRM framework. More about GraphGLRMs: https://github.com/mihirparadkar/GraphGLRM.jl More about LowRankModels: https://github.com/madeleineudell/LowRankModels.jl
+ + +Mihir Paradkar recently graduated from Cornell University in Biological Engineering. He has been user of Julia since v0.3.5 and is a developer of GraphGLRM.jl and LowRankModels.jl . He will be starting as a software engineering in data mining at Yelp late this summer.
+ +Data frames are essential tools for data scientists, but existing data frames packages in Julia (and other languages) are sequential and do not scale to large data sets. Alternatively, data frames in distributed frameworks such as Spark are slow and not integrated with other computations flexibly. We propose a novel compiler-based approach where we integrate data frames into the High Performance Analytics Toolkit (HPAT) to build HiFrames. It automatically parallelizes and compiles relational operations along with other array computations in end-to-end data analytics programs, and generates efficient MPI/C++ code. We demonstrate that HiFrames is significantly faster than alternatives such as Spark on clusters, without forcing the programmer to switch to embedded SQL for part of the program. HiFrames is 3.6x to 70x faster than Spark SQL for basic relational operations, and can be up to 20,000x faster for advanced analytics operations, such as weighted moving averages (WMA), that the map-reduce paradigm cannot handle effectively. We will discuss how Julia’s powerful macro and compilation system facilitates developing HiFrames.
+ + +Ehsan Totoni is a Research Scientist at Intel Labs. He develops programming systems for large-scale HPC and big data analytics applications with a focus on productivity and performance. He received his Ph.D. in Computer Science from the University of Illinois at Urbana-Champaign in 2014.
+ +ImageQuilting.jl is a high-performance implementation of texture synthesis and transfer for 3D images that is capable of matching pre-existing data in the canvas where the image is to be synthesized. It can optionally make use of GPUs through the OpenCL standard and is being currently used by the industry for fast generation of 3D geological models. In this talk, I will demonstrate some of the applications of this package in energy resources engineering and hydrogeology, and will highlight the qualities of the Julia programming language that enabled an unprecedented speed in this famous computer vision algorithm.
+ + +I am a Ph.D. candidate in the Department of Energy Resources Engineering at Stanford University. In my research, I study the links between surface processes (i.e. flow and sediment transport) at the surface of the Earth and the resulting geostatistical properties at its subsurface. Part of this research consists of developing efficient algorithms for stochastic/physical simulation of 3D Earth models. For more information, please visit: https://juliohm.github.io
+ +Fully homomorphic encryption (FHE) is a cryptographic technique allowing a user to run arbitrary computations over encrypted data. This is particularly useful for computing statistical analytics over sensitive data. In this work, we introduce a Julia module, Fhe.jl, which supports running Julia functions over an FHE-encrypted data set. We do so by using symbolic execution to convert a Julia function into its circuit representation, which we then evaluate over the encrypted data. In this talk, we will discuss the progress we have made so far, some of the challenges we have run into, and how we hope to work with the Julia community to continue our efforts.
+ + +José Manuel Calderón Trilla is a Research Scientist at Galois, Inc. working on Compilers, Static Analysis, and Formal Methods. He received his Ph.D. from the University of York in the UK for his work on Implicit Parallelism in lazy functional languages.
+ +Julia is a language designed for numerical computing and it does that job pretty well. However, the emphasis on numerical computing and data science tends to overshadow the language’s other use cases. In this talk we share our experiences using Julia to build a distributed data fabric using commodity hardware. A data fabric is a distributed storage system that abstracts away the physical infrastructure and makes data available to applications using well known protocols such as NFS or S3. Our talk focuses on how we use Julia to implement a data fabric with specific examples. We will discuss some of the shortcomings and how we circumvented them. Finally we close by a cost benefit analysis of developing in Julia and how it can be a critical advantage in bringing products to market.
+ + +Ajay works on systems and infrastructure software for fun and profit. He has dabbled in operating systems, memory allocators, file systems and distributed systems. He founded kinant.com in 2017 to simplify the deployment and usage of storage infrastructure.
+ +Julia was designed to be the right language for programming mathematics. In this talk, I’ll argue that its sophisticated type system allows mathematicians to program in the same way they write mathematics. This simplicity has two consequences. First, it has made Julia an attractive ecosystem in which to write mathematical packages: Julia is now the language with the most comprehensive, robust, and user-friendly ecosystem of packages for mathematical programming (or optimization, in modern lingo). Second, it has made Julia the right language in which to express many mathematical problems. The lightweight type system makes it easy to write code that is clearer than pseudocode. +This talk will present three case studies in optimization. We hope the audience will leave the talk with a new appreciation of Julia’s type system, as well as a new toolkit of packages to use for data fitting and optimization.
+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, and engineering system design. Her recent work on generalized low rank models (GLRMs) extends principal components analysis (PCA) to embed tabular data sets with heterogeneous (numerical, Boolean, categorical, and ordinal) types into a low dimensional space, providing a coherent framework for compressing, denoising, and imputing missing entries. She has developed of a number of open source libraries for modeling and solving optimization problems, including Convex.jl, one of the top ten tools in the new Julia language for technical computing, and is a member of the JuliaOpt organization, which curates high quality optimization software. +Madeleine completed her Ph.D. at Stanford University in Computational & Mathematical Engineering in 2015 under the supervision of Stephen Boyd, and a one year postdoctoral fellowship at Caltech in the Center for the Mathematics of Information hosted by Professor Joel Tropp. At Stanford, she was awarded a NSF Graduate Fellowship, a Gabilan Graduate Fellowship, and a Gerald J. Lieberman Fellowship, and was selected as the doctoral student member of Stanford’s School of Engineering Future Committee to develop a road-map for the future of engineering at Stanford over the next 10–20 years. She received a B.S. degree in Mathematics and Physics, summa cum laude, with honors in mathematics and in physics, from Yale University.
+ +Knet (pronounced “kay-net”) is the Koç University deep learning framework implemented in Julia by Deniz Yuret and collaborators. Knet uses dynamic computational graphs generated at runtime for automatic differentiation of (almost) any Julia code. This allows machine learning models to be implemented by only describing the forward calculation (i.e. the computation from parameters and data to loss) using the full power and expressivity of Julia. The implementation can use helper functions, loops, conditionals, recursion, closures, tuples and dictionaries, array indexing, concatenation and other high level language features, some of which are often missing in the restricted modeling languages of static computational graph systems like Theano, Torch, Caffe and Tensorflow. GPU operation is supported by simply using the KnetArray type instead of regular Array for parameters and data. High performance is achieved using custom memory management and efficient GPU kernels.
+ + +Deniz Yuret received his BS, MS, and Ph.D. at MIT working at the AI Lab on machine learning and natural language processing during 1988-1999. He co-founded Inquira, Inc., a startup commercializing question answering technology which was later acquired by Oracle. He is currently an associate professor of Computer Engineering at Koç University, Istanbul and founder of its Artificial Intelligence Laboratory. In his spare time he develops Knet.jl, a Julia deep learning framework that uses dynamic computational graphs generated at runtime for automatic differentiation of (almost) any Julia code.
+ +Our talk discusses the development and origin of LightGraphs, current features, and future developments. We introduce the package’s major design choices in a historical context as a compromise between the three core LightGraphs goals of simplicity, performance, and flexibility. We highlight several areas where specific features of Julia have led to flexible and efficient implementations of graph algorithms. +We will highlight our work in centrality measures, graph traversals, and spectral graph algorithms as examples of areas where Julia’s performance and design decisions have allowed LightGraphs to provide best-in-class implementations of graph algorithms. We also discuss integration with other organizations – JuliaOpt for matching and flow problems, and the Julia data visualization ecosystem – and highlight specifically LightGraphs’ potential to provide leadership on performant graph visualization. +Finally, we speculate on the influence of Julia’s focus on elegant parallel processing to future development of the package.
+ + +Dr. James Fairbanks is a Research Engineer at the Georgia Tech Research Institute where he studies problems in complex networks, data analysis, and high performance computing with applications to healthcare and social phenomena. +Seth Bromberger, a Research Scientist at Lawrence Livermore National Laboratory (https://people.llnl.gov/seth), is currently exploring the application of graph theory and machine learning to cybersecurity problems in critical infrastructure.
+ +Miletus is a financial software suite in Julia, with a financial contract specification language and extensive modelling features. In this talk, we’ll discuss the design principles involved in how to model a contract from primitive components, and how Julia’s language features lend themselves intuitively to this task. We’ll then talk about the various features of the software suite such as closed form models, binomial trees and computation of price sensitivities (aka “the Greeks”), providing several examples and code snippets, along with comparisons with other popular frameworks in this space.
+ + +Dr Simon Byrne is a quantitative software developer at Julia Computing, where he implements cutting edge numerical routines for statistical and financial models. Simon has a Ph.D. in statistics from the University of Cambridge, and has extensive experience in computational statistics and machine learning in both academia and industry. He has been contributing to the Julia project since 2012. Ranjan Anantharaman is a data scientist at Julia Computing where he works on numerical software in a variety of domains. His interests include scientific computing and machine learning. He has been contributing to the Julia project and ecosystem since 2015.
+ +Julia’s unique execution model, metaprogramming facilities, and type system make it an ideal candidate language for native automatic differentiation (AD). In this talk, we’ll discuss a variety of Julia-specific tricks employed by ForwardDiff and ReverseDiff to differentiate user-provided Julia functions. Topics covered include the implementation of a native Julia execution tracer via operator overloading, functor-based directives for specialized instruction taping, SIMD vectorization and instruction elision for inlined dual number operations, and vectorized differentiation of linear algebraic expressions. I’ll close the talk with a glimpse into the future of AD in Julia and JuMP, highlighting the effect new features may have on other downstream projects like Celeste, Optim and RigidBodyDynamics.
+ + +I like to make Julia code differentiate itself.
+ +By many measures, TensorFlow has grown over the last year to become the most popular library for training machine-learning models. TensorFlow.jl provides Julia with a simple yet feature-rich interface to TensorFlow that takes advantage of Julia’s multiple dispatch, just-in-time compilation, and metaprogramming capabilities to provide unique capabilities exceeding TensorFlow’s own native Python API. This talk will demonstrate TensorFlow.jl by guiding listeners through training a realistic model of image captioning , showing how to 1) construct the model with native Julia control flow and indexing, 2) visualize the model structure and parameters in a web browser during training, and 3) seamlessly save and share the trained model with Python. No prior experience with TensorFlow is assumed.
+ + +Ph.D. candidate at MIT studying artificial intelligence
+ +Modia is a Julia package to model and simulate physical systems (electrical, mechanical, thermo-dynamical, etc.) described by differential and algebraic equations. A user defines a model on a high level with model components (such as a mechanical body, an electrical resistance, or a pipe) that are physically connected together. A model component is constructed by “expression = expression” equations. The defined model is symbolically processed, JIT compiled and simulated with Sundials IDA solver with the KLU sparse matrix package. By this approach it’s possible and convenient to build models with hundred thousands of equations describing the dynamics of a car, an airplane, a power plant, etc. and simulate them. The authors used previous experience from the design of the modeling language Modelica (www.Modelica.org) to develop Modia. +In the presentation it is shown how a user can build models and simulate physical systems, including mechanical systems and electrical circuits. Furthermore, the design of Modia is sketched: The Modia language is a domain specific extension of Julia using macros. With graph theoretical algorithms, some of them recently developed by the authors, equations are pre-processed (including analytic differentiation if necessary) and transformed into a special form that can be simulated by IDA. Hereby the sparsity structure of the original (Modia) equations, as well as the nature of array equations are kept intact.
+ + +Hilding Elmqvist attained his Ph.D. at the Department of Automatic Control, Lund Institute of Technology in 1978. His Ph.D. thesis contains the design of a novel object-oriented model language called Dymola and algorithms for symbolic model manipulation. It introduced a new modeling methodology based on connecting submodels according to the corresponding physical connections instead of signal flows. Submodels were described declaratively by equations instead of assignment statements. Elmqvist spent one year in 1978-1979 at the Computer Science Department at Stanford University, California. +In 1992, Elmqvist founded Dynasim AB in Lund, Sweden. The primary product is Dymola for object-oriented modeling allowing graphical composition of models and 3D visualization of model dynamics. Elmqvist took the initiative in 1996 to organize an international effort to design the next generation object-oriented language for physical modeling: Modelica. In April 2006, Dynasim AB was acquired by Dassault Systemes. In January 2016, Elmqvist founded Mogram AB. Current activities include designing and implementing an experimental modeling language called Modia.
+ +By default, Julia comes with a powerful REPL that itself is completely written in Julia. It has, among other things, tab completion, customizable keybindings and different prompt modes to use the shell or access the help system. However, with regards to visual customization there are not that many options for a user to tweak. To that end, I created the package OhMyREPL.jl. Upon loading, it hooks into the REPL and adds features such as syntax highlighting, matching bracket highlighting, functionality to modify input and output prompts and a new way of printing stacktraces and error messages. It also contains some non-visual features, like allowing text that has been copied from a REPL session to be directly pasted back into a REPL and quickly opening the location of stack frames from a stacktrace in an editor. The talk will give an overview of the different features, discuss which features managed to get upstreamed to Julia v0.6 and, if time allows, outline the internals of the package.
+ + +Ph.D. student in computational mechanics at Chalmers University of Technology. Using Julia both for studies and as a hobby.
+ +This talk covers the design and implementation of Pkg3, the third (and hopefully final!) major iteration of Julia’s built-in package manager. We’ll begin with some history: what worked and didn’t work in the two previous iterations of the package manager. Pkg3 tries to marry the better parts of systems like Python’s virtualenv and Rust’s cargo, while supporting federated and layered package registries, and supporting interactive usage as well as reproducible environments and reliable deployment of code in production. We’ll nerd out a bit with some graph theory and how difficult it is to select compatible sets of package versions, and how much harder still it is to make version resolution understandable and predictable. But it won’t be all theory – we’ll also cover imminently practical subjects like “how do I install packages?”
+ + +co-creator of Julia, co-founder of Julia Computing
+ +GPUs have typically been programmed using low-level languages like CUDA and OpenCL, providing full control over the hardware at the expense of developer efficiency. CUDAnative.jl makes it possible to program GPUs directly from Julia, in the case you need the flexibility to write your own kernel functions, without having to fall back to CUDA C or binary libraries. In this talk, I will give an overview of CUDAnative.jl with its features and restrictions, explain the technology behind it, and sketch our future plans.
+ + +Ph.D. student at Ghent University
+ +The QML.jl (https://github.com/barche/QML.jl) package enables using the QML markup language from the Qt library to build graphical user interfaces for Julia programs. The package follows the recommended Qt practices and promotes separation between the GUI code and application logic. After a short introduction of these principles, the first topic of this talk will be the basic communication between QML and Julia, which happens through Julia functions and data (including composite types) stored in context properties. Using just a few basic building blocks, this makes all of the QML widgets available for interaction with Julia. The next part of the talk deals with Julia-specific extensions, such as the Julia ListModel, interfacing with the display system and GLVisualize and GR.jl support. These features will be illustrated using live demos, based on the examples in the QML.jl repository. Finally, some ideas for extending and improving the package will be listed, soliciting many contributions hopefully. +The target audience for this talk is anyone interested in developing GUIs for their Julia application with a consistent look on OS X, Linux and Windows. All user-facing code is pure Julia and QML, no C++ knowledge is required to use the package.
+ + +I am an associate professor at the mechanics department of the Royal Military Academy. For my Ph.D., I worked on Coolfluid, a C++ framework for computational fluid dynamics with a domain specific language. My interest in Julia is sparked by its powerful metaprogramming functionality coupled with C++-like performance, together with much better accessibility for students. To ease the transition to Julia, we are working on making some C++ libraries available in Julia. The QML.jl package is part of this effort. We also use Julia in our daily teaching activities, to provide students with interactive solutions to exercises.
+ +Query is a package for querying julia data sources. Its role is similar to LINQ in C# and dplyr in R. It can filter, project, join and group data from any iterable data source. It has enhanced support for querying arrays, DataFrames, DataTables, TypedTables, IndexedTables and any DataStream source (e.g. CSV, Feather, SQLite etc.). The package also defines an interface for tabular data that allows a) dispatch on any tabular data source and b) simple conversions of tabular data representations. The talk will first introduce Query from a user perspective and highlight different examples of queries that the package makes feasible. The second half of the talk will dive deep into the internals of the package and explain the various extension points that package provides.
+ + +David Anthoff is an environmental economist who studies climate change and environmental policy. He co-develops the integrated assessment model FUND that is used widely in academic research and in policy analysis. His research has appeared in Science, the Journal of Environmental Economics and Management, Environmental and Resource Economics, the Oxford Review of Economic Policy and other academic journals. He contributed a background research paper to the Stern Review and has advised numerous organizations (including US EPA and the Canadian National Round Table on the Environment and the Economy) on the economics of climate change. +He is an assistant professor in the Energy and Resources Group at the University of California, Berkeley. Previously he was an assistant professor in the School of Natural Resources and the Environment of the University of Michigan, a postdoc at the University of California, Berkeley and a postdoc at the Economic and Social Research Institute in Ireland. He also was a visiting research fellow at the Smith School of Enterprise and the Environment, University of Oxford. +He holds a Ph.D. (Dr. rer. pol.) in economics from the University of Hamburg (Germany) and the International Max Planck Research School on Earth System Modelling, a MSc in Environmental Change and Management from the University of Oxford (UK) and a M.Phil. in philosophy, logic and philosophy of science from Ludwig-Maximilians-Universität München (Munich, Germany).
+ +We will present 3 tools for decision making under uncertainty in the power systems area: SDDP, a tool for optimal hourly operation of complex power systems; OptGen, a computational tool for determining the least-cost expansion of a multi-regional hydrothermal system; OptFlow, a mathematical model to optimize operation of a generation/transmission system with AC electrical network constraints. +These models have been used by system operators, regulators and investors in more than seventy countries in the Americas, Asia-Pacific, Europe and Africa, including some of the largest hydro based systems in the world, such as the Nordic pool, Canada, the US Pacific Northwest and Brazil. SDDP is also the model used by the World Bank staff in their planning studies of countries in Asia, Africa and Latin America. OptGen had some interesting applications regional studies such as the interconnection of Central America, the Balkan regions, the interconnection of nine South American countries, Africa (Egypt-Sudan-Ethiopia and Morocco-Spain) and Central Asia. The original version of all 3 models was written in FORTRAN with the aid of some modelling tool or higher level API: AMPL for OptFlow, Mosel for OptGen and COIN-OR API for SDDP. Similar to any software, maintaining the code and adding new features became increasingly complex because they have to be built upon older data structures and program architectures. +These concerns motivated PSR to develop an updated version of these programs written entirely in julia (with JuMP and MathProgBase) for three basic reasons: (i) the code is concise and very readable; (ii) the availability of an advanced optimization “ecosystem”; and (iii) excellent resources for distributed processing (CPUs and GPUs). We retained the use of Xpress by developing the Xpress.jl library. We also use MPI.jl for distributed processing (including multiple servers in AWS). +The computational performance of the new code is matches the current ones’, which is very encouraging given that the current FORTRAN code has been optimized for several years based on thousands of studies. Also, the julia code incorporates several new modeling features that were easy to implement in all the 3 models: including SDP and SOCP relaxations for OPF and SDDiP method for stochastic integer optimization, confirming our expectation of faster model development. +The new models were incorporated to an integrated planning system for Peru being developed by PSR, which will be delivered in August 2017. They are also being internally tested as a “shadow” to the current version for studies in several countries and was delivered for beta testing for some PSR clients. The official release is scheduled for the end of 2017.
+ + +Camila graduated as an industrial engineer and has a MSc in Decision Analysis from PUC-Rio. Attended UC Berkeley for a semester during under graduation. Joined PSR in 2013, where, at present, works with the development of the models of optimization of hydrothermal dispatch under uncertainty with network constraints (SDDP model) and electric systems expansion planning (OPTGEN model).
+ +Joaquim has a BSc degree in electrical engineering and a BSc degree in mathematics, both from PUC -Rio and is currently working towards a PhD in electrical engineering with emphasis on decision support, also at PUC-Rio. During his undergraduate studies, he attended a year at UC Santa Barbara. He joined PSR in 2015 has been been working on the development of optimization models for hydro-thermal dispatch under uncertainty with transmission constraints reliability analysis, electrical systems expansion planning and nonlinear optimal power flow. Before PSR Joaquim worked with decision support at LAMPS (Laboratory of applied mathematical programming and statistics, at PUC-Rio) and with OTDR and Signal Processing at LabOpt (Optoelectronics laboratory, at PUC-Rio).
+ +from @jiahao: +We have really thought carefully about what the transpose of a vector should mean in a programming language. The pre-0.6 behavior that vector’vector yields a vector, vector’ yields a matrix, and vector’’ yields a matrix are all bad mathematics and produced no shortage of confusion by end users. +I present a summary of our research at the MIT Julia Labs into issue #4774, as a language design question that is informed by a comprehensive understanding of user expectations. Our main result is a short proof that it is impossible to avoid either new types, “ugly mathematics” (violation of Householder notation) or type instability. A single Array type is incompatible with Householder notation that produces the expected types from typical linear algebraic expressions. Furthermore, Householder notation intrinsically requires a conflation of 1x1 matrices and true scalars. +I also provide historical evidence the notion of “ugly mathematics” is neither static nor objective. In reality, linear algebra has changed greatly over the past centuries, demonstrating the impermanence of even elementary concepts of what matrices and vectors are and how they have been influenced by notation - a discussion forced into consciousness through the lens of programming language design, types, and formal program semantics. +I review the resolution of #19670 in the context of other designs in other programming languages, showing that all these designs turn out to locally optimal in conflating as much of Householder notation and array semantics as possible. +Joint work with Alan Edelman, Andy Ferris, and a few other people.
+ + +Data Scientist at Capital One, formerly Research Scientist at MIT
+ +In this talk we shall present TaylorIntegration.jl, an ODE integration package using Taylor’s method in Julia. The main idea of Taylor’s method is to approximate locally the solution by means by a high-order Taylor expansion, whose coefficients are computed recursively using automatic differentiation techniques. One of the principal advantages of Taylor’s method is that, whenever high accuracy is required, the order of the method can be increased, which is more efficient computationally than taking smaller time steps. The accuracy of Taylor’s method permits to have round-off errors per integration step. Traditionally, it has been difficult to make a generic Taylor integration package, but Julia permits this beautifully. We shall present some examples of the application of this method to ODE integration, including the whole computation of the Lyapunov spectrum, use of jet transport techniques, and parameter sensitivity. Open issues related to improving performance will be described.
+ + +Jorge Perez is a Physics Ph.D. student at UNAM, Mexico, under supervision of Luis Benet and David P. Sanders, authors of TaylorSeries.jl and ValidatedNumerics.jl. His Ph.D. research project is related to understanding the dynamics of minor Solar System objects: comets, asteroids, etc. He is coauthor of TaylorIntegration.jl and a contributor to TaylorSeries.jl. +Luis Benet is Associate Professor at the Instituto de Ciencias Físicas of the National University of Mexico (UNAM). He is mainly interested in classical and quantum chaos, including the dynamics of Solar System objects. He is coauthor of ValidatedNumerics.jl, TaylorSeries.jl and TaylorIntegration.jl, and has contributed to other Julia packages.
+ +We present a family of three Julia packages that together constitute a complete framework to describe and solve rational expectation models in economics. Dolang.jl is an equation parser and compiler that understands how to compile latex-like strings describing systems of equations into efficient Julia functions for evaluating the levels or derivatives of the equations. Dolo.jl leverages Dolang and implements a variety of frontier algorithms for solving a wide class of discrete time, continuous control rational expectations models. Finally, Dyno.jl builds upon Dolang to implement a Julia prototype of the Matlab-based dynare software library used extensively throughout academia and the public sector to approximate the solution to and estimate rational expectations models.
+ + +Economics Ph.D. student at NYU Stern. Active Julia member since 0.2
+ +We (Twan and Robin) are graduate students in the Robot Locomotion Group at MIT. Our research focuses on modeling and optimization for the simulation and control of walking (and sometimes flying) robots. We’ve been using Julia in our research over the past year, and we’re excited to share what we’ve learned, what we’ve built, and what we’re hoping to see in the future of Julia. +Specifically, we’d like to share some of our work on:
+We would also like to talk about how some of the best parts of the Julia ecosystem have made our work possible, like JuMP.jl, ForwardDiff.jl, and StaticArrays.jl. +And, finally, we plan to discuss what we hope to see in Julia’s future, including what the role of Julia can be inside a real-time robot controller.
+ + +We’re graduate students in the Robot Locomotion Group at MIT, where we work on simulation, planning, and control of walking and flying robots.
+ +Julia 0.6 includes a long-needed overhaul of the type system. While the effects of this change are not always visible, the new system eliminates classes of bugs and increases the expressiveness of types and method signatures. I plan to briefly explain how the new system works and what you can do with it. But more importantly, I want to ask: where do we go from here? Will we ever need another overhaul? I’ll present some possible future features and other related speculations. Topics may include record types, more powerful tuple types, protocols, ugly corner cases, and method specificity and ambiguity.
+ + +Jeff is one of the creators of Julia, co-founding the project at MIT in 2009 and eventually receiving a Ph.D. related to the language in 2015. He continues to work on the compiler and system internals, while also working to expand Julia’s commercial reach as a co-founder of Julia Computing, Inc.
+ +Turing is a new probabilistic programming language (PPL) based on Julia, a framework which allows users to define probabilistic models and perform inference automatically. Thanks to Julia’s meta-programming support, Turing has a very friendly front-end modelling interface. Meanwhile, coroutines are used in Turing’s inference engine development to achieve the state-of-the-art sampling performance. Also, we have recently introduced a new Gibbs interface, which allows user to compose different samplers and run them in the same time. In this talk, we will discuss our motivation of developing Turing in Julia, introduce the design and architecture of Turing, and present some practical examples of how probabilistic modelling is performed in Turing.
+ + +Developers of the Turing project form Cambridge Machine Learning Group
+ +This talk will give an overview of how researchers at the Federal Reserve Bank of New York have implemented economic forecasting and other post-estimation analyses of dynamic stochastic general equilibrium (DSGE) models using Julia’s parallel computing framework. This is part of the most recent release of our DSGE.jl package, following our ports of the DSGE model solution and estimation steps from MATLAB that were presented at JuliaCon in 2016. I will discuss the technical challenges and constraints we faced in our production environment and how we used Julia’s parallel computing tools to substantially reduce both the time and memory usage required to forecast our models. I will present our experiences with the different means of parallel computing offered in Julia - including an extended attempt at using DistributedArrays.jl - and discuss what we have learned about parallelization, both in Julia and in general. +In addition, I will provide some of our new perspectives on using Julia in a production setting at an academic and policy institution. DSGE models are sometimes called the workhorses of modern macroeconomics, applying insights from microeconomics to inform our understanding of the economy as a whole. They are used to forecast economic variables, investigate counterfactual scenarios, and understand the impact of monetary policy. The New York Fed’s DSGE model is a large-scale model of the U.S. economy, which incorporates the zero lower bound, price/wage stickiness, financial frictions, and other realistic features of the economy. Solving, estimating, and forecasting it presents a series of high-dimensional problems which are well suited for implementation in Julia.
+ +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.
+ + +I’m a Research Analyst at the New York Fed using Julia to estimate and forecast macroeconomic models. I’m interested in applying the frontier of scientific computing to economic research, so that we can solve more realistic and complex models.
+ +Convex optimization problems require rigorous mathematical understanding to solve them. Convex.jl allows users to solve complex optimization problems easily by providing a simple intuitive user interface to express the objective function and constraints. As it became popular, we saw increased demand to support optimization over complex numbers, from users working in diverse scientific fields including power grid optimization, quantum information theory, wireless communication, and signal processing. Previously, these users relied on various tools such as MATLAB’s cvx and open-source python package PICOS to tackle different problems depending upon their domain of work. Convex’s new support for complex numbers allows users to approach each of these problems in Julia. In this talk, I will show how to the new functionality in Convex.jl provides a single integrated solution for many types of Disciplined Convex Programming Problems and show how to solve complex problems using Convex.jl in very few lines of code, taking examples from scientific domains mentioned above. I will also present benchmarks comparing Convex.jl with competing open-source tools.
+ + +Ayush Pandey is a final year graduate student at IIT Kharagpur studying Mathematics & Computing Sciences with micro-specialization in Optimization Theory and Applications. He is also a Google Summer of Code, 2016 fellow under the Julia Language.
+ +The use of multiple dispatch in Julia’s standard library and user-written functions presents a challenge for automated techniques of generating test data. In order to exercise all the methods that implement a function, the generation technique must generate test data with diverse data types, but traditional techniques typically focus solely on diverse data values and implicitly assume a constant data type. In this talk, I will demonstrate our solution to this challenge which automatically learns an effective probability distribution over types and methods that create instances of these types. I will explain how we used this approach to fuzz-test some common arithmetic and string functions in the Julia standard library, in the process identifying three faults.
+ + +I am an assistant professor in software engineering. The primary objective of my research is to improve the cost-effectiveness of software testing through the application of machine learning and statistical methods. I have been a user of Julia for three years, and am co-developer of the DataGenerators package which facilitates the generation of complex test data.
+ +Complex systems in biology are often difficult to treat analytically using mathematics and expensive to investigate with empirical methods. Moreover, deterministic approaches are misleading in systems that exhibit noise (e.g. rare events akin to mutation and extinction). Stochastic simulation provides investigators with the ability to simulate complex systems by integrating mathematical rigor and biological insight. However, simulations are slow, computationally expensive, and difficult to implement in software. My goal in developing BioSimulator.jl is to provide investigators with a tool that enables (1) quick and intuitive model prototyping, (2) efficient simulation, (3) visualization of simulation output, and (4) implementing new stochastic simulation algorithms. Using the Julia language allowed us to meet all four criteria with relative ease and extend to parallelized simulations. My talk will describe the theory underlying BioSimulator.jl, highlight aspects of our implementation, and present a few numerical examples.
+ + +I am a first-year student in biomathematics. My studies are focused on stochastic processes, scientific computing, and optimization.
+ +Circuitscape is one of the most popular tools to measure landscape connectivity, using concepts from electrical circuit theory. Ecologists can model landscapes as large resistance maps and then compute current maps and voltage potentials at various parts on the landscape. Computationally, this involves constructing a large graph and using a sparse solver. This tool has originally been written in Python, and this talk will be about porting it to Julia as well as improving the solver in the package. This talk will also focus on performance comparisons between the Julia and Python versions.
+ + +Ranjan Anantharaman is a data scientist at Julia Computing. His interests span applied mathematics and numerical computing, and he enjoys working with computation across a variety of fields and domains.
+ +Neurons throughout the brain, and particularly in the cerebral cortex, represent many quantities of interest using population codes. Latent variable models of neural population activity may be seen as attempting to identify the value, time-evolution and encoding of such internal variables from neural data alone. They do so by seeking a small set of underlying processes that can account for the coordinated activity of the population. +We introduce a novel estimation method [1] for latent factor models for point processes that operates on continuous spike times. Our method is based on score matching for point process regressions [2] adapted to population recordings with latent processes formed by mixing basis functions. +The basis functions are represented as either Fourier modes, or functions living in a Reproducing Kernel Hilbert Space, parametrised using MLKernels. The method requires the kernel matrix as well as the first and second derivatives thereof, which we can compute efficiently via the Calculus package, making use of anonymous functions. Parameter estimation is then closed form and thus lightning fast up to normalisation, but afterwards we need to estimate the total intensity in the observation period. The approximation of the time integral relies on Cubature.jl. +Due to its speed, this method enables neuroscientists to visualise latent processes in real time during experimental recordings and immediate compare them to their expectations, thus quickening the Planning-Design-Analysis loop by a large margin.
+Gergo focused on math and physics in high school, but completed an engineering degree in Molecular Bionics as an undergrad in his home city, Budapest. After being the image processing guy in a cancer research lab in London as well as learning about AI in Leuven, Belgium, Gergo settled as a Ph.D. student in the Gatbsy Computational Neuroscience Unit, working on developing machine learning algorithms to process and understand various types of neural data.
+ +Stochastic Dual Dynamic Programming (SDDP) is an optimization algorithm for solving large, multi-stage stochastic programming problems. It is well known in the electricity community, but has received little attention in other application areas. The algorithm is computationally demanding as it typically involves iteratively solving hundreds of thousands of linear programs. In the past, implementations have been coded in slow, but expressive mathematical optimization languages such as AMPL, or in fast, but low level languages such as C++. In this talk, we detail a JuMP extension we have developed to solve problems using SDDP. We also present benchmarks showing that our Julia implementation has similar run-times to a previous version developed in C++, while being more flexible and expressive. This speed and flexibility has allowed us to revisit assumptions made in previous work, as well as apply the SDDP algorithm to problems as diverse as agriculture, energy, and finance.
+ + +Oscar Dowson (@odow) is a P.h.D. Candidate in Engineering Science at the University of Auckland. He works on applying stochastic optimization to the New Zealand dairy industry.
+ +The DataStreams package defines a powerful and performant interface for getting data in and out of Julia. Come learn about exciting advances in features and performance as we approach Julia 1.0.
+ + +Attended Carnegie Mellon for a master’s degree in data science and active Julia contributor for 4 years now.
+ +This talk will address efforts to promote diversity and inclusion at JuliaCon this year, with the goals of a) increasing awareness of JuliaCon’s initiatives among conference participants and the Julia community at large and b) starting a public conversation about diversity and inclusion with other open-source conferences. It will place JuliaCon’s initiatives in the context of the broader scientific computing community.
+ + +Erica is a research analyst in the Macroeconomics function at the Federal Reserve Bank of New York and the Diversity Chair for JuliaCon 2017. She is a 2015 graduate of Williams College and plans to begin her Ph.D. in Economics in the fall.
+ +Many species of bacteria are able to collectively sense and respond to their environment. This communication form known as quorum-sensing (QS) can be achieved through the production of small molecules that are able to freely diffuse across cell membranes. These molecules (autoinducers) can subsequently be detected by other individuals in the population and once a threshold limit is reached, then this may cause a change in gene expression which allows bacteria to coordinate their activities such as biofilm formation, virulence and antibiotic resistance. Despite the widespread interest in QS from molecular mechanisms to social evolution and pathogen control, there is still controversy over the basic evolutionary function of QS. Using Julia as the agent-based modeling platform, we have been able to investigate the rewards and risks of coordination and cooperation in QS. In this talk, I will briefly introduce the research background and share some of our results obtained from in silico evolution using Julia. This work is important as it sheds light on how simple signal-mediated behavioral rules can shape complex collective behaviors in bacteria. Julia greatly helped simplify the modeling precess and speed up simulations.
+ + +Yifei Wang is currently a postdoctoral research fellow with the School of Biological Sciences at Georgia Institute of Technology. His research focuses on collective intelligence, evolutionary dynamics and high-performance computing. Dr. Wang received a degree of B.Eng. in computer science & technology in 2009, a degree of M.Eng. in astronautics engineering in 2012, and a degree of Ph.D. in computing in 2016. He was an awardee of Richard E. Merwin Student Scholarship from the IEEE Computer Society in 2011, and received a three-year Overseas University Research Studentship from the University of Bath (UK) in 2012. Dr. Wang was the Student Activities Chair of IEEE UK & Ireland Section from 2013 to 2015. He along with his team successfully organized the 3rd IEEE UK & Ireland Student Branch Congress in 2013.
+ +GR is a plotting package for the creation of two- and three-dimensional graphics in Julia, offering basic MATLAB-like plotting functions to visualize static or dynamic data with minimal overhead. In addition, GR can be used as a backend for Plots, a popular visualization interface and toolset for Julia. Using quick practical examples, this talk is going to present the special features and capabilities provided by the GR framework for high-performance graphics, in particular when being used in interactive notebooks (Jupyter), development environments (Atom), desktop applications (nteract) or terminal programs (iTerm2). The presentation also introduces how to embed GR in interactive GUI applications based on QML.jl, a new plotting interface to Qt5 QML. Moreover, some experimental features and elements will be introduced, i.a. a meta layer providing an interactive interface to new backends based on Qt5 or JavaScript.
+ + +Josef Heinen is the head of the group “Scientific IT–Systems” at the Peter Grünberg Institute / Jülich Centre for Neutron Science, both institutes at Forschungszentrum Jülich, a leading research centre in Germany. The design and development of visualization systems have been an essential part of his activities over the last twenty years. Most recently his team is engaged with the further development of a universal framework for cross-platform visualization applications (GR Framework).
+ +The pricing of bonds or a Credit Portfolio usually has simple mathematics. However, when faced with a big portfolio, careful design is crucial for a fast execution time. I’ll show how I designed a solution to price a database of about 2.4 million contracts with 78 million cashflows in up to 3.5 minutes using a 8 core machine. The solution uses plain simple Julia code, some parallel computation and buffering strategies, Julia’s native serialization for fast-loading data from the disk, and a handful of packages. BusinessDays.jl and InterestRates.jl packages will be featured.
+ + +Bachelor in Computer Engineering, M. Sc. in Economics, Market Risk Manager at BNDES (Brazilian Development Bank).
+ +In the multi-disciplinary field of systems biology, we welcome the opportunity that Julia brings for writing fast software with simple syntax. Speed is important in an age when biological datasets are increasing in size and analyses are becoming computationally more expensive. One example is the problem of determining how genes within a cell interact with one another. In the inference of gene regulatory networks (GRN) we seek to detect relationships between genes through statistical dependencies in biological data, and as datasets grow, so does computation time. Some algorithms use measures from information theory, which are suitable for detecting nonlinear biological relationships, but incur a high computational cost. We developed InformationMeasures.jl, a package for calculating information theoretic measures. The improvement in performance of our Julia package compared to widely-used packages in other languages enables us to develop new algorithms with higher complexity, examining triples, rather than pairs, of genes. These we can show are more successful than pairwise methods (in simulated data where the underlying GRNs are known), and scale well to the size of the largest currently-available biological datasets.
+ + +Thalia is a Ph.D. student in theoretical systems biology at Imperial College, London. Her research focuses on algorithm development for biological network inference, in particular using information theory. Outside of her studies she contributes to various open source software projects.
+ +LLVM.jl provides a high-level Julia interface to the LLVM compiler framework. In this talk, I’ll explain how to use LLVM.jl for basic code generation and execution, as well as how to integrate it with the rest of the Julia compiler.
+ + +Ph.D. student at Ghent University
+ +At present, two options exist for saving Julia data structures to disk: Julia’s built-in serializer and the JLD (Julia data) package. The built-in serializer achieves reasonable performance, but uses a non-standardized format that differs by Julia version and processor architecture. JLD saves data structures in a standardized format (HDF5), but has substantial overhead when saving large numbers of mutable objects. In this talk, I describe the design of JLD2, a re-implementation of JLD. By replacing JLD’s dependency on the HDF5 library with a pure Julia implementation of a subset of HDF5, JLD2 achieves performance comparable to Julia’s built-in serializer, while writing files readable by standard HDF5 implementations. Additionally, JLD2 resolves numerous issues with the previous JLD format and implementation.
+ + +I am currently a Ph.D. student in neuroscience at MIT, but my affiliation will probably change before JuliaCon.
+ +Whole-genome sequencing (WGS) data is being generated at an unprecedented rate. Analysis of WGS data requires a flexible data format to store the different types of DNA variation. A new WGS variant data format “SeqArray” was proposed recently (Zheng X, etc, 2017 Bioinformatics), which outperforms text-based variant call format (VCF) in terms of access efficiency and file size. +Here I introduce a new Julia package “JSeqArray” for data manipulation of genotypes and annotations in an array-oriented manner (https://github.com/CoreArray/JSeqArray). It enables users to write portable and immediately usable code in the wider scientific ecosystem. When used in conjunction with the in-built multiprocessing and job-oriented functions for parallel execution, the JSeqArray package provides users a flexible and high-performance programming environment for analysis of WGS variant data. In the presentation, the examples of calculating allele frequencies, principal component analysis and association tests of linear regression will be given.
+ + +Ph.D, Biostatistics, (6/13) Dept. of Biostatistics, UW, Seattle, WA Postdoctoral Fellow, (7/13 – 8/15) Dept. of Biostatistics, University of Washington (UW), Seattle, WA Senior Fellow, (9/15 – present) Dept. of Biostatistics, University of Washington (UW), Seattle, WA Develop and apply statistical and computational methods for the interpretation of large-scale genetic data
+ +TBD
+ + +co-creator of Julia, co-founder of Julia Computing
+ +Seismic.jl is a Julia package that provides a framework for seismic wave modeling, data processing and imaging. The current version includes support to read/write seismic data, reconstruction and denoising of multi-dimensional (5D) seismic data via parallel and distributed tensor completion, GPU-accelerated finite-difference solvers for seismic wave simulations, and seismic imaging including passive-seismic source location. In this lightning talk, I will briefly describe our area of research and immediately, show how Seismic.jl has been used as main framework for our research in applied seismology.
+ + +Wenlei Gao received his B.Sc in 2010 and M.Sc in 2013 in Geophysics from China University of Petroleum, Beijing, China. From 2013 to 2014 he worked for the Research Institute of China National Offshore Oil Company. He is currently enrolled in the Ph.D. program in Geophysics in the University of Alberta. His research is mainly focused on multicomponent seismic data registration and joint deconvolution.
+ +A quick update on the state of Julia on the Raspberry Pi. We will see how get Julia and GPIO related packages working on the Pi, and explore some working examples of applications running on the Pi and utilising its power to interact with the physical world.
+ + +Avik is the author of Julia’s integration with Java and various other packages. One of his hobbies is to make Julia a first class language on the Raspberry Pi.
+ +Julia has the potential to become a major programming language in economics. In this presentation I will suggest a new way to calibrate models of economic growth. For that purpose I use a Markov-Chain Monte-Carlo algorithm (the Klara package) and I repeatedly solve for the roots of a big system of nonlinear equations using the JuMP and Ipopt packages. With this approach I am able to estimate the distributions of parameter values which drive long-run economic growth and project confidence intervals of macroeconomic variables into the future. For this purpose Julia is the best programming language that I know of, because it combines a great range of functionalities and at the same time it is very fast. To conclude, I will reflect on some challenges that came up during the project.
+ + +I am a Ph.D. student in the economics department at the Ludwig-Maximilians University in Munich (Germany).
+ +A quick presentation on our experience of running JuliaBox on various cloud platforms viz. Amazon AWS, Google Cloud Platform and Microsoft Azure. Also we present the current development plans to make JuliaBox faster and support a host of new features.
+ + +Software Engineer at Julia Computing Inc.
+ +JuliaDB.jl is an end-to-end all-Julia data analysis platform incorporating storage, parallelism and compute into a single model. One can load a pile of CSV files into JuliaDB as a distributed table. JuliaDB will index the files and save the index for efficient lookup of subsets of the data later. You can also convert the data from the CSV files into an efficient memory mappable binary format (“ingest”). +This talk will be a brief introduction to the basic primitives of JuliaDB and how to use them.”
+ + +Jeff is one of the creators of Julia, co-founding the project at MIT in 2009 and eventually receiving a Ph.D. related to the language in 2015. He continues to work on the compiler and system internals, while also working to expand Julia’s commercial reach as a co-founder of Julia Computing, Inc.
+ +JuliaRun is a product of Julia Computing under development and a few early users. It is adaptable to a variety of private and public clouds and makes it easy to deploy Julia applications both batch and online. We will present a brief of the architecture and how it can help deploy scalable end to end applications.
+ + +Tanmay and Pradeep have contributed to Julia packages in JuliaWeb and JuliaCloud.
+ +I will present Junet — a new package for network analysis that seeks to be a fast and hackable alternative to mainstream network analysis libraries like NetworkX, igraph, and graph-tool. Unlike other Julia packages, it allows to quickly traverse and modify the graphs as well as to associate the attributes with their nodes and edges. I will discuss the data structures implemented in Junet and showcase how specific Julia’s features allow to make them efficient. For example, thanks to parametric types it is possible to shrink the memory consumed by Junet to a fraction of what other libraries require. And conjunction of multiple dispatch with just-in-time compilation allows to optimize some methods based on the specific types they operate on, sometimes eliminating the computation altogether. The talk will also overview things that are experimental and don’t work so well like creating zero-cost iterators and parallelizing loops. Finally, I will present the benchmarks comparing Junet with state-of-the-art libraries for network analysis.
+ + +Graduate student
+ +Analysis of high-throughput data can be improved by taking advantage of known relationships between observations. Matrix linear models provide a simple framework for encoding such relationships to enhance detection of associations. Estimation of these models is challenging when the datasets are large and when penalized regression is used. This talk will discuss implementing fast estimation algorithms for L1-penalized matrix linear models as a first-time Julia user and fluent R user. We will share our experiences using Julia as our platform for prototyping, numerical linear algebra, parallel computing, and sharing our method.
+ + +Jane Liang recently obtained a bachelor’s degree in statistics from UC Berkeley and plans to enter a doctoral program later this year. Currently, she is a scientific programmer working with Dr. Saunak Sen at the University of Tennessee Health Science Center, Department of Preventive Medicine, Division of Biostatistics.
+ +The parallel application of multiple statistical hypothesis tests is one of the fundamental patterns of exploratory data analysis for big datasets. This becomes essential in various fields of scientific research, such as in high-throughput biology, medicine and imaging where one is routinely faced with millions of tests. The goal is to protect against spurious discoveries with rigorous statistical error control guarantees, while simultaneously providing enough power to detect needles in a haystack. Here, we present MultipleTesting.jl, a package that provides a unified interface for classical and modern multiple testing methods. We give a quick introduction to the underlying statistical concepts and show how Julia is ideally suited for such an endeavour: First, most multiple testing procedures consist of a standard set of primitives, such as p-values, adjusted p-values and hypothesis weights. Second, elaborate (multiple testing) algorithms often consist of simpler components in a plug-and-play fashion; these include estimators of the proportion of true null hypotheses, parametric as well as non-parametric distribution estimators, and statistical machine learning techniques. All of these ideas can be abstracted away by Julia’s type system and multiple dispatch. Third, Julia provides the computational performance which is necessary when analyzing millions of hypotheses. We believe MultipleTesting.jl complements the growing number of high quality statistics packages in Julia’s ecosystem.
+ + +Nikos Ignatiadis is a first year Ph.D. student at Stanford’s Statistics department. He is interested in the development of interpretable methods for multiple testing and high dimensional inference.
+ +Nullability is a complex issue for any programming language or domain; Nulls.jl puts forth the data-friendly approach Julia has wanted and deserves with core language support.
+ + +Attended Carnegie Mellon for a master’s degree in data science and active Julia contributor for 4 years now.
+ +Geophysical inversion is the mathematical and computational process of estimating the spatial distribution of physical properties of the earth’s subsurface from remote measurements. It’s a key tool in applied geophysics, which is generally concerned with determining the structure and composition of the earth’s interior without direct sampling. At JuliaCon 2017 I would like to discuss our group’s efforts to develop a modular, scalable, and extensible framework for solving geophysical inverse problems and other partial differential equation (PDE) constrained parameter estimation problems in Julia. +To solve PDE constrained parameter estimation problems we need advanced algorithms for optimization, for the solution of PDEs, and the ability to efficiently share information between these domains. Our framework, called jInv—short for JuliaInversion—provides modular building block routines for these tasks that allow users to easily write their own software to solve new problems. The framework heavily uses Julia’s multiple dispatch to allow for extensibility and generic programming. +It is also critical that software implementations of these algorithms can scale to large distributed computing systems. jInv allows users to exploit the parallelism in geophysical inverse problems without detailed knowledge of Julia’s parallel computing constructs. +The first main goal of my talk is to discuss our approach to exploiting parallelism in geophysical inverse problems and how it has been implemented in jInv. The second goal is to illustrate, through examples of developing jInv modules for new geophysical problems, how we’ve moved jInv from a research project for the benefit of our own group to a tool that can be of use to the wider community.
+ + +Hi! I’m a Ph.D. student in the department of Earth, Ocean and Atmospheric Sciences at the University of British Columbia in Vancouver Canada. Academically I’m interested in developing new computational methods for solving geophysical imaging problems. Since coming to UBC Julia has become my language of choice and I now consider myself a reformed Fortran programmer.
+ +SparseRegression implements a variety of offline and online algorithms for statistical models that are linear in the parameters (generalized linear models, quantile regression, SVMs, etc.). This talk will discuss my experience using primitives defined in the JuliaML ecosystem (LossFunctions and PenaltyFunctions) to implement a fast and flexible SparseReg type for fitting a wide variety of models.
+ + +Josh is a statistics Ph.D. student at NC State University, where he researches on-line optimization algorithms for performing statistical analysis on big and streaming data.
+ +I will describe my experience working with and developing highly efficient data structures in Julia which leverage statically known information - such as the type(s) contained in a collection, or the predetermined size of an array. Julia’s combination of efficient code generation and metaprogramming capability make it an ideal language to implement data structures which are both convenient to program with and lightning fast in execution. +I plan to describe the various metaprogramming approaches which are useful for implementing containers of known size or having inhomogeneous elements - by using traits, pure functions, generated functions, macros and recursion. I will touch upon the successes and failures of packages like StaticArrays.jl, Switches.jl and TypedTables.jl, and hope to preview work on a more flexible yet strongly-typed tabular data structure than currently provided by TypedTables.
+ + +I currently work at Fugro Roames on the intersection of machine learning, geodesy and big data. Beginning with detailed, large-scale scans of the physical world, we deduce intelligence for our clients that would be expensive to acquire directly. Previously, I worked in academia as a numerical quantum physicist, where I was attracted to Julia for its unique combination of user productivity and speed.
+ +The recent advances in machine learning and artificial intelligence are amazing, and Julia seems poised to play a significant role in these fields. Yet, in order to have real value within a company, data scientists must be able to get their models off of their laptops and deployed within a company’s distributed data pipelines and production infrastructure. In this talk, we will implement an ML model locally and talk about the trouble we can get into taking this to production. Then, against all odds, we will actually deploy the model in a scalable manner to a production cluster. Now that’s a pretty good 10 minutes!
+ + +Daniel (@dwhitena) is a Ph.D. trained data scientist working with Pachyderm (@pachydermIO). Daniel develops innovative, distributed data pipelines which include predictive models, data visualizations, statistical analyses, and more. He has spoken at conferences around the world (Datapalooza, DevFest Siberia, GopherCon, and more), teaches data science/engineering with Ardan Labs (@ardanlabs), maintains the Go kernel for Jupyter, and is actively helping to organize contributions to various open source data science projects.
+ +Standards already exist to improve software readability, but code understandable by a colleague differs from the best code to present to a student. As a scientist, I have often had to jump from mathematics or pseudo-code to a fully fledged implementation, with no chance to gain purchase in an intermediate middle ground. In the last year, I have worked on a Julia blog in computational physics and numerics and have striven to write code comprehensible to someone unfamiliar with the fundamental principles of the algorithm. In this talk, I will display both good and bad examples of documentation and tutorials, as well as guidelines for improvement.
+ + +Theoretical Physics Graduate Student
+ +This talk will give an overview of the Julia extension for VS Code. The extension currently provides syntax highlighting, an integrated REPL, code completion, hover help, an integrated linter, code navigation, integration with the Julia testing infrastructure and integrated support for Weave documents (Julia’s knitr equivalent). +A 30-minute version of this talk would talk about the internals of the extension. We would describe the Julia language server (our implementation of the Microsoft Language Server Protocol) that provides the integration with the VS Code UI. Other topics we would cover are our approach to build a robust and reliable software delivery mechanism that does not depend on the shared Julia package directory, our custom parser that is used in the language server and the developments currently being made to provide actionable parse-time formatting and linting hints, as well as any other features we might add between now and JuliaCon. +Links: +https://github.com/JuliaEditorSupport/LanguageServer.jl https://github.com/JuliaEditorSupport/julia-vscode https://github.com/ZacLN/Parser.jl
+ + +London based Economist
+ +TheoSea (for THEOry SEArch) is a Julia meta-program that discovers compact theories from data if they exist. It writes candidate theories in Julia and then validates: tossing the bad theories and keeping the good theories. Compactness is measured by a metric, such as the number of space-time derivatives. A theory can consist of more than one well-formed formula over a mathematical language. The underlying algorithm is optimal in terms of compactness, although it may be combinatorially explosive for non-compact theories. TheoSea is now working on re-discovering the source-free Maxwell equations and the wave equation of light. There are many applications.
+ + +https://www.linkedin.com/in/mark-stalzer-97254a/
+ +Qb@ll is an open source density functional theory package being developed at Lawrence Livermore National Lab. Present work focuses on efficient time integration methods, with the aim of substantially increasing the timescales accessible in simulations of electron dynamics. Qb@ll is several hundred thousand lines of C++, Fortran, and Perl. Exploring new methods directly in the code base is extremely developer-time inefficient. Simultaneously, rigorous exploration of relevant methods is highly computationally intensive, precluding the use of traditional high-productivity languages. Screening new methods in Julia has proven highly effective, even accounting for the time to learn the language and implement a small code to explore electron wave function integration.
+ + +Jane is a graduate student in computational materials physics enrolled at Caltech. She is interning at Lawrence Livermore National Lab, where she is working with Xavier Andrade on methods for and applications of density functional theory.
+ +Function return type annotations were added over a year ago and have seen some usage in Base but little in user-land. This talk will describe how they are implemented and discuss how ResultTypes.jl uses them to great effect.
+ + +Eric is co-leading Invenia’s transition to Julia and designing the building blocks for Invenia’s Energy Intelligence System.
+ +A large part of data science is in the gathering of data, and in solving the 2 language problem, it should be no surprise that Julia is great for that part of the workflow. In this talk, we will discuss how to combine a set of packages (HTTP.jl, Gumbo.jl, Cascadia.jl) to easily develop and deploy a web scraping strategy. We will see how Julia’s high level language features make it easy to interactively develop such projects, and at the same allow deployment into a distributed cluster for scraping at scale.
+ + +Avik is the author of Julia’s integration with Java and various other packages. One of his hobbies is to make Julia a first class language on the Raspberry Pi.
+ +WebIO acts as a small Julian bridge between browser-based UIs to Julia such as IJulia, Atom, Blink and Mux, and packages that wish to output rich, interactive widgets. This means graphics packages don’t have to depend on IJulia or Atom or Blink etc to create widgets. Instead they only depend on WebIO and use its abstractions. Widgets written with WebIO once will work on all the above interfaces. Some features are:
+I work on various Julia projects. My interests are mainly in interactive UIs.
+ +© 2014-2020 JuliaCon.org All rights reserved. + Fork this site on Github or + open a bug report.
+ +This is an introductory tutorial on Julia as it is today, aimed at people with experience in another language, and who want to get up to speed quickly as Julia heads towards its first stable version.
+ + +David P. Sanders is associate professor of computational physics in the Department of Physics of the Faculty of Sciences at the National University of Mexico in Mexico City.
+His previous Julia tutorials on YouTube have over 75,000 views. He is a principal author of the ValidatedNumerics.jl package for interval arithmetic, and IntervalConstraintProgramming.jl for constraint propagation.
Over the last few years we have seen Deep Learning rise to prominence not just in academia with state-of-the-art results for well-established tasks, but also in industry to leverage an ever-increasing amount of data becoming available. Due to the computationally heavy nature of Deep Learning approaches, Julia is in a unique position to serve as the language of choice for developing and deploying deep machine learning models. +In this workshop we will introduce Deep Learning for a general audience – assuming only high school-level mathematics to gain a practical understanding of the topics covered. We will first introduce the history and theoretical underpinnings of Deep Learning. After this we will proceed to introduce the lay of the land in terms of libraries and frameworks in Julia – demonstrating to the audience how one can implement state-of-the-art Deep Learning models for various forms of data. After attending the workshop the audience will have an understanding of how they can use Julia for Deep Learning and adapt these approaches to their own data. +The organisers of the workshop have between them many years of experience of teaching, research, and working with and implementing Deep Learning frameworks in Julia and other programming languages.
+ + +Mike Innes is a software engineer at Julia Computing, where he works on the Juno IDE and the machine learning ecosystem. +Jon Malmaud is a PhD candidate at MIT’s Brain and Cognitive Science Department, where he works on AI and Deep Learning. He’s also a core contributor to the Julia language, and created Julia’s TensorFlow bindings. +Pontus Stenetorp is a research associate at University College London, that spends most of his research time on Natural Language Processing and Machine Learning – with a particular focus on Deep Learning. He has been using Julia since 2014 due to a need for rapid prototyping and computational performance. When it comes to Julia contributions, he tends to contribute small occasional patches to the standard library.
+ +Start using Julia to do simulations of quantum systems with many interacting particles! We will write a single-core exact diagonalization code which can handle a variety of models from quantum physics, using Julia to make it readable and performant. We’ll tour the Julia package ecosystem for useful packages that will help us store our results to share with others and get to the interesting physics. Then, we’ll use some of Julia’s parallel features to scale up our code to do many-body simulation on many-core and many-node systems in a convenient, reproducible, and fast way. You need not ever have written any Julia before. We’ll use physics examples as natural motivation to explore Julia’s capabilities, but no background in quantum mechanics is required. We will introduce the models as we go.
+ + +5th year physics graduate student, sometimes Julia contributor
+ +This interactive workshop will introduce a couple of tools and packages for GPU programming in Julia: how to set-up a working environment, basic usage, and optimization. Participants will be able to follow along using their own system, or on a cloud-based JuliaBox instance.
+Contributors to the JuliaGPU ecosystem
+ +After attending this workshop, you will have the skills needed to integrate Julia in real-world environments. Not only that, you will understand at least one strategy for distributing Julia data analysis at production scale on large data sets and streaming data. +The Roadmap of the workshop will include:
+Daniel (@dwhitena) is a Ph.D. trained data scientist working with Pachyderm (@pachydermIO). Daniel develops innovative, distributed data pipelines which include predictive models, data visualizations, statistical analyses, and more. He has spoken at conferences around the world (Datapalooza, DevFest Siberia, GopherCon, and more), teaches data science/engineering with Ardan Labs (@ardanlabs), maintains the Go kernel for Jupyter, and is actively helping to organize contributions to various open source data science projects.
+ +I am the developer of NLOptControl.jl, a JuliaOpt tool that is an extension for JuMP.jl. NloptControl.jl is used for formulating and solving nonlinear optimal control problems. A current limitation of optimization modeling software, such as JuMP is that it does not allow for ease of adding integral constraint equations. +NLOptControl.jl also provides an implementation of the pseudo-spectral method written in written in julia which is extremely fast. While I have not yet benchmarked it against GPOPSii (a commercial software that also uses this method to solve optimal control problems), I hope to have made some comparisons to help motivate my users during juliaCon2017. NLOptControl.jl is an extension of JuMP.jl, and with that comes the a tremendous amount of power. For instance, have you ever struggled calculating Hessians and Jacobians? Well those days are over because NLOptControl.jl takes care of that for you by simply utilizing JuMP and the automatic differentiation capabilities of ReverseDiffSparse.jl. +Workshop Details The workshop will give people interested in nonlinear optimal control guidance and hands-on experience using a very high level tool that is fast, concise, and powerful. The workshop will be organize into two parts; background information and hands-on experience. The background information section will explain the basics of nonlinear optimal control problems, why I got started with julia, and then show some examples including the Autonomous Vehicle Control problems that I am solving. Then during the hands-on part, users will solve optimal control problems from start to finish and the results will be automatically plotted.
+Mechanical Engineering Ph.D. 4th year student
+ +In this workshop we will introduce the two main packages organized under the JuliaNLSolvers umbrella: Optim.jl for optimization and NLsolve.jl for solving systems of equations. We will look at the types of problems the packages solve, what the interfaces are like, and work on practical examples. A strong mathematical background is not needed, but some understanding of calculus is required to follow the discussion of the different methods.
+ + +Ph.D. student in economics, JuliaNLSolvers owner and developer, Julia nerd.
+ +DifferentialEquations.jl is a highly extendable high-performance library for solving a vast array of differential equations in Julia. The purpose of this workshop is to introduce the participants to DifferentialEquations.jl, focusing on the new types of problems that are able to be explored through this software and how Julia has made this possible. We will start with a tutorial of the ordinary differential equation solvers. Users will be shown how to use the common solver interface to solve and analyze equations using the solvers from OrdinaryDiffEq.jl, Sundials.jl, ODE.jl, LSODA.jl, and ODEInterface.jl. Next, the capabilities will be explored in further depth, and users will walk through solving hybrid differential equations continuous + discrete components), using arbitrary precision and unitful arithmetic, and solving equations with discontinuous events. After that, the tutorial will show users how to branch out to other forms of differential equations, showing how the same interface allows them to use the unique high-order adaptive Runge-Kutta methods for stochastic differential equations and the fast high-order methods for delay differential equations. Lastly, participants will be walked through the analysis add-on tools, using Optim.jl to perform parameter estimation of ordinary differential equation models, identify sensitive parameters, and quantify numerical uncertainties of solutions. Users will leave the workshop with an expanded view of what kinds of problems can be solved with DifferentialEquations.jl and with the knowledge of how to solve them.
+ + +Chris Rackauckas is a 4th year Ph.D. student in Mathematics at the University of California, Irvine. He is the principal author of many Julia packages, including the JuliaDiffEq packages (DifferentialEquations.jl) and ParallelDataTransfer.jl, and has contributed to numerous other packages related to scientific computing. Chris is also actively engaged in the Julia community as the author of the StochasticLifestyle blog and the tutorial “A Deep Introduction to Julia for Data Science and Scientific Computing”.
+ +Julia uses a unique mix of techniques adopted from conventional static and dynamic to provide a special blend of high-performance and flexible compute kernels. This allows it to simultaneously have a fully ahead-of-time-compiled code model – while permitting (even encouraging) code updates at runtime – and a fully runtime-interpreted interface – while permitting extensive compile-time optimization. In this talk, I will examine some of the trade-offs and limitations this requires of user code, especially on common first-class code evaluation features – such as eval and incremental pre-compilation – as well as advanced features – such as @generated functions and @pure. We will also try to take a look at the internal layout and implementation of some of these data structures, and how the compiler works to maintain their correctness over time, despite other changes to the system.
I’ve been a Julia contributor since before it was cool. Now, I’m working for Julia Computing, as the static compilation champion, compiler correctness fiend, and performance cliff jumper.
+ +Increasingly organizations are using cloud platforms to store their data and perform analytics driven by cost, scale, and manageability considerations. Business applications are being retooled to leverage the vast enterprise / public data, artificial intelligence (AI), and machine learning (ML) algorithms. To build and deploy large scale intelligent applications, data scientists and analysts today need to be able to combine their knowledge of analytical languages and platforms like Julia with that of the cloud. +In this talk, data scientists and analysts will learn how to build end-to-end analytical solutions using Julia on scalable cloud infrastructure. Developing such solutions usually requires one to understand how to seamlessly integrate Julia with various cloud technologies. After attending the talk, the attendees should have a good understanding of all the major aspects needed to start building intelligent applications on the cloud using Julia, leveraging appropriate cloud services and tool-kits. We will also briefly introduce the Azure Data Science Virtual Machine DSVM which provides a comprehensive development/experimentation environment with several pre-configured tools to make it easy to work with different cloud services (SQL Data Warehouse, Spark, Blobs etc.) from Julia and other popular data analytics languages. Join this demo heavy session where we cover the end to end data science life-cycle and show how you can access storage and compute services on the Azure cloud using Julia from the DSVM. A self-guided tutorial building upon the examples in the demo will be published online for attendees to continue their learning offline.
+ + +Udayan is a Software Engineer with Algorithms and Data Science group at Microsoft. Before coming to Microsoft, he was designing predictive algorithms to detect threats and malignant apps at a mobile security startup in Chicago. He has a MS and a Ph.D. in Computer Engineering from University of Florida, Gainesville, FL. His research was focused on Trust, Privacy and Behavior mining in Mobile Networks. +Paul is a senior software engineer in Microsoft’s Algorithms and Data Science group, where he is the lead engineer for the Data Science Virtual Machine and works on a variety of solutions for easier machine learning and data science. He was previously the project lead for the Planner service in Office 365. While on Planner he also worked on disaster recovery, topology, storage, and several other core service components. He holds computer science degrees from Clemson and Duke.
+ +Laurent Heirendt, Sylvain Arreckx, Ines Thiele, Ronan M.T. Fleming +Systems Biologists in the COnstraint-Based Reconstruction and Analysis (COBRA) [7] community are gearing up to develop computational models of large and huge-scale biochemical networks with more than one million biochemical reactions. The growing model size puts a strain on efficient simulation and network exploration times to the point that accelerating existing COBRA methods became a priority. Flux balance analysis and its variants are widely used methods for predicting steady-state reaction rates in biochemical reaction networks. The exploration of high dimensional networks has long been hampered by performance limitations of current implementations in Matlab/C (The COBRA Toolbox [8] and fastFVA [3]) or Python (cobrapy [2]). Julia [1] is the language that fills the gap between complexity, performance, and development time. DistributedFBA.jl [4], part of the novel COBRA.jl package, is a high-level, high-performance, open-source Julia implementation of flux balance analysis, which is a linear optimization problem. It is tailored to solve multiple flux balance analyses on a subset or all the reactions of large and huge-scale networks, on any number of threads or nodes using optimization solver interfaces implemented in MathProgBase.jl [5]. Julia’s parallelization capabilities led to a speedup in latency that follows Amdahl’s law. For the first time, a flux variability analysis (two flux balance analyses on each biochemical reaction) on a model with more than 200k biochemical reactions [6] has been performed. With Julia and COBRA.jl, the reconstruction and analysis capabilities of large and huge-scale models in the COBRA community are lifted to another level. +Code and benchmark data are freely available on github.com/opencobra/COBRA.jl +References:
+ +Laurent Heirendt was born in 1987 in Luxembourg City, Luxembourg (Europe). He received his BSc in Mechanical Engineering from the Ecole Polytechnique Fédérale de Lausanne, Switzerland in 2009. A year later, he received his MSc in Advanced Mechanical Engineering from Imperial College London in the UK, where his research and thesis focused on developing a general dynamic model for shimmy analysis of aircraft landing gear that is still in use today. He received his Ph.D. in 2014 in Aerospace Science from the University of Toronto, Canada. He developed a thermo-tribomechnical model of an aircraft landing gear, which led to a patent pending design of a critical aircraft landing gear component. He then worked in industry and oversaw the structural analysis of large aircraft docking structures. +Recently, Laurent started as a Research Associate at the Luxembourg Centre for Systems Biomedicine, where he works in the numerical optimization of large biochemical networks using Julia. Besides his mother tongue Luxembourgish, he is fluent in English, French and German, and he is currently learning Brazilian Portuguese.
+ +How can we find all solutions of a system of nonlinear equations, the “feasible set” satisfied by a collection of inequalities, or the global optimum of a complicated function? These are all known to be hard problems in numerical analysis.
+In this talk, we will show how to solve all of these problems, in a guaranteed way, using a collection of related methods based on interval arithmetic, provided by the IntervalArithmetic.jl package. The starting point is a simple dimension-independent bisection code, which can be enhanced in a variety of ways. This method is rigorous: it is guaranteed to find all roots, or to find the global minimum, respectively.
+One key idea is the use of continuous constraint propagation, which allows us to remove large portions of the search space that are infeasible. We will explain the basics of this method, in particular the “forward-backward contractor”, and describe the implementation in the IntervalConstraintProgramming.jl package.
+This package generates forward and backward code automatically from a Julia expression, using metaprogramming techniques. These are combined into “contractors”, i.e. operators that contract a box without removing any portion of the set of interest. These, in turn, give a rigorous answer to the question whether a given box lies inside the feasible set or not. In this way, a paving (collection of boxes) is built up that approximates the set.
David P. Sanders is associate professor of computational physics in the Department of Physics of the Faculty of Sciences at the National University of Mexico in Mexico City.
+His video tutorials on Julia have a total of 75,000 views on YouTube. He is a principal author of the ValidatedNumerics.jl package for interval arithmetic, and IntervalConstraintProgramming.jl for constraint propagation.
Information in the brain is processed by the coordinated activity of large neural circuits. Neural network models help to understand, for example, how biophysical features of single neurons and the network topology shape the collective circuit dynamics. This requires solving large systems of coupled differential equations which is numerically challenging. +Here, we introduce a novel efficient method for numerically exact simulations of sparse neural networks that bring to bear Julia’s different data structures and high performance. The new algorithm reduces the computational cost from O(N) to O(log(N)) operations per network spike. This is achieved by mapping the neural dynamics to pulse-coupled phase oscillators and using mutable binary heaps for efficient state updates. Thereby numerically exact simulations of large spiking networks and the characterization of their chaotic phase space structure become possible. For example, calculating the largest Lyapunov exponent of a spiking neural network with one million neurons is sped up by more than four orders of magnitude compared to previous implementations in other programming languages (C++, Python, Matlab).
+ + +Rainer just finished his Ph.D. in at the Max Planck Institute for Dynamics and Self-Organization (Göttingen) on ‘Chaotic neural circuit dynamics’ after studying physics at various places. He has been using Julia since 2014, as it minimizes both programming time and CPU time and allows easy debugging, profiling and visualization under one roof.
+ +The Shearlet Transform was proposed in 2005 by the Professor Gitta Kutyniok (http://www3.math.tu-berlin.de/numerik/mt/mt/www.shearlet.org/papers/SMRuADaSO.pdf) and her colleagues as a multidimensional generalization of the Wavelet Transform, and since then it has been adopted by a lot of Companies and Institutes by its stable and optimal representation of multidimensional signals. Shearlab.jl is a already registered Julia package (https://github.com/arsenal9971/Shearlab.jl) based in the most used implementation of Shearlet Transform programmed in Matlab by the Research Group of Prof. Kutyniok (http://www.shearlab.org/software); improving it by at least double the speed on different experiments. +As examples of applications of Shearlet Transform one has Image Denoising, Image Inpaiting and Video Compression; for instance I used it mainly to reconstruct the Light Field of a 3D Scene from Sparse Photographic Samples of Different Perspectives with Stereo Vision purposes. A lot of research institutes and companies have already adopted the Shearlet Transform in their work (e.g. Fraunhofer Institute in Berlin and Charité Hospital in Berlin, Mathematical Institute of TU Berlin) by its directional sensitivity, reconstruction stability and sparse representation.
+ + +Ph.D. student in Mathematics at the Technical University of Berlin (TUB) with Professor Gitta Kutyniok as advisor; major in Mathematics and Physics from National University of México (UNAM); ex Data Scientist of a mexican Open Governance Start Up (OPI); with experience in Data Mining, Machine Learning, Computational Harmonic Analysis and Computer Vision. Currently developing Light Field Reconstruction algorithms using Digital Signal Processing tools for 3D Imaging and Stereo Vision. Is known by his colleagues for using Julia on everything. It was introduced to Julia by Professor David Philip Sanders and after both gave a course on Computational Statistical Physics using Julia at the National University of México (UNAM) which convinced him to adopt Julia as his main programming language.
+ +Flux.jl is a new Julia package for machine learning. It aims to provide strong tooling and support for debugging, high-level features for working with very complex networks, and state of the art performance via backends like TensorFlow or MXNet, while also providing a very high level of interoperability so that approaches can easily be mixed and matched. This talk will introduce Flux from the ground up and demonstrate some of its more advanced features.
+ + +I work with Julia Computing on Julia’s IDE, Juno, as well as various projects within the machine learning ecosystem.
+ +The web is eating the world, but building modern web applications can be an intimidating task. Successful online products must be fast, beautiful and usable. Responsive, maintainable and extendable. Provide simple and flexible web APIs. Be secure. Reach virtually 100% uptime while being easy to debug, extend and update, requiring powerful logging, intelligent caching and rapid scaling strategies. +Julia as a language has an enormous potential in the web space thanks to its concise and friendly syntax, the powerful REPL, Unicode support, cross-platform availability, the efficiently compiled code and its parallel and distributed computing capabilities. And Julia’s ecosystem already provides low level libraries like HttpServer and WebSockets. But they leave the developers having to spend large amounts of time writing glue and boilerplate code: a tedious, expensive and error prone task. +Genie is a new web framework that leverages Julia’s unique combination of features and its extensive collection of packages to empower developers to create high-performance web apps in less time and with less code. It glues low level libraries and contributes its own middlewares to expose a coherent and efficient workflow and a rich API for building web applications. +This talk will give you the guided tour of Genie, introducing the MVC stack and its main components and showing you how to quickly bootstrap a new Genie app and how to easily implement CRUD operations to expose resources over the internet, in an efficient and secure manner. You will see how easy it is to use Genie’s API in tandem with Julia’s modules system to hook up your code - allowing you to focus on your software’s value proposition instead of wasting precious time dealing with the low level details of transporting bytes over the wire.
+ + +Web developer since 2000. Architecting and building multi-tier, performance critical web apps handling large amounts of real time data since 2008. PHP, Ruby, JavaScript, F#, Elixir. Now using Julia and Genie to tackle web development’s own two-language problem (productive-slow-interpreted vs unproductive-fast-compiled). +CTO at OLBG. Startup devotee and serial tech founder. IronHack mentor, organizer of Barcelona Julia and Barcelona on Rails. Creator of Genie.jl.
+ +GLVisualize is a visualization framework written purely in Julia + OpenGL. There are a lot of new changes that I want to talk about:
+Developer of GLVisualize & GPUArrays
+ +Many projects in research and development require analysis of tabular data. For example, medical records can be viewed as a collection of variables like height, weight, and age for different patients. The values may be boolean (yes or no), numerical (100.3), categorical (A, B, O), or ordinal (early, middle, late). Some values may also be missing. However, analysis and feature extraction is made easier by knowing relationships between variables, for example, that weight increases with height. GraphGLRM is a framework that leverages structure in data to de-noise, compress, and estimate missing values. Using Julia’s flexibility and speed, we developed this package quickly and with sufficient performance for real-world data processing needs. GraphGLRMs are now robust and versatile enough to work with sparse, heterogeneous data. We will also discuss updates to Julia data structures and tooling that would ease package development and further empower the GraphGLRM framework. More about GraphGLRMs: https://github.com/mihirparadkar/GraphGLRM.jl More about LowRankModels: https://github.com/madeleineudell/LowRankModels.jl
+ + +Mihir Paradkar recently graduated from Cornell University in Biological Engineering. He has been user of Julia since v0.3.5 and is a developer of GraphGLRM.jl and LowRankModels.jl . He will be starting as a software engineering in data mining at Yelp late this summer.
+ +Data frames are essential tools for data scientists, but existing data frames packages in Julia (and other languages) are sequential and do not scale to large data sets. Alternatively, data frames in distributed frameworks such as Spark are slow and not integrated with other computations flexibly. We propose a novel compiler-based approach where we integrate data frames into the High Performance Analytics Toolkit (HPAT) to build HiFrames. It automatically parallelizes and compiles relational operations along with other array computations in end-to-end data analytics programs, and generates efficient MPI/C++ code. We demonstrate that HiFrames is significantly faster than alternatives such as Spark on clusters, without forcing the programmer to switch to embedded SQL for part of the program. HiFrames is 3.6x to 70x faster than Spark SQL for basic relational operations, and can be up to 20,000x faster for advanced analytics operations, such as weighted moving averages (WMA), that the map-reduce paradigm cannot handle effectively. We will discuss how Julia’s powerful macro and compilation system facilitates developing HiFrames.
+ + +Ehsan Totoni is a Research Scientist at Intel Labs. He develops programming systems for large-scale HPC and big data analytics applications with a focus on productivity and performance. He received his Ph.D. in Computer Science from the University of Illinois at Urbana-Champaign in 2014.
+ +ImageQuilting.jl is a high-performance implementation of texture synthesis and transfer for 3D images that is capable of matching pre-existing data in the canvas where the image is to be synthesized. It can optionally make use of GPUs through the OpenCL standard and is being currently used by the industry for fast generation of 3D geological models. In this talk, I will demonstrate some of the applications of this package in energy resources engineering and hydrogeology, and will highlight the qualities of the Julia programming language that enabled an unprecedented speed in this famous computer vision algorithm.
+ + +I am a Ph.D. candidate in the Department of Energy Resources Engineering at Stanford University. In my research, I study the links between surface processes (i.e. flow and sediment transport) at the surface of the Earth and the resulting geostatistical properties at its subsurface. Part of this research consists of developing efficient algorithms for stochastic/physical simulation of 3D Earth models. For more information, please visit: https://juliohm.github.io
+ +Fully homomorphic encryption (FHE) is a cryptographic technique allowing a user to run arbitrary computations over encrypted data. This is particularly useful for computing statistical analytics over sensitive data. In this work, we introduce a Julia module, Fhe.jl, which supports running Julia functions over an FHE-encrypted data set. We do so by using symbolic execution to convert a Julia function into its circuit representation, which we then evaluate over the encrypted data. In this talk, we will discuss the progress we have made so far, some of the challenges we have run into, and how we hope to work with the Julia community to continue our efforts.
+ + +José Manuel Calderón Trilla is a Research Scientist at Galois, Inc. working on Compilers, Static Analysis, and Formal Methods. He received his Ph.D. from the University of York in the UK for his work on Implicit Parallelism in lazy functional languages.
+ +Julia is a language designed for numerical computing and it does that job pretty well. However, the emphasis on numerical computing and data science tends to overshadow the language’s other use cases. In this talk we share our experiences using Julia to build a distributed data fabric using commodity hardware. A data fabric is a distributed storage system that abstracts away the physical infrastructure and makes data available to applications using well known protocols such as NFS or S3. Our talk focuses on how we use Julia to implement a data fabric with specific examples. We will discuss some of the shortcomings and how we circumvented them. Finally we close by a cost benefit analysis of developing in Julia and how it can be a critical advantage in bringing products to market.
+ + +Ajay works on systems and infrastructure software for fun and profit. He has dabbled in operating systems, memory allocators, file systems and distributed systems. He founded kinant.com in 2017 to simplify the deployment and usage of storage infrastructure.
+ +Julia was designed to be the right language for programming mathematics. In this talk, I’ll argue that its sophisticated type system allows mathematicians to program in the same way they write mathematics. This simplicity has two consequences. First, it has made Julia an attractive ecosystem in which to write mathematical packages: Julia is now the language with the most comprehensive, robust, and user-friendly ecosystem of packages for mathematical programming (or optimization, in modern lingo). Second, it has made Julia the right language in which to express many mathematical problems. The lightweight type system makes it easy to write code that is clearer than pseudocode. +This talk will present three case studies in optimization. We hope the audience will leave the talk with a new appreciation of Julia’s type system, as well as a new toolkit of packages to use for data fitting and optimization.
+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, and engineering system design. Her recent work on generalized low rank models (GLRMs) extends principal components analysis (PCA) to embed tabular data sets with heterogeneous (numerical, Boolean, categorical, and ordinal) types into a low dimensional space, providing a coherent framework for compressing, denoising, and imputing missing entries. She has developed of a number of open source libraries for modeling and solving optimization problems, including Convex.jl, one of the top ten tools in the new Julia language for technical computing, and is a member of the JuliaOpt organization, which curates high quality optimization software. +Madeleine completed her Ph.D. at Stanford University in Computational & Mathematical Engineering in 2015 under the supervision of Stephen Boyd, and a one year postdoctoral fellowship at Caltech in the Center for the Mathematics of Information hosted by Professor Joel Tropp. At Stanford, she was awarded a NSF Graduate Fellowship, a Gabilan Graduate Fellowship, and a Gerald J. Lieberman Fellowship, and was selected as the doctoral student member of Stanford’s School of Engineering Future Committee to develop a road-map for the future of engineering at Stanford over the next 10–20 years. She received a B.S. degree in Mathematics and Physics, summa cum laude, with honors in mathematics and in physics, from Yale University.
+ +Knet (pronounced “kay-net”) is the Koç University deep learning framework implemented in Julia by Deniz Yuret and collaborators. Knet uses dynamic computational graphs generated at runtime for automatic differentiation of (almost) any Julia code. This allows machine learning models to be implemented by only describing the forward calculation (i.e. the computation from parameters and data to loss) using the full power and expressivity of Julia. The implementation can use helper functions, loops, conditionals, recursion, closures, tuples and dictionaries, array indexing, concatenation and other high level language features, some of which are often missing in the restricted modeling languages of static computational graph systems like Theano, Torch, Caffe and Tensorflow. GPU operation is supported by simply using the KnetArray type instead of regular Array for parameters and data. High performance is achieved using custom memory management and efficient GPU kernels.
+ + +Deniz Yuret received his BS, MS, and Ph.D. at MIT working at the AI Lab on machine learning and natural language processing during 1988-1999. He co-founded Inquira, Inc., a startup commercializing question answering technology which was later acquired by Oracle. He is currently an associate professor of Computer Engineering at Koç University, Istanbul and founder of its Artificial Intelligence Laboratory. In his spare time he develops Knet.jl, a Julia deep learning framework that uses dynamic computational graphs generated at runtime for automatic differentiation of (almost) any Julia code.
+ +Our talk discusses the development and origin of LightGraphs, current features, and future developments. We introduce the package’s major design choices in a historical context as a compromise between the three core LightGraphs goals of simplicity, performance, and flexibility. We highlight several areas where specific features of Julia have led to flexible and efficient implementations of graph algorithms. +We will highlight our work in centrality measures, graph traversals, and spectral graph algorithms as examples of areas where Julia’s performance and design decisions have allowed LightGraphs to provide best-in-class implementations of graph algorithms. We also discuss integration with other organizations – JuliaOpt for matching and flow problems, and the Julia data visualization ecosystem – and highlight specifically LightGraphs’ potential to provide leadership on performant graph visualization. +Finally, we speculate on the influence of Julia’s focus on elegant parallel processing to future development of the package.
+ + +Dr. James Fairbanks is a Research Engineer at the Georgia Tech Research Institute where he studies problems in complex networks, data analysis, and high performance computing with applications to healthcare and social phenomena. +Seth Bromberger, a Research Scientist at Lawrence Livermore National Laboratory (https://people.llnl.gov/seth), is currently exploring the application of graph theory and machine learning to cybersecurity problems in critical infrastructure.
+ +Miletus is a financial software suite in Julia, with a financial contract specification language and extensive modelling features. In this talk, we’ll discuss the design principles involved in how to model a contract from primitive components, and how Julia’s language features lend themselves intuitively to this task. We’ll then talk about the various features of the software suite such as closed form models, binomial trees and computation of price sensitivities (aka “the Greeks”), providing several examples and code snippets, along with comparisons with other popular frameworks in this space.
+ + +Dr Simon Byrne is a quantitative software developer at Julia Computing, where he implements cutting edge numerical routines for statistical and financial models. Simon has a Ph.D. in statistics from the University of Cambridge, and has extensive experience in computational statistics and machine learning in both academia and industry. He has been contributing to the Julia project since 2012. Ranjan Anantharaman is a data scientist at Julia Computing where he works on numerical software in a variety of domains. His interests include scientific computing and machine learning. He has been contributing to the Julia project and ecosystem since 2015.
+ +Julia’s unique execution model, metaprogramming facilities, and type system make it an ideal candidate language for native automatic differentiation (AD). In this talk, we’ll discuss a variety of Julia-specific tricks employed by ForwardDiff and ReverseDiff to differentiate user-provided Julia functions. Topics covered include the implementation of a native Julia execution tracer via operator overloading, functor-based directives for specialized instruction taping, SIMD vectorization and instruction elision for inlined dual number operations, and vectorized differentiation of linear algebraic expressions. I’ll close the talk with a glimpse into the future of AD in Julia and JuMP, highlighting the effect new features may have on other downstream projects like Celeste, Optim and RigidBodyDynamics.
+ + +I like to make Julia code differentiate itself.
+ +By many measures, TensorFlow has grown over the last year to become the most popular library for training machine-learning models. TensorFlow.jl provides Julia with a simple yet feature-rich interface to TensorFlow that takes advantage of Julia’s multiple dispatch, just-in-time compilation, and metaprogramming capabilities to provide unique capabilities exceeding TensorFlow’s own native Python API. This talk will demonstrate TensorFlow.jl by guiding listeners through training a realistic model of image captioning , showing how to 1) construct the model with native Julia control flow and indexing, 2) visualize the model structure and parameters in a web browser during training, and 3) seamlessly save and share the trained model with Python. No prior experience with TensorFlow is assumed.
+ + +Ph.D. candidate at MIT studying artificial intelligence
+ +Modia is a Julia package to model and simulate physical systems (electrical, mechanical, thermo-dynamical, etc.) described by differential and algebraic equations. A user defines a model on a high level with model components (such as a mechanical body, an electrical resistance, or a pipe) that are physically connected together. A model component is constructed by “expression = expression” equations. The defined model is symbolically processed, JIT compiled and simulated with Sundials IDA solver with the KLU sparse matrix package. By this approach it’s possible and convenient to build models with hundred thousands of equations describing the dynamics of a car, an airplane, a power plant, etc. and simulate them. The authors used previous experience from the design of the modeling language Modelica (www.Modelica.org) to develop Modia. +In the presentation it is shown how a user can build models and simulate physical systems, including mechanical systems and electrical circuits. Furthermore, the design of Modia is sketched: The Modia language is a domain specific extension of Julia using macros. With graph theoretical algorithms, some of them recently developed by the authors, equations are pre-processed (including analytic differentiation if necessary) and transformed into a special form that can be simulated by IDA. Hereby the sparsity structure of the original (Modia) equations, as well as the nature of array equations are kept intact.
+ + +Hilding Elmqvist attained his Ph.D. at the Department of Automatic Control, Lund Institute of Technology in 1978. His Ph.D. thesis contains the design of a novel object-oriented model language called Dymola and algorithms for symbolic model manipulation. It introduced a new modeling methodology based on connecting submodels according to the corresponding physical connections instead of signal flows. Submodels were described declaratively by equations instead of assignment statements. Elmqvist spent one year in 1978-1979 at the Computer Science Department at Stanford University, California. +In 1992, Elmqvist founded Dynasim AB in Lund, Sweden. The primary product is Dymola for object-oriented modeling allowing graphical composition of models and 3D visualization of model dynamics. Elmqvist took the initiative in 1996 to organize an international effort to design the next generation object-oriented language for physical modeling: Modelica. In April 2006, Dynasim AB was acquired by Dassault Systemes. In January 2016, Elmqvist founded Mogram AB. Current activities include designing and implementing an experimental modeling language called Modia.
+ +By default, Julia comes with a powerful REPL that itself is completely written in Julia. It has, among other things, tab completion, customizable keybindings and different prompt modes to use the shell or access the help system. However, with regards to visual customization there are not that many options for a user to tweak. To that end, I created the package OhMyREPL.jl. Upon loading, it hooks into the REPL and adds features such as syntax highlighting, matching bracket highlighting, functionality to modify input and output prompts and a new way of printing stacktraces and error messages. It also contains some non-visual features, like allowing text that has been copied from a REPL session to be directly pasted back into a REPL and quickly opening the location of stack frames from a stacktrace in an editor. The talk will give an overview of the different features, discuss which features managed to get upstreamed to Julia v0.6 and, if time allows, outline the internals of the package.
+ + +Ph.D. student in computational mechanics at Chalmers University of Technology. Using Julia both for studies and as a hobby.
+ +This talk covers the design and implementation of Pkg3, the third (and hopefully final!) major iteration of Julia’s built-in package manager. We’ll begin with some history: what worked and didn’t work in the two previous iterations of the package manager. Pkg3 tries to marry the better parts of systems like Python’s virtualenv and Rust’s cargo, while supporting federated and layered package registries, and supporting interactive usage as well as reproducible environments and reliable deployment of code in production. We’ll nerd out a bit with some graph theory and how difficult it is to select compatible sets of package versions, and how much harder still it is to make version resolution understandable and predictable. But it won’t be all theory – we’ll also cover imminently practical subjects like “how do I install packages?”
+ + +co-creator of Julia, co-founder of Julia Computing
+ +GPUs have typically been programmed using low-level languages like CUDA and OpenCL, providing full control over the hardware at the expense of developer efficiency. CUDAnative.jl makes it possible to program GPUs directly from Julia, in the case you need the flexibility to write your own kernel functions, without having to fall back to CUDA C or binary libraries. In this talk, I will give an overview of CUDAnative.jl with its features and restrictions, explain the technology behind it, and sketch our future plans.
+ + +Ph.D. student at Ghent University
+ +The QML.jl (https://github.com/barche/QML.jl) package enables using the QML markup language from the Qt library to build graphical user interfaces for Julia programs. The package follows the recommended Qt practices and promotes separation between the GUI code and application logic. After a short introduction of these principles, the first topic of this talk will be the basic communication between QML and Julia, which happens through Julia functions and data (including composite types) stored in context properties. Using just a few basic building blocks, this makes all of the QML widgets available for interaction with Julia. The next part of the talk deals with Julia-specific extensions, such as the Julia ListModel, interfacing with the display system and GLVisualize and GR.jl support. These features will be illustrated using live demos, based on the examples in the QML.jl repository. Finally, some ideas for extending and improving the package will be listed, soliciting many contributions hopefully. +The target audience for this talk is anyone interested in developing GUIs for their Julia application with a consistent look on OS X, Linux and Windows. All user-facing code is pure Julia and QML, no C++ knowledge is required to use the package.
+ + +I am an associate professor at the mechanics department of the Royal Military Academy. For my Ph.D., I worked on Coolfluid, a C++ framework for computational fluid dynamics with a domain specific language. My interest in Julia is sparked by its powerful metaprogramming functionality coupled with C++-like performance, together with much better accessibility for students. To ease the transition to Julia, we are working on making some C++ libraries available in Julia. The QML.jl package is part of this effort. We also use Julia in our daily teaching activities, to provide students with interactive solutions to exercises.
+ +Query is a package for querying julia data sources. Its role is similar to LINQ in C# and dplyr in R. It can filter, project, join and group data from any iterable data source. It has enhanced support for querying arrays, DataFrames, DataTables, TypedTables, IndexedTables and any DataStream source (e.g. CSV, Feather, SQLite etc.). The package also defines an interface for tabular data that allows a) dispatch on any tabular data source and b) simple conversions of tabular data representations. The talk will first introduce Query from a user perspective and highlight different examples of queries that the package makes feasible. The second half of the talk will dive deep into the internals of the package and explain the various extension points that package provides.
+ + +David Anthoff is an environmental economist who studies climate change and environmental policy. He co-develops the integrated assessment model FUND that is used widely in academic research and in policy analysis. His research has appeared in Science, the Journal of Environmental Economics and Management, Environmental and Resource Economics, the Oxford Review of Economic Policy and other academic journals. He contributed a background research paper to the Stern Review and has advised numerous organizations (including US EPA and the Canadian National Round Table on the Environment and the Economy) on the economics of climate change. +He is an assistant professor in the Energy and Resources Group at the University of California, Berkeley. Previously he was an assistant professor in the School of Natural Resources and the Environment of the University of Michigan, a postdoc at the University of California, Berkeley and a postdoc at the Economic and Social Research Institute in Ireland. He also was a visiting research fellow at the Smith School of Enterprise and the Environment, University of Oxford. +He holds a Ph.D. (Dr. rer. pol.) in economics from the University of Hamburg (Germany) and the International Max Planck Research School on Earth System Modelling, a MSc in Environmental Change and Management from the University of Oxford (UK) and a M.Phil. in philosophy, logic and philosophy of science from Ludwig-Maximilians-Universität München (Munich, Germany).
+ +We will present 3 tools for decision making under uncertainty in the power systems area: SDDP, a tool for optimal hourly operation of complex power systems; OptGen, a computational tool for determining the least-cost expansion of a multi-regional hydrothermal system; OptFlow, a mathematical model to optimize operation of a generation/transmission system with AC electrical network constraints. +These models have been used by system operators, regulators and investors in more than seventy countries in the Americas, Asia-Pacific, Europe and Africa, including some of the largest hydro based systems in the world, such as the Nordic pool, Canada, the US Pacific Northwest and Brazil. SDDP is also the model used by the World Bank staff in their planning studies of countries in Asia, Africa and Latin America. OptGen had some interesting applications regional studies such as the interconnection of Central America, the Balkan regions, the interconnection of nine South American countries, Africa (Egypt-Sudan-Ethiopia and Morocco-Spain) and Central Asia. The original version of all 3 models was written in FORTRAN with the aid of some modelling tool or higher level API: AMPL for OptFlow, Mosel for OptGen and COIN-OR API for SDDP. Similar to any software, maintaining the code and adding new features became increasingly complex because they have to be built upon older data structures and program architectures. +These concerns motivated PSR to develop an updated version of these programs written entirely in julia (with JuMP and MathProgBase) for three basic reasons: (i) the code is concise and very readable; (ii) the availability of an advanced optimization “ecosystem”; and (iii) excellent resources for distributed processing (CPUs and GPUs). We retained the use of Xpress by developing the Xpress.jl library. We also use MPI.jl for distributed processing (including multiple servers in AWS). +The computational performance of the new code is matches the current ones’, which is very encouraging given that the current FORTRAN code has been optimized for several years based on thousands of studies. Also, the julia code incorporates several new modeling features that were easy to implement in all the 3 models: including SDP and SOCP relaxations for OPF and SDDiP method for stochastic integer optimization, confirming our expectation of faster model development. +The new models were incorporated to an integrated planning system for Peru being developed by PSR, which will be delivered in August 2017. They are also being internally tested as a “shadow” to the current version for studies in several countries and was delivered for beta testing for some PSR clients. The official release is scheduled for the end of 2017.
+ + +Camila graduated as an industrial engineer and has a MSc in Decision Analysis from PUC-Rio. Attended UC Berkeley for a semester during under graduation. Joined PSR in 2013, where, at present, works with the development of the models of optimization of hydrothermal dispatch under uncertainty with network constraints (SDDP model) and electric systems expansion planning (OPTGEN model).
+ +Joaquim has a BSc degree in electrical engineering and a BSc degree in mathematics, both from PUC -Rio and is currently working towards a PhD in electrical engineering with emphasis on decision support, also at PUC-Rio. During his undergraduate studies, he attended a year at UC Santa Barbara. He joined PSR in 2015 has been been working on the development of optimization models for hydro-thermal dispatch under uncertainty with transmission constraints reliability analysis, electrical systems expansion planning and nonlinear optimal power flow. Before PSR Joaquim worked with decision support at LAMPS (Laboratory of applied mathematical programming and statistics, at PUC-Rio) and with OTDR and Signal Processing at LabOpt (Optoelectronics laboratory, at PUC-Rio).
+ +from @jiahao: +We have really thought carefully about what the transpose of a vector should mean in a programming language. The pre-0.6 behavior that vector’vector yields a vector, vector’ yields a matrix, and vector’’ yields a matrix are all bad mathematics and produced no shortage of confusion by end users. +I present a summary of our research at the MIT Julia Labs into issue #4774, as a language design question that is informed by a comprehensive understanding of user expectations. Our main result is a short proof that it is impossible to avoid either new types, “ugly mathematics” (violation of Householder notation) or type instability. A single Array type is incompatible with Householder notation that produces the expected types from typical linear algebraic expressions. Furthermore, Householder notation intrinsically requires a conflation of 1x1 matrices and true scalars. +I also provide historical evidence the notion of “ugly mathematics” is neither static nor objective. In reality, linear algebra has changed greatly over the past centuries, demonstrating the impermanence of even elementary concepts of what matrices and vectors are and how they have been influenced by notation - a discussion forced into consciousness through the lens of programming language design, types, and formal program semantics. +I review the resolution of #19670 in the context of other designs in other programming languages, showing that all these designs turn out to locally optimal in conflating as much of Householder notation and array semantics as possible. +Joint work with Alan Edelman, Andy Ferris, and a few other people.
+ + +Data Scientist at Capital One, formerly Research Scientist at MIT
+ +In this talk we shall present TaylorIntegration.jl, an ODE integration package using Taylor’s method in Julia. The main idea of Taylor’s method is to approximate locally the solution by means by a high-order Taylor expansion, whose coefficients are computed recursively using automatic differentiation techniques. One of the principal advantages of Taylor’s method is that, whenever high accuracy is required, the order of the method can be increased, which is more efficient computationally than taking smaller time steps. The accuracy of Taylor’s method permits to have round-off errors per integration step. Traditionally, it has been difficult to make a generic Taylor integration package, but Julia permits this beautifully. We shall present some examples of the application of this method to ODE integration, including the whole computation of the Lyapunov spectrum, use of jet transport techniques, and parameter sensitivity. Open issues related to improving performance will be described.
+ + +Jorge Perez is a Physics Ph.D. student at UNAM, Mexico, under supervision of Luis Benet and David P. Sanders, authors of TaylorSeries.jl and ValidatedNumerics.jl. His Ph.D. research project is related to understanding the dynamics of minor Solar System objects: comets, asteroids, etc. He is coauthor of TaylorIntegration.jl and a contributor to TaylorSeries.jl. +Luis Benet is Associate Professor at the Instituto de Ciencias Físicas of the National University of Mexico (UNAM). He is mainly interested in classical and quantum chaos, including the dynamics of Solar System objects. He is coauthor of ValidatedNumerics.jl, TaylorSeries.jl and TaylorIntegration.jl, and has contributed to other Julia packages.
+ +We present a family of three Julia packages that together constitute a complete framework to describe and solve rational expectation models in economics. Dolang.jl is an equation parser and compiler that understands how to compile latex-like strings describing systems of equations into efficient Julia functions for evaluating the levels or derivatives of the equations. Dolo.jl leverages Dolang and implements a variety of frontier algorithms for solving a wide class of discrete time, continuous control rational expectations models. Finally, Dyno.jl builds upon Dolang to implement a Julia prototype of the Matlab-based dynare software library used extensively throughout academia and the public sector to approximate the solution to and estimate rational expectations models.
+ + +Economics Ph.D. student at NYU Stern. Active Julia member since 0.2
+ +We (Twan and Robin) are graduate students in the Robot Locomotion Group at MIT. Our research focuses on modeling and optimization for the simulation and control of walking (and sometimes flying) robots. We’ve been using Julia in our research over the past year, and we’re excited to share what we’ve learned, what we’ve built, and what we’re hoping to see in the future of Julia. +Specifically, we’d like to share some of our work on:
+We would also like to talk about how some of the best parts of the Julia ecosystem have made our work possible, like JuMP.jl, ForwardDiff.jl, and StaticArrays.jl. +And, finally, we plan to discuss what we hope to see in Julia’s future, including what the role of Julia can be inside a real-time robot controller.
+ + +We’re graduate students in the Robot Locomotion Group at MIT, where we work on simulation, planning, and control of walking and flying robots.
+ +Julia 0.6 includes a long-needed overhaul of the type system. While the effects of this change are not always visible, the new system eliminates classes of bugs and increases the expressiveness of types and method signatures. I plan to briefly explain how the new system works and what you can do with it. But more importantly, I want to ask: where do we go from here? Will we ever need another overhaul? I’ll present some possible future features and other related speculations. Topics may include record types, more powerful tuple types, protocols, ugly corner cases, and method specificity and ambiguity.
+ + +Jeff is one of the creators of Julia, co-founding the project at MIT in 2009 and eventually receiving a Ph.D. related to the language in 2015. He continues to work on the compiler and system internals, while also working to expand Julia’s commercial reach as a co-founder of Julia Computing, Inc.
+ +Turing is a new probabilistic programming language (PPL) based on Julia, a framework which allows users to define probabilistic models and perform inference automatically. Thanks to Julia’s meta-programming support, Turing has a very friendly front-end modelling interface. Meanwhile, coroutines are used in Turing’s inference engine development to achieve the state-of-the-art sampling performance. Also, we have recently introduced a new Gibbs interface, which allows user to compose different samplers and run them in the same time. In this talk, we will discuss our motivation of developing Turing in Julia, introduce the design and architecture of Turing, and present some practical examples of how probabilistic modelling is performed in Turing.
+ + +Developers of the Turing project form Cambridge Machine Learning Group
+ +This talk will give an overview of how researchers at the Federal Reserve Bank of New York have implemented economic forecasting and other post-estimation analyses of dynamic stochastic general equilibrium (DSGE) models using Julia’s parallel computing framework. This is part of the most recent release of our DSGE.jl package, following our ports of the DSGE model solution and estimation steps from MATLAB that were presented at JuliaCon in 2016. I will discuss the technical challenges and constraints we faced in our production environment and how we used Julia’s parallel computing tools to substantially reduce both the time and memory usage required to forecast our models. I will present our experiences with the different means of parallel computing offered in Julia - including an extended attempt at using DistributedArrays.jl - and discuss what we have learned about parallelization, both in Julia and in general. +In addition, I will provide some of our new perspectives on using Julia in a production setting at an academic and policy institution. DSGE models are sometimes called the workhorses of modern macroeconomics, applying insights from microeconomics to inform our understanding of the economy as a whole. They are used to forecast economic variables, investigate counterfactual scenarios, and understand the impact of monetary policy. The New York Fed’s DSGE model is a large-scale model of the U.S. economy, which incorporates the zero lower bound, price/wage stickiness, financial frictions, and other realistic features of the economy. Solving, estimating, and forecasting it presents a series of high-dimensional problems which are well suited for implementation in Julia.
+ +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.
+ + +I’m a Research Analyst at the New York Fed using Julia to estimate and forecast macroeconomic models. I’m interested in applying the frontier of scientific computing to economic research, so that we can solve more realistic and complex models.
+ +Convex optimization problems require rigorous mathematical understanding to solve them. Convex.jl allows users to solve complex optimization problems easily by providing a simple intuitive user interface to express the objective function and constraints. As it became popular, we saw increased demand to support optimization over complex numbers, from users working in diverse scientific fields including power grid optimization, quantum information theory, wireless communication, and signal processing. Previously, these users relied on various tools such as MATLAB’s cvx and open-source python package PICOS to tackle different problems depending upon their domain of work. Convex’s new support for complex numbers allows users to approach each of these problems in Julia. In this talk, I will show how to the new functionality in Convex.jl provides a single integrated solution for many types of Disciplined Convex Programming Problems and show how to solve complex problems using Convex.jl in very few lines of code, taking examples from scientific domains mentioned above. I will also present benchmarks comparing Convex.jl with competing open-source tools.
+ + +Ayush Pandey is a final year graduate student at IIT Kharagpur studying Mathematics & Computing Sciences with micro-specialization in Optimization Theory and Applications. He is also a Google Summer of Code, 2016 fellow under the Julia Language.
+ +The use of multiple dispatch in Julia’s standard library and user-written functions presents a challenge for automated techniques of generating test data. In order to exercise all the methods that implement a function, the generation technique must generate test data with diverse data types, but traditional techniques typically focus solely on diverse data values and implicitly assume a constant data type. In this talk, I will demonstrate our solution to this challenge which automatically learns an effective probability distribution over types and methods that create instances of these types. I will explain how we used this approach to fuzz-test some common arithmetic and string functions in the Julia standard library, in the process identifying three faults.
+ + +I am an assistant professor in software engineering. The primary objective of my research is to improve the cost-effectiveness of software testing through the application of machine learning and statistical methods. I have been a user of Julia for three years, and am co-developer of the DataGenerators package which facilitates the generation of complex test data.
+ +Complex systems in biology are often difficult to treat analytically using mathematics and expensive to investigate with empirical methods. Moreover, deterministic approaches are misleading in systems that exhibit noise (e.g. rare events akin to mutation and extinction). Stochastic simulation provides investigators with the ability to simulate complex systems by integrating mathematical rigor and biological insight. However, simulations are slow, computationally expensive, and difficult to implement in software. My goal in developing BioSimulator.jl is to provide investigators with a tool that enables (1) quick and intuitive model prototyping, (2) efficient simulation, (3) visualization of simulation output, and (4) implementing new stochastic simulation algorithms. Using the Julia language allowed us to meet all four criteria with relative ease and extend to parallelized simulations. My talk will describe the theory underlying BioSimulator.jl, highlight aspects of our implementation, and present a few numerical examples.
+ + +I am a first-year student in biomathematics. My studies are focused on stochastic processes, scientific computing, and optimization.
+ +Circuitscape is one of the most popular tools to measure landscape connectivity, using concepts from electrical circuit theory. Ecologists can model landscapes as large resistance maps and then compute current maps and voltage potentials at various parts on the landscape. Computationally, this involves constructing a large graph and using a sparse solver. This tool has originally been written in Python, and this talk will be about porting it to Julia as well as improving the solver in the package. This talk will also focus on performance comparisons between the Julia and Python versions.
+ + +Ranjan Anantharaman is a data scientist at Julia Computing. His interests span applied mathematics and numerical computing, and he enjoys working with computation across a variety of fields and domains.
+ +Neurons throughout the brain, and particularly in the cerebral cortex, represent many quantities of interest using population codes. Latent variable models of neural population activity may be seen as attempting to identify the value, time-evolution and encoding of such internal variables from neural data alone. They do so by seeking a small set of underlying processes that can account for the coordinated activity of the population. +We introduce a novel estimation method [1] for latent factor models for point processes that operates on continuous spike times. Our method is based on score matching for point process regressions [2] adapted to population recordings with latent processes formed by mixing basis functions. +The basis functions are represented as either Fourier modes, or functions living in a Reproducing Kernel Hilbert Space, parametrised using MLKernels. The method requires the kernel matrix as well as the first and second derivatives thereof, which we can compute efficiently via the Calculus package, making use of anonymous functions. Parameter estimation is then closed form and thus lightning fast up to normalisation, but afterwards we need to estimate the total intensity in the observation period. The approximation of the time integral relies on Cubature.jl. +Due to its speed, this method enables neuroscientists to visualise latent processes in real time during experimental recordings and immediate compare them to their expectations, thus quickening the Planning-Design-Analysis loop by a large margin.
+Gergo focused on math and physics in high school, but completed an engineering degree in Molecular Bionics as an undergrad in his home city, Budapest. After being the image processing guy in a cancer research lab in London as well as learning about AI in Leuven, Belgium, Gergo settled as a Ph.D. student in the Gatbsy Computational Neuroscience Unit, working on developing machine learning algorithms to process and understand various types of neural data.
+ +Stochastic Dual Dynamic Programming (SDDP) is an optimization algorithm for solving large, multi-stage stochastic programming problems. It is well known in the electricity community, but has received little attention in other application areas. The algorithm is computationally demanding as it typically involves iteratively solving hundreds of thousands of linear programs. In the past, implementations have been coded in slow, but expressive mathematical optimization languages such as AMPL, or in fast, but low level languages such as C++. In this talk, we detail a JuMP extension we have developed to solve problems using SDDP. We also present benchmarks showing that our Julia implementation has similar run-times to a previous version developed in C++, while being more flexible and expressive. This speed and flexibility has allowed us to revisit assumptions made in previous work, as well as apply the SDDP algorithm to problems as diverse as agriculture, energy, and finance.
+ + +Oscar Dowson (@odow) is a P.h.D. Candidate in Engineering Science at the University of Auckland. He works on applying stochastic optimization to the New Zealand dairy industry.
+ +The DataStreams package defines a powerful and performant interface for getting data in and out of Julia. Come learn about exciting advances in features and performance as we approach Julia 1.0.
+ + +Attended Carnegie Mellon for a master’s degree in data science and active Julia contributor for 4 years now.
+ +This talk will address efforts to promote diversity and inclusion at JuliaCon this year, with the goals of a) increasing awareness of JuliaCon’s initiatives among conference participants and the Julia community at large and b) starting a public conversation about diversity and inclusion with other open-source conferences. It will place JuliaCon’s initiatives in the context of the broader scientific computing community.
+ + +Erica is a research analyst in the Macroeconomics function at the Federal Reserve Bank of New York and the Diversity Chair for JuliaCon 2017. She is a 2015 graduate of Williams College and plans to begin her Ph.D. in Economics in the fall.
+ +Many species of bacteria are able to collectively sense and respond to their environment. This communication form known as quorum-sensing (QS) can be achieved through the production of small molecules that are able to freely diffuse across cell membranes. These molecules (autoinducers) can subsequently be detected by other individuals in the population and once a threshold limit is reached, then this may cause a change in gene expression which allows bacteria to coordinate their activities such as biofilm formation, virulence and antibiotic resistance. Despite the widespread interest in QS from molecular mechanisms to social evolution and pathogen control, there is still controversy over the basic evolutionary function of QS. Using Julia as the agent-based modeling platform, we have been able to investigate the rewards and risks of coordination and cooperation in QS. In this talk, I will briefly introduce the research background and share some of our results obtained from in silico evolution using Julia. This work is important as it sheds light on how simple signal-mediated behavioral rules can shape complex collective behaviors in bacteria. Julia greatly helped simplify the modeling precess and speed up simulations.
+ + +Yifei Wang is currently a postdoctoral research fellow with the School of Biological Sciences at Georgia Institute of Technology. His research focuses on collective intelligence, evolutionary dynamics and high-performance computing. Dr. Wang received a degree of B.Eng. in computer science & technology in 2009, a degree of M.Eng. in astronautics engineering in 2012, and a degree of Ph.D. in computing in 2016. He was an awardee of Richard E. Merwin Student Scholarship from the IEEE Computer Society in 2011, and received a three-year Overseas University Research Studentship from the University of Bath (UK) in 2012. Dr. Wang was the Student Activities Chair of IEEE UK & Ireland Section from 2013 to 2015. He along with his team successfully organized the 3rd IEEE UK & Ireland Student Branch Congress in 2013.
+ +GR is a plotting package for the creation of two- and three-dimensional graphics in Julia, offering basic MATLAB-like plotting functions to visualize static or dynamic data with minimal overhead. In addition, GR can be used as a backend for Plots, a popular visualization interface and toolset for Julia. Using quick practical examples, this talk is going to present the special features and capabilities provided by the GR framework for high-performance graphics, in particular when being used in interactive notebooks (Jupyter), development environments (Atom), desktop applications (nteract) or terminal programs (iTerm2). The presentation also introduces how to embed GR in interactive GUI applications based on QML.jl, a new plotting interface to Qt5 QML. Moreover, some experimental features and elements will be introduced, i.a. a meta layer providing an interactive interface to new backends based on Qt5 or JavaScript.
+ + +Josef Heinen is the head of the group “Scientific IT–Systems” at the Peter Grünberg Institute / Jülich Centre for Neutron Science, both institutes at Forschungszentrum Jülich, a leading research centre in Germany. The design and development of visualization systems have been an essential part of his activities over the last twenty years. Most recently his team is engaged with the further development of a universal framework for cross-platform visualization applications (GR Framework).
+ +The pricing of bonds or a Credit Portfolio usually has simple mathematics. However, when faced with a big portfolio, careful design is crucial for a fast execution time. I’ll show how I designed a solution to price a database of about 2.4 million contracts with 78 million cashflows in up to 3.5 minutes using a 8 core machine. The solution uses plain simple Julia code, some parallel computation and buffering strategies, Julia’s native serialization for fast-loading data from the disk, and a handful of packages. BusinessDays.jl and InterestRates.jl packages will be featured.
+ + +Bachelor in Computer Engineering, M. Sc. in Economics, Market Risk Manager at BNDES (Brazilian Development Bank).
+ +In the multi-disciplinary field of systems biology, we welcome the opportunity that Julia brings for writing fast software with simple syntax. Speed is important in an age when biological datasets are increasing in size and analyses are becoming computationally more expensive. One example is the problem of determining how genes within a cell interact with one another. In the inference of gene regulatory networks (GRN) we seek to detect relationships between genes through statistical dependencies in biological data, and as datasets grow, so does computation time. Some algorithms use measures from information theory, which are suitable for detecting nonlinear biological relationships, but incur a high computational cost. We developed InformationMeasures.jl, a package for calculating information theoretic measures. The improvement in performance of our Julia package compared to widely-used packages in other languages enables us to develop new algorithms with higher complexity, examining triples, rather than pairs, of genes. These we can show are more successful than pairwise methods (in simulated data where the underlying GRNs are known), and scale well to the size of the largest currently-available biological datasets.
+ + +Thalia is a Ph.D. student in theoretical systems biology at Imperial College, London. Her research focuses on algorithm development for biological network inference, in particular using information theory. Outside of her studies she contributes to various open source software projects.
+ +LLVM.jl provides a high-level Julia interface to the LLVM compiler framework. In this talk, I’ll explain how to use LLVM.jl for basic code generation and execution, as well as how to integrate it with the rest of the Julia compiler.
+ + +Ph.D. student at Ghent University
+ +At present, two options exist for saving Julia data structures to disk: Julia’s built-in serializer and the JLD (Julia data) package. The built-in serializer achieves reasonable performance, but uses a non-standardized format that differs by Julia version and processor architecture. JLD saves data structures in a standardized format (HDF5), but has substantial overhead when saving large numbers of mutable objects. In this talk, I describe the design of JLD2, a re-implementation of JLD. By replacing JLD’s dependency on the HDF5 library with a pure Julia implementation of a subset of HDF5, JLD2 achieves performance comparable to Julia’s built-in serializer, while writing files readable by standard HDF5 implementations. Additionally, JLD2 resolves numerous issues with the previous JLD format and implementation.
+ + +I am currently a Ph.D. student in neuroscience at MIT, but my affiliation will probably change before JuliaCon.
+ +Whole-genome sequencing (WGS) data is being generated at an unprecedented rate. Analysis of WGS data requires a flexible data format to store the different types of DNA variation. A new WGS variant data format “SeqArray” was proposed recently (Zheng X, etc, 2017 Bioinformatics), which outperforms text-based variant call format (VCF) in terms of access efficiency and file size. +Here I introduce a new Julia package “JSeqArray” for data manipulation of genotypes and annotations in an array-oriented manner (https://github.com/CoreArray/JSeqArray). It enables users to write portable and immediately usable code in the wider scientific ecosystem. When used in conjunction with the in-built multiprocessing and job-oriented functions for parallel execution, the JSeqArray package provides users a flexible and high-performance programming environment for analysis of WGS variant data. In the presentation, the examples of calculating allele frequencies, principal component analysis and association tests of linear regression will be given.
+ + +Ph.D, Biostatistics, (6/13) Dept. of Biostatistics, UW, Seattle, WA Postdoctoral Fellow, (7/13 – 8/15) Dept. of Biostatistics, University of Washington (UW), Seattle, WA Senior Fellow, (9/15 – present) Dept. of Biostatistics, University of Washington (UW), Seattle, WA Develop and apply statistical and computational methods for the interpretation of large-scale genetic data
+ +TBD
+ + +co-creator of Julia, co-founder of Julia Computing
+ +Seismic.jl is a Julia package that provides a framework for seismic wave modeling, data processing and imaging. The current version includes support to read/write seismic data, reconstruction and denoising of multi-dimensional (5D) seismic data via parallel and distributed tensor completion, GPU-accelerated finite-difference solvers for seismic wave simulations, and seismic imaging including passive-seismic source location. In this lightning talk, I will briefly describe our area of research and immediately, show how Seismic.jl has been used as main framework for our research in applied seismology.
+ + +Wenlei Gao received his B.Sc in 2010 and M.Sc in 2013 in Geophysics from China University of Petroleum, Beijing, China. From 2013 to 2014 he worked for the Research Institute of China National Offshore Oil Company. He is currently enrolled in the Ph.D. program in Geophysics in the University of Alberta. His research is mainly focused on multicomponent seismic data registration and joint deconvolution.
+ +A quick update on the state of Julia on the Raspberry Pi. We will see how get Julia and GPIO related packages working on the Pi, and explore some working examples of applications running on the Pi and utilising its power to interact with the physical world.
+ + +Avik is the author of Julia’s integration with Java and various other packages. One of his hobbies is to make Julia a first class language on the Raspberry Pi.
+ +Julia has the potential to become a major programming language in economics. In this presentation I will suggest a new way to calibrate models of economic growth. For that purpose I use a Markov-Chain Monte-Carlo algorithm (the Klara package) and I repeatedly solve for the roots of a big system of nonlinear equations using the JuMP and Ipopt packages. With this approach I am able to estimate the distributions of parameter values which drive long-run economic growth and project confidence intervals of macroeconomic variables into the future. For this purpose Julia is the best programming language that I know of, because it combines a great range of functionalities and at the same time it is very fast. To conclude, I will reflect on some challenges that came up during the project.
+ + +I am a Ph.D. student in the economics department at the Ludwig-Maximilians University in Munich (Germany).
+ +A quick presentation on our experience of running JuliaBox on various cloud platforms viz. Amazon AWS, Google Cloud Platform and Microsoft Azure. Also we present the current development plans to make JuliaBox faster and support a host of new features.
+ + +Software Engineer at Julia Computing Inc.
+ +JuliaDB.jl is an end-to-end all-Julia data analysis platform incorporating storage, parallelism and compute into a single model. One can load a pile of CSV files into JuliaDB as a distributed table. JuliaDB will index the files and save the index for efficient lookup of subsets of the data later. You can also convert the data from the CSV files into an efficient memory mappable binary format (“ingest”). +This talk will be a brief introduction to the basic primitives of JuliaDB and how to use them.”
+ + +Jeff is one of the creators of Julia, co-founding the project at MIT in 2009 and eventually receiving a Ph.D. related to the language in 2015. He continues to work on the compiler and system internals, while also working to expand Julia’s commercial reach as a co-founder of Julia Computing, Inc.
+ +JuliaRun is a product of Julia Computing under development and a few early users. It is adaptable to a variety of private and public clouds and makes it easy to deploy Julia applications both batch and online. We will present a brief of the architecture and how it can help deploy scalable end to end applications.
+ + +Tanmay and Pradeep have contributed to Julia packages in JuliaWeb and JuliaCloud.
+ +I will present Junet — a new package for network analysis that seeks to be a fast and hackable alternative to mainstream network analysis libraries like NetworkX, igraph, and graph-tool. Unlike other Julia packages, it allows to quickly traverse and modify the graphs as well as to associate the attributes with their nodes and edges. I will discuss the data structures implemented in Junet and showcase how specific Julia’s features allow to make them efficient. For example, thanks to parametric types it is possible to shrink the memory consumed by Junet to a fraction of what other libraries require. And conjunction of multiple dispatch with just-in-time compilation allows to optimize some methods based on the specific types they operate on, sometimes eliminating the computation altogether. The talk will also overview things that are experimental and don’t work so well like creating zero-cost iterators and parallelizing loops. Finally, I will present the benchmarks comparing Junet with state-of-the-art libraries for network analysis.
+ + +Graduate student
+ +Analysis of high-throughput data can be improved by taking advantage of known relationships between observations. Matrix linear models provide a simple framework for encoding such relationships to enhance detection of associations. Estimation of these models is challenging when the datasets are large and when penalized regression is used. This talk will discuss implementing fast estimation algorithms for L1-penalized matrix linear models as a first-time Julia user and fluent R user. We will share our experiences using Julia as our platform for prototyping, numerical linear algebra, parallel computing, and sharing our method.
+ + +Jane Liang recently obtained a bachelor’s degree in statistics from UC Berkeley and plans to enter a doctoral program later this year. Currently, she is a scientific programmer working with Dr. Saunak Sen at the University of Tennessee Health Science Center, Department of Preventive Medicine, Division of Biostatistics.
+ +The parallel application of multiple statistical hypothesis tests is one of the fundamental patterns of exploratory data analysis for big datasets. This becomes essential in various fields of scientific research, such as in high-throughput biology, medicine and imaging where one is routinely faced with millions of tests. The goal is to protect against spurious discoveries with rigorous statistical error control guarantees, while simultaneously providing enough power to detect needles in a haystack. Here, we present MultipleTesting.jl, a package that provides a unified interface for classical and modern multiple testing methods. We give a quick introduction to the underlying statistical concepts and show how Julia is ideally suited for such an endeavour: First, most multiple testing procedures consist of a standard set of primitives, such as p-values, adjusted p-values and hypothesis weights. Second, elaborate (multiple testing) algorithms often consist of simpler components in a plug-and-play fashion; these include estimators of the proportion of true null hypotheses, parametric as well as non-parametric distribution estimators, and statistical machine learning techniques. All of these ideas can be abstracted away by Julia’s type system and multiple dispatch. Third, Julia provides the computational performance which is necessary when analyzing millions of hypotheses. We believe MultipleTesting.jl complements the growing number of high quality statistics packages in Julia’s ecosystem.
+ + +Nikos Ignatiadis is a first year Ph.D. student at Stanford’s Statistics department. He is interested in the development of interpretable methods for multiple testing and high dimensional inference.
+ +Nullability is a complex issue for any programming language or domain; Nulls.jl puts forth the data-friendly approach Julia has wanted and deserves with core language support.
+ + +Attended Carnegie Mellon for a master’s degree in data science and active Julia contributor for 4 years now.
+ +Geophysical inversion is the mathematical and computational process of estimating the spatial distribution of physical properties of the earth’s subsurface from remote measurements. It’s a key tool in applied geophysics, which is generally concerned with determining the structure and composition of the earth’s interior without direct sampling. At JuliaCon 2017 I would like to discuss our group’s efforts to develop a modular, scalable, and extensible framework for solving geophysical inverse problems and other partial differential equation (PDE) constrained parameter estimation problems in Julia. +To solve PDE constrained parameter estimation problems we need advanced algorithms for optimization, for the solution of PDEs, and the ability to efficiently share information between these domains. Our framework, called jInv—short for JuliaInversion—provides modular building block routines for these tasks that allow users to easily write their own software to solve new problems. The framework heavily uses Julia’s multiple dispatch to allow for extensibility and generic programming. +It is also critical that software implementations of these algorithms can scale to large distributed computing systems. jInv allows users to exploit the parallelism in geophysical inverse problems without detailed knowledge of Julia’s parallel computing constructs. +The first main goal of my talk is to discuss our approach to exploiting parallelism in geophysical inverse problems and how it has been implemented in jInv. The second goal is to illustrate, through examples of developing jInv modules for new geophysical problems, how we’ve moved jInv from a research project for the benefit of our own group to a tool that can be of use to the wider community.
+ + +Hi! I’m a Ph.D. student in the department of Earth, Ocean and Atmospheric Sciences at the University of British Columbia in Vancouver Canada. Academically I’m interested in developing new computational methods for solving geophysical imaging problems. Since coming to UBC Julia has become my language of choice and I now consider myself a reformed Fortran programmer.
+ +SparseRegression implements a variety of offline and online algorithms for statistical models that are linear in the parameters (generalized linear models, quantile regression, SVMs, etc.). This talk will discuss my experience using primitives defined in the JuliaML ecosystem (LossFunctions and PenaltyFunctions) to implement a fast and flexible SparseReg type for fitting a wide variety of models.
+ + +Josh is a statistics Ph.D. student at NC State University, where he researches on-line optimization algorithms for performing statistical analysis on big and streaming data.
+ +I will describe my experience working with and developing highly efficient data structures in Julia which leverage statically known information - such as the type(s) contained in a collection, or the predetermined size of an array. Julia’s combination of efficient code generation and metaprogramming capability make it an ideal language to implement data structures which are both convenient to program with and lightning fast in execution. +I plan to describe the various metaprogramming approaches which are useful for implementing containers of known size or having inhomogeneous elements - by using traits, pure functions, generated functions, macros and recursion. I will touch upon the successes and failures of packages like StaticArrays.jl, Switches.jl and TypedTables.jl, and hope to preview work on a more flexible yet strongly-typed tabular data structure than currently provided by TypedTables.
+ + +I currently work at Fugro Roames on the intersection of machine learning, geodesy and big data. Beginning with detailed, large-scale scans of the physical world, we deduce intelligence for our clients that would be expensive to acquire directly. Previously, I worked in academia as a numerical quantum physicist, where I was attracted to Julia for its unique combination of user productivity and speed.
+ +The recent advances in machine learning and artificial intelligence are amazing, and Julia seems poised to play a significant role in these fields. Yet, in order to have real value within a company, data scientists must be able to get their models off of their laptops and deployed within a company’s distributed data pipelines and production infrastructure. In this talk, we will implement an ML model locally and talk about the trouble we can get into taking this to production. Then, against all odds, we will actually deploy the model in a scalable manner to a production cluster. Now that’s a pretty good 10 minutes!
+ + +Daniel (@dwhitena) is a Ph.D. trained data scientist working with Pachyderm (@pachydermIO). Daniel develops innovative, distributed data pipelines which include predictive models, data visualizations, statistical analyses, and more. He has spoken at conferences around the world (Datapalooza, DevFest Siberia, GopherCon, and more), teaches data science/engineering with Ardan Labs (@ardanlabs), maintains the Go kernel for Jupyter, and is actively helping to organize contributions to various open source data science projects.
+ +Standards already exist to improve software readability, but code understandable by a colleague differs from the best code to present to a student. As a scientist, I have often had to jump from mathematics or pseudo-code to a fully fledged implementation, with no chance to gain purchase in an intermediate middle ground. In the last year, I have worked on a Julia blog in computational physics and numerics and have striven to write code comprehensible to someone unfamiliar with the fundamental principles of the algorithm. In this talk, I will display both good and bad examples of documentation and tutorials, as well as guidelines for improvement.
+ + +Theoretical Physics Graduate Student
+ +This talk will give an overview of the Julia extension for VS Code. The extension currently provides syntax highlighting, an integrated REPL, code completion, hover help, an integrated linter, code navigation, integration with the Julia testing infrastructure and integrated support for Weave documents (Julia’s knitr equivalent). +A 30-minute version of this talk would talk about the internals of the extension. We would describe the Julia language server (our implementation of the Microsoft Language Server Protocol) that provides the integration with the VS Code UI. Other topics we would cover are our approach to build a robust and reliable software delivery mechanism that does not depend on the shared Julia package directory, our custom parser that is used in the language server and the developments currently being made to provide actionable parse-time formatting and linting hints, as well as any other features we might add between now and JuliaCon. +Links: +https://github.com/JuliaEditorSupport/LanguageServer.jl https://github.com/JuliaEditorSupport/julia-vscode https://github.com/ZacLN/Parser.jl
+ + +London based Economist
+ +TheoSea (for THEOry SEArch) is a Julia meta-program that discovers compact theories from data if they exist. It writes candidate theories in Julia and then validates: tossing the bad theories and keeping the good theories. Compactness is measured by a metric, such as the number of space-time derivatives. A theory can consist of more than one well-formed formula over a mathematical language. The underlying algorithm is optimal in terms of compactness, although it may be combinatorially explosive for non-compact theories. TheoSea is now working on re-discovering the source-free Maxwell equations and the wave equation of light. There are many applications.
+ + +https://www.linkedin.com/in/mark-stalzer-97254a/
+ +Qb@ll is an open source density functional theory package being developed at Lawrence Livermore National Lab. Present work focuses on efficient time integration methods, with the aim of substantially increasing the timescales accessible in simulations of electron dynamics. Qb@ll is several hundred thousand lines of C++, Fortran, and Perl. Exploring new methods directly in the code base is extremely developer-time inefficient. Simultaneously, rigorous exploration of relevant methods is highly computationally intensive, precluding the use of traditional high-productivity languages. Screening new methods in Julia has proven highly effective, even accounting for the time to learn the language and implement a small code to explore electron wave function integration.
+ + +Jane is a graduate student in computational materials physics enrolled at Caltech. She is interning at Lawrence Livermore National Lab, where she is working with Xavier Andrade on methods for and applications of density functional theory.
+ +Function return type annotations were added over a year ago and have seen some usage in Base but little in user-land. This talk will describe how they are implemented and discuss how ResultTypes.jl uses them to great effect.
+ + +Eric is co-leading Invenia’s transition to Julia and designing the building blocks for Invenia’s Energy Intelligence System.
+ +A large part of data science is in the gathering of data, and in solving the 2 language problem, it should be no surprise that Julia is great for that part of the workflow. In this talk, we will discuss how to combine a set of packages (HTTP.jl, Gumbo.jl, Cascadia.jl) to easily develop and deploy a web scraping strategy. We will see how Julia’s high level language features make it easy to interactively develop such projects, and at the same allow deployment into a distributed cluster for scraping at scale.
+ + +Avik is the author of Julia’s integration with Java and various other packages. One of his hobbies is to make Julia a first class language on the Raspberry Pi.
+ +WebIO acts as a small Julian bridge between browser-based UIs to Julia such as IJulia, Atom, Blink and Mux, and packages that wish to output rich, interactive widgets. This means graphics packages don’t have to depend on IJulia or Atom or Blink etc to create widgets. Instead they only depend on WebIO and use its abstractions. Widgets written with WebIO once will work on all the above interfaces. Some features are:
+I work on various Julia projects. My interests are mainly in interactive UIs.
+ +© 2014-2020 JuliaCon.org All rights reserved. + Fork this site on Github or + open a bug report.
+ ++ JuliaCon 2018 takes place at the Bloomsbury campus at UCL, which is located to the North of central London. + There are a large number of hotels, bed and breakfast, and student halls in close proximity. + The purpose of this guide is not to make specific recommendations, but to provide an overview of the options and approximate pricing. +
+ +There are a numerous high-end hotels located nearby, expect room rates of 300-400GBP/night.
+A number of properties line Euston Road which runs East-West between Euston and St. Pancras, just to the North of UCL's Bloomsbury campus. Rates are typically 80-120GBP/night.
+There are also some properties located to the South and East of Bloomsbury, each of which are approximately five minutes walk from the campus. Rates are typically 100-150GBP/night.
+There are a large number of independently run bed and breakfast properties located around Bloomsbury with large clusters located on Gower Street + (immediately adjacent to UCL's campus) and Cartwright Gardens (five to ten minutes walk). +
+These properties typically offer more basic accommodation, but this varies signficantly between establishments. Rooms can be found from 60-100GBP/night.
+UCL offers individual and group bookings of its student accommodation during the summer holidays. + A brochure lists the available options, + which are priced from 40-60GBP/night and can be booked online. +
+Accommodation is basic but safe and functional. Note that some locations do not provide en-suite facilities. + The majority of the properties are located within fifteen minutes walk of UCL's campus, with the exception of Max Rayne/Ifor Evans + (20 minutes via the Northern Line from Camden Town to Euston station), and Goldsmid House (15 minutes via the Victoria Line from Victoria to Warren Street). + James Lighthill House and Frances Gardner/Langton Close are also located a little further from UCL. +
+ +
+
+ + + Stanford University and Julia Computing + +
+Are you new to Julia?! This beginners’ tutorial should be accessible to anyone with technical computing needs and some experience with another language. We will show you why Julia is special, demonstrate how easy Julia is to learn, and get you writing some Julia code. +
+
+
+ + + Fugro Roames + +
+Julia focuses on speed and user productivity, due in part to its metaprogramming capability. This workshop arms you with the knowledge to create fast, generic and easy-to-use APIs using techniques including multiple dispatch, recursion, traits, constant propagation, macros, and generated functions. +
+
+
+ + + Julia Computing, Koç University, and University College London + +
+Machine Learning has become one of the hottest research and industry areas over the last few years; we believe Julia is the strongest contender to become the language for Machine Learning and in this tutorial we will give a flying start to train/deploy models and use of the power that Julia brings. +
+
+
+ + + Imperial College, London + +
+This workshop brings together 4 speakers on different topics in numerical analysis, to demonstrate the strengths of Julia’s approach to scientific computing in atomistic simulations, function approximation, differential equations, fast transformations, validated numerics, and linear algebra. +
+
+
+ + + University of California, Berkeley + +
+This workshop will introduce the Queryverse family of packages, a unified data science stack on julia. It provides tools for file IO, data querying, visual data exploration and statistical plotting. It also integrates with a large number of other julia packages. +
+
+
+ + + UC Irvine and MIT + +
+Climate scientists solve fluid dynamics PDEs. Biologists solve reaction-diffusion PDEs. Economists solve optimal control PDEs. But solving PDEs is hard! Where do you start? This workshop gives a broad overview of the Julia package ecosystem and shows how to tie it together to solve these problems. +
+
+
+ + + MIT Sloan + +
+JuMP is an award-winning DSL for mathematical optimization that has quickly become the gold-standard for its simplicity, performance, and versatility. A major overhaul of JuMP will be finalized during the JuMP-dev workshop in June, so it is the perfect time for an updated tutorial and feature demo. +
+
+
+ + + Julia Computing + +
+A hands on workshop demonstrating the use of natural language processing tools in Julia. Working with textual data, we will discuss methods for data collection, parsing, pre-processing, embedding, classification and deep neural networks. +
+
+
+ + + + +
+JuliaPro is all set for a huge makeover post Julia 1.0 release, this talk is all about revealing the new features that will be included in the next generation of JuliaPro.
+
+
+ + + + +
+Language developers are torn between the need to quickly iterate on language designs and the need to prove that those designs can be efficiently implemented. I’ll show that Julia neatly captures many of the proposed solutions to this dilemma, making it a compelling platform for language development.
+
+
+ + + + +
+In this talk I will describe the past, present and the future (in the context of recent changes to sequencing technology and genome assembly techniques) of BioJulia, and how we are working towards our mission of provide a performant, human-friendly bioinformatics infrastructure.
+
+
+ + + + +
+Julia is the best language one can do science with. It combines high performance with intuitive & simple code, and allows 1-to-1 correspondence between code and scientific algorithm. I will present an overview of the packages of the JuliaDynamics GitHub org. as examples that justify this claim.
+
+
+ + + + +
+Thanks to Julia’s speed and expressiveness, our very small team (1 developer!) was quickly able to create an ecosystem of Julia libraries for state-of-the-art automatic analysis of drug mixtures using nuclear magnetic resonance (NMR) spectroscopy data.
+
+
+ + + + +
+Julia is my scientific computing programming language of choice to implement my mathematical model of Burkitt lymphoma, a highly aggressive disease plaguing children in Africa. This talk will appeal to people interested in solving Mathematical Biology applications with Julia.
+
+
+ + + Fugro + +
+Fugro Roames provides automated extraction of geointelligence at scale. I’ll discuss how we are using Julia in our machine learning pipeline to identify buildings, roads, trees, and other objects in unstructured point cloud data, and how we deliver billions of points without human intervention.
+
+
+ + + Sorbonne Université + +
+MIToS is a package developed for the analysis of protein sequence and structure. It allows fast and flexible calculation of conservation and coevolution scores and helps to analyze them. It has been used in a large dataset to understand evolutionary signals due to protein structures.
+
+
+ + + + +
+Bayestesting.jl is a Julia package that implements a new Bayesian hypothesis testing procedure that does not suffer from the problems inherent in both the standard Bayesian and frequentist approaches, and is easy to use in practice. Of interest to anyone who does any statistical hypothesis testing.
+
+
+ + + + +
+Learn how to turn your software into a portable application you can compile, distribute - and sell - anywhere! Julia is great for building robust, cross-platform software. In April, I published the first-ever app on the Mac App Store written entirely in Julia. Learn how you can do the same!
++ + University of Cambridge + +
+We introduce recent developments in Turing.jl — a probabilistic programming language. Similar to Stan, Turing provides a black box tool for Bayesian inference. Turing provides researchers experts with a research toolbox for implementing, investigating and benchmarking new or composed algorithms.
+
+
+ + + + +
+In this talk I first present the hurdles and challenges associated with teaching a course with a large cohort using Julia while still in development. I then move on to present a variety of unique perspectives on the presentation of elementary statistical concepts via short and concise code snippets.
+
+
+ + + Eindhoven University of Technology + +
+Scientific modeling concerns a continual search for better models for given data sets. This process can be elegantly captured in a Bayesian inference framework. ForneyLab enables largely automated scientific design loops by deriving fast, analytic algorithms for approximate Bayesian inference.
+
+
+ + + MIT Computer Science and Artificial Intelligence Laboratory + +
+Index notation (Einstein summation) is an elegant representation for array operations, powering several recent high-level compilers for array/tensor algebra. Attend to enjoy a programmer-centric explanation of index notation, its generalizations, and how it will revolutionize array library design!
+
+
+ + + + +
+Some people swear by them. Other, at them. But every language has one. Python has SQLAlchemy, Java has JOOQ, .NET has Entity, Ruby has ActiveRecord. Now Julia has SearchLight. The SearchLight ORM provides a powerful DSL which makes working with SQL databases more productive, secure and fun.
+
+
+ + + + +
+Multi-threading in Julia is an excellent feature to speed up Monte Carlo simulations, e.g. for Asian option pricing. However, if you are not careful how you generate pseudo random numbers you can get wrong results or have your code run slowly. I discuss how one can avoid both problems.
+
+
+ + + Julia Computing, Inc. + +
+The Circuitscape rewrite in Julia provides a 4-8x benefit in speed and scalability over the old Python package . We show the specific benefits of Julia over Python and how to write an end-to-end application purely in Julia, from native Julia solvers to packaging and shipping.
+
+
+ + + U of Copenhagen + +
+Ecological analysis draws upon many different tools - geographic, phylogenetic, bioinformatic and simulation packages and a wide range of statistics. Most ecologists use R, but its package ecosystem is severely fragmented. EcoJulia is a framework to bring cohesive ecological data analysis to Julia.
+
+
+ + + San Francisco Bay Area + +
+The talk shows how to implement some of the best-known attacks on real-world cryptography - in Julia! To break crypto is to solve mathematical puzzles, and it is valuable as a technical exercise, as well as an educational experiment for Julia. Few knows how to actually break crypto, want to see how?
+
+
+ + + + +
+
+
+ + + Epiq Solutions + +
+Julia has great potential for signal processing, but it’s DSP.jl package is missing a fundamental filter design algorithm: “remez”, also known as the Parks-McClellan algorithm. I’m going to talk about the algorithm, review efforts to implement it in Julia, and compare it with what’s in Scipy.
+
+
+ + + University of Cologne + +
+I will share my experience on how Julia can improve numerical physics research. This will provide evidence for the claim that Julia can replace Fortran/C++ as workhorses in science. Also I’ll introduce MonteCarlo.jl, a new package for conducting (quantum) Monte Carlo simulations of physical systems.
+
+
+ + + Fugro Roames + +
+Data comes in all shapes and sizes. While Julia’s built-in arrays are wonderful for dealing with flat or “flattish” data - here I’ll introduce some strategies and tools for dealing with more complex nested data structures, the split-apply-combine paradigm, and working with relational data (tables).
+
+
+ + + University of South Brittany + +
+
+
+ + + Domo + +
+At Domo we see a LOT of data. Like, Fortune-500-sized automated pipelines of business-critical data kind of data. And now we’re turning to Julia to get smart about all that data. While deploying pre-1.0 may sound risky, Domo is no stranger to blazing trails in search of the right tool for the job.
+
+
+ + + Ministry of Social Development, Mexico + +
+Political data is widely available in the internet but non-informative at all. I use Julia capabilities to extract the information from the Mexican Senate, transform it to a temporal network and get insights from the dynamics of the system.
+
+
+ + + + +
+Julia’s basic Logging package is sufficient for console logging but lacks the features necessary for monitoring large, multi-component systems and cloud applications. This talk will attempt to convince you to use Memento instead and demonstrate its strengths.
+
+
+ + + + +
+Before Julia, it was not possible, starting from scratch, for one person to make significant progress writing a tool that can compete with Wolfram on a reasonable time scale. But, the many advantages of Julia, for instance syntactic macros and access to the syntax tree, put this goal in reach.
+
+
+ + + Relational AI + +
+In designing a new language for technical computing, we believe the designers of Julia have accidentally created a great language for systems programming. We explain how efficient, low-level data structures like B+-trees can be implemented in high-level Julia code, with help from a recent package.
+
+
+ + + Warsaw School of Economics + +
+Have you ever wondered what is faster - a supercomputer or a computational cluster in the AWS cloud? Do you want to know what is the easier option to run your massively parallel Julia program? In this presentation you will see how a massively parallel Julia scales with the cluster size increase.
+
+
+ + + Julia Computing + +
+Harness your superpower for good and advocate for public policy issues that are important to you. I’ll tell the story about how I used a cell phone video and a Julia notebook to become part of a local movement for improved bike safety in the city of Pittsburgh.
+
+
+ + + The National Institute of Engineering, Mysore + +
+Minecraft is arguably one of the most popular video games. The sandbox game is successful because it promotes building and creating from imagination. The PiCraft package allows manipulation of the Minecraft world. Programming in Julia we build amazing things like Mobius strips and Aztec Temples.
+
+
+ + + + +
+Julia’s JIT-compilation needs to run on each restart, and the compilation delay can slow development of large projects. I will describe a package, Revise.jl, that allows you to do more testing and debugging in a single Julia session.
+
+
+ + + Rutgers University + +
+Real-world data comes to you in tables full of strings, dates, numbers, etc. To analyze this data you often need to wrangle it into a numerical array. The “formula” DSL is a powerful tool to express these transformations, inspired by R but supercharged with Julia’s unique strengths.
+
+
+ + + KLS Gogte Institute of Technology, Belgaum + +
+Welcome to the exciting world of Brain Computer Interface with Internet of Things. With our project we have made an attempt to provide voice to the voiceless and capability to the incapable (paralyzed) with the help of wonderful programming language known as Julia.
+
+
+ + + + +
+Sailing craft experience a range of environmental conditions in their voyages across the seas. I show how Julia can be used to model the weather, compare weather scenarios and optimise the route whilst avoiding the structural failure of the craft and to thus reduce cost and crew injury.
++ + Universidad Nacional Autonoma de Mexico andUniversidad Nacional Autonoma de Mexico + +
+We approximate a function rigorously with Julia: find a Taylor series that is close, using automatic differentiation, and bound the resulting error using intervals, giving a “Taylor model”. We use this to get guaranteed approximate solutions of ordinary differential equations in the form of tubes.
+
+
+ + + + +
+Sophisticated tools are required to accurately estimate modern economic models, in the face of unprecedented macroeconomic conditions. The tempered particle filter is a novel method for filtering nonlinear state space models, surpassing conventional tools in accuracy and flexibility. This talk wi...
+
+
+ + + + +
+JuliaDBMeta’s macros provide a simple syntax to select, filter, map, group and transform JuliaDB data tables for in memory or out-of-core processing. Plots based visualizations can be incorporated in the pipeline. InteractBase provides a graphical interface to define and compose these opera...
+
+
+ + + The University of Manchester + +
+Modern networks often store the relationship between entities with time stamps. It is difficult to model and study the evolving nature of such network using traditional graph software package. We present EvolvingGraphs.jl, a Julia software package for analysing time-dependent networks.
+
+
+ + + + +
+
+
+ + + + +
+Parameter estimation is the problem of accurately determining the parameters of a dynamic model. I plan to introduce DiffEqBayes.jl, a package for solving these problems using bayesian techniques.
+
+
+ + + + +
+Big data mass in fields like Bioengineering needs fast computations and simplified operations on complex geometric models. LARLIB.jl is a library for efficient solid modeling operations that works on non-manifold cases with a compact representation that permits fast computations and operations.
+
+
+ + + Kevala Analytics + +
+For decades, conservationists have captured photographs of whales and their flukes (tails) in the open water. Can these images be used to accurately identify whale species? In this talk, see one implementation of an image recognition tool using Julia that may aid global whale conservation efforts.
+
+
+ + + Julia Computing + +
+Have you ever wondered why 0.1 > 1//10, 1*pi < pi or 10^16+1 > 1e16+1? I will explain how equalities and inequalities in Julia work across different numeric types.
+
+
+ + + + +
+Research and development pulls together disparate tools and creates seamless product. Julia is an integrated R&D platform: it can command an instrument, e.g. an android phone, call existing C libraries, perform complex scripting and analysis. But best of all, it can unit-test the whole ordeal.
+
+
+ + + University of California, Irvine + +
+Drug development costs $1.2billion over 12 years. Clinical trial simulations, using PKPD models, de-risk this investment. Simulations help narrow-down target patient, dosing schedule and trial size choices. PKPDSimulator.jl is a Julia package for trial simulation.
+
+
+ + + + +
+In the proposed talk an efficient root finding algorithm is presented, which can determine whole high-dimensional submanifolds (points, curves, surfaces…) of the roots of implicit non-linear equation systems, even in cases, where the number of unknowns surpasses the number of equations.
+
+
+ + + Chalmers University of Technology + +
+Julia 1.0 comes with a brand new package manager, currently called Pkg3. Pkg3 was redesigned from scratch to solve a number of fundamental problems with the old package manager. This talk discusses the decisions we made to ensure that Pkg3 allows the Julia package ecosystem to grow and succeed.
+
+
+ + + + +
+Julia’s built-in numeric and datetime types are very good. Sometimes we need better. We introduce SaferIntegers, ArbNumerics and TimesDates for nanosecond resolution.
+
+
+ + + Etsy + +
+Etsy relies heavily on experimentation to improve our decision-making process. In this talk, I will present how Etsy handles data peeking and how we use Julia to help us investigate and assess the problem on our platform.
+
+
+ + + Julia Computing, Inc. + +
+Over the past year Julia Computing has released a new version of JuliaBox. It was designed to be not just a hosted notebook service but also to let users deploy, scale and share their julia code. This talk describes how we achieve this and other new features.
+
+
+ + + U of Toronto + +
+Recent work in machine learning and deep reinforcement learning uses self-tuning optimization methods which utilize higher-order gradients. Higher-order automatic gradients are challenging to implement correctly, even in Tensorflow and PyTorch. I show how to do this using Flux.jl.
+
+
+ + + GTRI + +
+LightGraphs defines abstractions to implement for any graph or network. Instead of re-inventing the wheel, we can share existing algorithms and functions within the ecosystem. We will live-code a new graph type. Attendees will learn to extend JuliaGraphs with a custom graph type for any application.
+
+
+ + + + +
+We present the package “BoltzmannMachines.jl”: Different types of restricted Boltzmann machines serve as flexible building blocks for our Julia-native implementation of multimodal deep Boltzmann machines, a generative model for unsupervised deep learning on composite or partitioned data sets.
+
+
+ + + MIT + +
+Cassette is a tool for injecting user-defined code transformation passes into Julia’s JIT compilation cycle, enabling normal Julia packages to analyze, optimize, and modify Cassette-unaware Julia programs via both low-level IR transformation and high-level dispatch using Cassette’s context types.
+
+
+ + + + +
+The focus of this talk is DataDeps.jl – BinDeps for Data – Repeatable Data Setup for Replicable Data Science. How to manage data dependencies to ensure any script can be executed by others. The secondary topic is what comes next: data ingestion, with a focus on NLP, though that generalizes.
+
+
+ + + U of Cambridge + +
+Our new reaction reader tool is an attempt to automate the boring parts of biochemical modelling (transcribing equations). The user can now spend more time actually analysing those models! Also makes your code prettier.
+
+
+ + + Gandalf Software, Inc. + +
+String performance is important in many areas, such as parsing text formats such as JSON, CSV, or bioinformatics data, for NLP (natural language processing), and for interfacing with other languages/libraries that use other encodings than UTF-8. This talk will discuss the JuliaString “ecosystem”.
+
+
+ + + + +
+This talk will showcase what is possible with the JuliaGeo related packages, with the aim to get you started if you want to do geospatial analysis in Julia. Making full use of the strengths of Julia, examples are shown of that would be either too slow or too much work in other languages.
+
+
+ + + Cambridge University + +
+Latexify.jl allows you to create and render LaTeX code from not only simple types, but also arrays and even systems of equations. In this talk, I will introduce what Latexify.jl can do, how Julia’s metaprogramming makes it possible and how the underlying philosophy can be leveraged for other things.
+
+
+ + + GTRI + +
+The JuliaGraphs ecosystem has expanded this year, with new innovations in abstract representations and modularity. We discuss these improvements, highlighting the effects of changes in Julia 0.6 and 0.7 which affected the design of the JuliaGraphs ecosystem.
+
+
+ + + + +
+Deep neural networks can be highly useful. Nonetheless, some problems require structured programming elements such as variables, conditional execution, and loop clauses. We present a Julia framework that supports gradient based learning even when such programming elements are included in a model.
+
+
+ + + Julia Computing + +
+Julia Computing and EkStep have launched an initiative to train 500k individuals in the field of AI. Come hear how we’re designing the courses and delivery.
+
+
+ + + + +
+My research group uses Julia to solve large-scale industrial inverse problems in geophysics. These are rich computational problems involving differential equations and optimization. I’ll explain how we’ve used Julia to make fast, modular and scalable production geophysical inversion code.
+
+
+ + + University of Edinburgh + +
+Can a shiny new language like Julia easily be added to a mature codebase? Yes it can! Come hear about my experience writing Julia code for Madagascar, an open-source software suite for geophysics. Be prepared for repeated abuse of ccall, metaprogramming and pipelines, but little geophysics (phew!).
+
+
+ + + + +
+Optimal dispatch of pumped storage is an important mechanism when optimizing a portfolio of energy assets with regard to its exposure to the electricity market. We present a solution to this problem in Julia and compare its advantages to some existing application that we use in our everyday work.
+
+
+ + + Julia Computing, Inc. + +
+We have many tools to provide some answers when analyzing Julia programs – code_warntype, @profile, VS Code workspace – but many more questions. Let’s explore a new experience for understanding Julia code!
+
+
+ + + + +
+You just created an awesome new Julia package – congratulations! How can you show it off to potential users (many of whom may not have used Julia yet)? Create an online, interactive demo!
+
+
+ + + MIT + +
+Earth systems are simulated using numerical models of increasing resolution that play a key role in predicting climate. This talk presents a Julia framework that will help educators and researchers leverage these models via an intuitive and scalable representation of gridded Earth variables.
+
+
+ + + PTScientists + +
+Julia might be a secret weapon for the next chapter of the New Space revolution. This talk will present the roadmap for the JuliaAstro and JuliaSpace organizations and demonstrate how Julia can be used to combat the current complexity crisis and enable the next generation of space explorers.
+
+
+ + + Lund U + +
+Are you interested in high performance code that is also easy to use? This talk will showcase how to price exotic financial derivatives, without having to compromise between speed and code readability.
+
+
+ + + Melbourne, Australia + +
+RecSys is based on predicting the best item set for a user. I used Julia in a real-time solution with Genie, DataFrames and XGBoost integrated with a Search Engine. As result, it helped my DS team to deliver impacting results processing +100,000 features for a large set of jobs in incredible 250ms!
+
+
+ + + + +
+
+
+ + + + +
+TIM (Tangent Information Modeller) is a unified large-scale forecasting system written first in C++ and then in Julia. The key advantages in doing so will be shared covering both the computational and architectural aspects ranging from the engine kernel all the way up to its REST API with examples.
+
+
+ + + + +
+Julia’s multiple dispatch and generic functions lets you reuse code, not just for computing results, but also to visualize how the algorithm works and even prove formal correctness of an implementation. I’ll show this for parallel prefix, a fundamental algorithm of parallel computing.
+
+
+ + + Domo + +
+Client and server web interactions are at the heart of most modern applications, Julia and otherwise. Web APIs open doors for cross-language and service interoperability and HTTP.jl aims to provide a robust, modern foundation for Julia programs needing request or server capabilities.
+
+
+ + + U of Amsterdam + +
+Volatility modeling lies at the heart of much of financial risk management. The workhorse model in this field is the GARCH model, along with its various extensions. The talk describes a package that the author is developing to bring these models to Julia.
+
+
+ + + Caltech/Lawrence Livermore National Lab + +
+
+
+ + + + +
+In this talk I introduce a new approach to authoring highly polished interactive data visualizations on the web with Julia. Such visualizations historically been difficult to create without writing custom Javascript.
+
+
+ + + University of Glasgow + +
+Global biodiversity loss is reaching critical levels. Working with 200M plant records, an evolutionary tree of 30k of plant species and global climate reconstructions to understand this process is a huge computational challenge, and one that requires many of Julia’s “ecosystems” working together.
+
+
+ + + + +
+The need for speed: SyMBOL is a model that analyses bank failures. The core of SyMBOL is a Monte Carlo simulation with correlated random shocks and it was written in C. Given the parallel computing capabilities of Julia and a different setup, we were able to reduce the computation time by 50%.
+
+
+ + + IBM Dublin Research Lab + +
+CombineML main feature is to provide a framework for seamless ensembling of existing machine learning implementations from scikitlearn, caret, and Julia. It supports the following ensembles: stack, voting, and best. It is a heterogeneous ensemble driven by a uniform machine learner API designed f...
+
+
+ + + + +
+Analyzing mechanical testing data can be tricky, especially for those conducting interdisciplinary research (e.g. biomechanics) who may not have in-house code. We are using Julia to develop an open source software package to make this process simpler and more reproducible.
+
+
+ + + + +
+Virtual Reality plays the leading role on the new media revolution with Light Field reconstruction as a common technique for content generation.High industrial interests make this technique hard to understand and implement, I will present a novel method to reconstruct the depth of objects in images.
+
+
+ + + Caltech/Lawrence Livermore National Lab + +
+How can we make Julia more inclusive of and accessible to new users from all backgrounds and experience levels? We want to create fantastic teaching materials that don’t assume a ton of prior knowledge. I’ll share what we’ve done so far to make Julia more accessible and how you can help!
+
+
+ + + + +
+Flux is a new machine learning library that’s easy and intuitive to use with state-of-the-art performance. I’ll show how we achieve this using Julia’s advanced features alongside modern compiler and language technology, as well as cool things that people are doing with Flux.
+
+
+ + + Konstanz U + +
+Value Function Iteration (VFI) is a technique widely used by economists to solve dynamic programming problems. VFI is conceptually simple, but computationally very taxing with complex models or high dimensions. However, using Julia and GPUs, it is possible to run VFI algorithms up to 150x faster.
+
+
+ + + + +
+Building and serving binary dependencies for Julia has been a challenging problem in the past. With BinaryBuilder.jl and BinaryProvider.jl, we present a set of powerful and straightfoward tools to compile, serve and load binary dependencies for packages on all platforms Julia supports.
++ + University of Copenhagen + +
+People doing numerical computing are greedy. They want results now and accurately, and we have been ready to accept loss of readability and extensibility to get it. As a result, the elementary functions we take for granted in paper math are often coded in low-level languages. We can do better.
+
+
+ + + + +
+Numerical optimization is used in many scientific fields such as signal processing, machine learning, finance and control. We propose a new Julia package providing an intuitive language for defining and solving possibly nonconvex, nonsmooth optimization problems using natural mathematical notation.
+
+
+ + + Universidad de Buenos Aires/CONICET and and + +
+The objective of this talk is to introduce GSReg.jl, a new all-subset-regression package to perform High Performance Computing in econometrics using Julia. GSReg.jl runs 4 to 100 times faster than similar packages and comes with a simplified GUI to allow smooth-transitions for R and Stata users.
+
+
+ + + Domo + +
+What’s new in the data framework package powering some of the most popular data packages in Julia? Come learn about advancements in flexibly typed schemas, querying functionality directly integrated with IO, and automatic data transfer parallelism.
+
+
+ + + + +
+Julia’s design enables efficient idiomatic code optimizations. I will detail Julia’s main optimizations and explain under which conditions on the code Julia’s JIT compiler can perform them. I will also show how users meet these conditions, using static and dynamic analyses of popular Julia packages.
+
+
+ + + Julia Computing + +
+JuliaDB is a pure Julia analytical database. It support a number of features: releational database operations, parsing text files, parallel computing, tabular data storage and compression. +In this talk you will learn about the underlying building block packages that make up JuliaDB. This talk sho...
+
+
+ + + + +
+The remote memory access routines from MPI-3 are a natural fit for the Julia programming model. We show how to build a custom IO and distributed array on top of them, and how this system can help with interfacing with both Julia native parallelism and external MPI-based libraries.
+
+
+ + + + +
+
+
+ + + + +
+JuliaDB integrates with OnlineStats to provide scalable single pass algorithms (that can run in parallel) for statistics and modeling on big data. This integration allows you to transform small-scale analyses into out-of-core computations for huge datasets without changing your code.
+
+
+ + + King's College London + +
+Atomistic simulation needs custom models, to approximate through hard O(N!) scaling of the underlying physical equations. Julia is a natural language to express such physical abstractions in. I will show how you can contribute to materials research with Julia and a fistful of 1960s PhysRevs.
+
+
+ + + + +
+Anyone who works in a technical field has heard something like this from family or friends: “Oh, I was never any good at maths at school.” My job is to set targeted, achievable mathematics homework so that no child ends up feeling this way. Let me tell you how I use Julia to do this.
+
+
+ + + + +
+The Trilinos library features modern iterative solvers for large linear systems. Using the Tpetra library, it can exploit hybrid parallelism and GPUs. We present an overview of the current status of the package that makes this functionality available to Julia.
+
+
+ + + + +
+Highly parallelizable black box combinatorial optimization algorithm that only relies on function evaluations, and which returns locally optimal solutions with high probability.
+
+
+ + + Julia Computing + +
+Have you ever wondered how or why you might create a custom array? Have you never written struct ___ <: AbstractArray{T,N}? It’s easier than you might expect! I’ll give a motivating example, incrementally define and refine a custom array, and demonstrate how to make it robust and fast.
+
+
+ + + University College London + +
+Julia’s high-level nature and speed helped me to implement an intricate algorithm for converting a set of high-dimensional data into a very compact representation, allowing me to efficiently solve real-world research problems.
+
+
+ + + + +
+With Joulia.jl we developed a package for electricity sector models in Julia, taking advantage of the possibilities to cover all steps of the modeling workflow from data pre-processing, over the algebraic modeling and solution up to the visualization of results in an open-source environment.
+
+
+ + + University of California, Berkeley + +
+The julia extension for Visual Studio Code provides a convenient coding environment for julia development. This talk will highlight key features of the extension.
+
+
+ + + + +
+Parameters.jl provides a macro to decorate type-definitions which adds keyword constructors and default values. When working with instances it has macros to unpack their fields. I will demo its core features, the resulting cleaner code patterns, and the improvements to code maintainability.
+
+
+ + + MIT + +
+Do you want to build Baymax, Data, or Robby the Robot? Do you want a future with more robots for rescue, delivery, and exploration (and fewer C++ linker errors)? I’ll introduce the JuliaRobotics org and show off our work on visualizing, simulating, and controlling a humanoid robot in Julia.
+
+
+ + + + +
+We develop TIM, a computational engine for large-scale forecasting in energy industry covering load, gas, solar and wind. We share our lessons learned when trying to do AOT compilation of TIM and deploying the binary in the cloud. We cover Linux and Windows scenarios.
+
+
+ + + Julia Computing + +
+Computational problems can often be represented as specific types of graphs known as DAGs. That allows an execution framework to execute parts in right order, schedule in parallel, and make optimal use of available resources. We present ideas on which we are building a scalable scheduler for Julia.
+
+
+ + + Budapest University of Technology and Economics + +
+Modelling of stochastic effects in engineering is limited not only by the few existing mathematical methods but also by their low effectivity and high complexity. An easy-to-use Julia package is presented to investigate stochastic linear delayed systems including control and machine-tool vibrations.
+
+
+ + + GERAD, Montréal & INRIA Lille + +
+Increasing the proportion of renewable energy has become a priority for power grids, but their integration requires higher flexibility of consumption times. Using game theory and optimization, we design a framework allowing flexibility and privacy, while reducing costs for both consumer and supplier
+
+
+ + + ETH Zurich, Switzerland + +
+Glaciers and ice caps are projected to dominate global sea level rise up to 2100. To estimate ice thickness maps of such glaciers using mostly surface data, we use a semi-physical forward model combined with a Bayesian inversion scheme. We leverage Julia to allow compute intense MCMC simulations.
+
+
+ + + Dravyaniti Consulting LLP + +
+Life of a Trading strategy is unknown. 'Till how long will this work?'. As markets get more mature, with advent of ML and AI, the designer's job is getting tougher. Using rules to analyse big data by splitting it across Time-Frames, traders can gain significant edges, for all types of traders.
+
+
+ + + University of Luxembourg + +
+Julia accelerates analyses of huge-scale biochemical networks with now more than a million biochemical reactions. Through the open-source high-performance COBRA.jl package, the analysis capabilities of the COnstraint-Based Reconstruction and Analysis community are lifted to another level.
+
+
+ + + British Antarctic Survey + +
+EchoJulia is a software library that is enabling new kinds of fisheries acoustic applications. From big data analysis of ship-based surveys to data collection from ocean gliders, we show how Julia is set to improve ecosystem estimates of Southern Ocean Antarctic Krill.
+
+
+ + + University College London + +
+Handling uncertainty in process design and optimisation is a crucial challenge in current research and in the industry. We believe that Julia has the potential to be used as a comprehensive modelling language to enable designers to develop new systems with greater confidence.
+
+
+ + + Australian Institute for Machine Learning + +
+I will present an approximate maximum likelihood method that encapsulates a gamut of heteroscedastic errors-in-variables regression problems that often arise in computer vision applications. Julia's multiple dispatch and Unicode support facilitates a unique, concise and readable implementation.
+
+
+ + + University of Warwick + +
+Most of the time, neurons in the cortex fire due to randomly arriving inputs. The irregular firing that results is not merely noise, but is thought to play an important role in cortical computation. I show how I have implemented stochastic simulations of this irregular firing in my research.
+
+
+ + + Exegetic Analytics + +
+Bayesian techniques can seem challenging and esoteric. However, they promise a powerful alternative to frequentist statistics, with the possibility of extracting even more useful information from your data. This talk will help you get started with Bayesian analyses.
+
+
+ + + Institute for Economic Forecasting, Romanian Academy + +
+The title of the presentation comes from the my forthcoming book at one of the leading publishers, Academic Press, an imprint of Elsevier. The poster (based on the book) will introduce the audience to state-of-art computational techniques used in economics through examples and applications in Julia.
+
+
+ + + City of London School + +
+The talk is about remote control robots controlled by Julia on a Raspberry Pi. I will show how to do physical computing with Julia using the GPIO pins of the Pi.
+
+
+ + + UNAM + +
+Julia's capabilities are amazing for scientific computing - but how to begin designing your own libraries and packages? With OrthogonalPolynomials.jl, we will showcase the development of a production ready library in 100 lines of code - with a series of video walkthroughs on step by step design.
+
+
+ + + UFPR - Federal University of Paraná + +
+We study the Simplex method, a linear optimization search method. The revised Simplex method was studied and implemented along with the LU update, aiming for the solution of large scale sparse problems. The method was implemented in the Julia Language and tested against available solvers.
+
+
+ + + Karlsruhe Institute of Technology + +
+This poster announces PCE.jl, which is a Julia Package for uncertainty quantification (UQ) using a method called 'polynomial chaos expansion' (PCE). It offers an alternative approach to Monte-Carlo-based UQ, and is also more efficient for certain problem instances.
+
+
+ + + University of Cambridge + +
+Deep Learning's popularity is partly derived from its composability. General probabilistic machine learning is, in fact, just as composable, but technically much more challenging. I present an interesting edge case where life is easy, and discuss how Julia is uniquely positioned to exploit this.
+
+
+ + + University of California, Irvine + +
+Stochasticity (randomness) in biochemical reactions exists. Things diffuse and randomly bump together to bind/unbind. Yet these chemicals form the basis of life. But biological organisms evolve to their surroundings. Have they evolved to use biochemical randomness? I will demonstrate how they do it.
+File not found
+ ++ The site configured at this address does not + contain the requested file. +
+ +
+ If this is your site, make sure that the filename case matches the URL.
+ For root URLs (like http://example.com/) you must provide an
+ index.html file.
+
+ Read the full documentation + for more information about using GitHub Pages. +
+ +
+
+
+
+ 
+
+ + JuliaCon is dedicated to providing a harassment-free conference + experience for everyone, regardless of gender, gender identity and + expression, sexual orientation, disability, physical appearance, body + size, race, age, religion, text editor choice, or tabs vs spaces + preference. We do not tolerate harassment of conference participants + in any form. Offensive or sexual language and imagery is not + appropriate for any conference venue, including formal talks and + networking between sessions. Conference participants violating these + rules may be sanctioned or expelled from the conference (without a + refund) at the discretion of the conference organizers. + + Harassment includes, but is not limited to: +
+ Participants asked to stop any harassing behavior are expected to + comply immediately If a participant engages in harassing behavior, + event organizers retain the right to take any actions to keep the + event a welcoming environment for all participants. This includes + warning the offender or expulsion from the conference with no + refund. Event organizers may take action to redress anything designed + to, or with the clear impact of, disrupting the event or making the + environment hostile for any participants. We expect participants to + follow these rules at all event venues and event-related social + activities. We think people should follow these rules outside event + activities too! +
+ ++ If someone makes you or anyone else feel unsafe or unwelcome, please + report it as soon as possible. Harassment and other code of conduct + violations reduce the value of our event for everyone. We want you to + be happy at our event. People like you make our event a better + place. You can make a report either personally or anonymously. +
+ ++ Please call or message this phone + number: +44 7920402037 or this email address + juliacon@julialang.org + (private group of the committee) + to make a personal report or to discuss any incident that may have + left you uncomfortable. This number and email address will be + continuously monitored for the duration of the event. + + When taking a personal report, our staff will ensure you are safe and + cannot be overheard. They may involve other event staff to ensure your + report is managed properly. Once safe, we'll ask you to tell us about + what happened. This can be upsetting, but we'll handle it as + respectfully as possible, and you can bring someone to support + you. You won't be asked to confront anyone and we won't tell anyone + who you are. + + Our team will be happy to help you contact hotel/venue security, local + law enforcement, local support services, provide escorts, or otherwise + assist you to feel safe for the duration of the event. We value your + attendance. +
+ ++ All talks and workshops for JuliaCon 2018 are streaming live on Youtube. + Recordings of the talks can be seen on the JuliaCon 2018 playlist. +
+
+ + + University of Manchester + +
+Nick Higham is Royal Society Research Professor and Richardson Professor of Applied Mathematics at the + University of Manchester. His research is in numerical linear algebra + and ranges from theory to the development of algorithms and software, with a + focus on accuracy and stability. His book Functions of Matrices: + Theory and Computation (SIAM, 2008) was the first research monograph + on matrix functions and he is editor of the Princeton Companion to + Applied Mathematics (2015). He is a Fellow of the Royal Society, a + SIAM Fellow, and a Member of Academia Europaea. He is a keen expositor and + blogs at http://nickhigham.wordpress.com.
+ +
+ + + Broadcom Inc. + +
+Sophie Wilson is a Broadcom Fellow and Distinguished Engineer. + Her inventions helped to transform the computing landscape. + Sophie and Steve Furber’s development and codesign of the BBC Micro + processor led to their development of the ARM processor; + today the ARM processor powers virtually every mobile phone and tablet in the world. + By 1999, Sophie developed the Firepath SIMD LIW processor, + for which she led the design of the instruction set, and she co-founded Element 14, + which was later acquired by Broadcom. Sophie is a Fellow of the Royal Society, + a Fellow of the Royal Academy of Engineering, a Fellow of the British Computer Society, + a Fellow of the Women’s Engineering Society and an honorary Fellow of Selwyn College, Cambridge. + She has an honorary doctorate of science from Cambridge University.
+ +
+ + + Aviva plc. + +
+Tim Thornham is the Financial Modelling Solutions Director at Aviva. + He is responsible for the development and maintenance of actuarial and + quantitative risk models used across the firm for financial and prudential reporting. + Aviva is the second largest UK insurer and one of Europe’s leading + providers of life and general insurance.
+ +Tim is a qualified actuary and has worked in various roles in consultancies, +insurance companies and in an actuarial software company. Over his career, he +has specialised in actuarial modelling systems implementation, working with many +insurance companies around the world, over nearly 30 years in the industry.
+ +
+ + + MIT + +
+Gilbert Strang was an undergraduate at MIT and a Rhodes Scholar + at Balliol College, Oxford. His Ph.D. was from UCLA and since then he has taught at MIT. + He has been a Sloan Fellow and a Fairchild Scholar and is a Fellow of the + American Academy of Arts and Sciences. He is a Professor of Mathematics at MIT, + an Honorary Fellow of Balliol College, and a member of the National + Academy of Sciences. Professor Strang has published eleven books.
+ +He was the President of SIAM during 1999 and 2000, and Chair of the Joint Policy +Board for Mathematics. He received the von Neumann Medal of the US Association +for Computational Mechanics, and the Henrici Prize for applied analysis. +The first Su Buchin Prize from the International Congress of Industrial and +Applied Mathematics, and the Haimo Prize from the Mathematical Association of +America, were awarded for his contributions to teaching around the world.
+ +
+ + + University of Leeds + +
+Mike is Director of Research Computing at The University of Leeds and +an EPSRC Research Software Engineering Fellow. Previous roles include being +the co-founder of the RSE group at the University of Sheffield and Head of +Research Software Support in the faculty of Engineering and Physical Sciences +at The University of Manchester.
+ +Mike’s entire career has been focused on one thing: +To enable researchers and educators to do computing better.
+ +He is additionally a Principal Investigator on the EU funded OpenDreamKit +project which supports the open source mathematical software ecosystem, +Co-Investigator on the UK national RSE network and has had his name on a +bunch of other grants where he supported software stuff. +He blogs on www.walkingrandomly.com and tweets at @walkingrandomly
+ ++ The Julia Community Prize has been announced. Congratulations + to this years winners: Tim Besard, Katharine Hyatt, Chris Rackauckas and Elliot Saba. +
+ The JuliaCon committee is composed entirely of volunteer organizers + and can be reached at juliacon@julialang.org + with any questions or comments. +
++ JuliaCon 2018 takes place at the Bloomsbury campus at UCL, which is located to the North of central London. + There are a large number of hotels, bed and breakfast, and student halls in close proximity. + Read our guide for an overview of the options and approximate pricing. +
++ JuliaCon is dedicated to providing a harassment-free conference + experience for everyone, regardless of gender, gender identity and + expression, sexual orientation, disability, physical appearance, body + size, race, age, religion, national and ethnic origin, + text editor choice, or tabs vs spaces preference. + We do not tolerate harassment of conference participants + in any form. Offensive or sexual language and imagery is not + appropriate for any conference venue, including formal talks and + networking between sessions. Conference participants violating these + rules may be sanctioned or expelled from the conference (without a + refund) at the discretion of the conference organizers. Our + anti-harassment policy can be found here. +
++ The main conference, including all talks and workshops, will be held at the University College, London. Roberts Engineering Building, Torrington Place, WC1E 7JE, London, UK. Here's a map: +
+ ++ The Welcome Reception (sponsored by Invenia Labs) on the evening of the 8th will be held at the amazing riverside location of the + IET. 2 Savoy Place, WC2R 0BL. +
++ The hackathon on Saturday, the 11th, will take place in the heart of London's startup ecosystem in Shoreditch. + We will meet at the Microsoft Reactor, + 70 Wilson St, EC2A 2DB. +
+
+
+ + + + +
+JuliaPro is all set for a huge makeover post Julia 1.0 release, this talk is all about revealing the new features that will be included in the next generation of JuliaPro.
+
+
+ + + + +
+Thanks to Julia’s speed and expressiveness, our very small team (1 developer!) was quickly able to create an ecosystem of Julia libraries for state-of-the-art automatic analysis of drug mixtures using nuclear magnetic resonance (NMR) spectroscopy data.
+
+
+ + + + +
+Julia is my scientific computing programming language of choice to implement my mathematical model of Burkitt lymphoma, a highly aggressive disease plaguing children in Africa. This talk will appeal to people interested in solving Mathematical Biology applications with Julia.
+
+
+ + + Fugro + +
+Fugro Roames provides automated extraction of geointelligence at scale. I’ll discuss how we are using Julia in our machine learning pipeline to identify buildings, roads, trees, and other objects in unstructured point cloud data, and how we deliver billions of points without human intervention.
+
+
+ + + Sorbonne Université + +
+MIToS is a package developed for the analysis of protein sequence and structure. It allows fast and flexible calculation of conservation and coevolution scores and helps to analyze them. It has been used in a large dataset to understand evolutionary signals due to protein structures.
+
+
+ + + + +
+Bayestesting.jl is a Julia package that implements a new Bayesian hypothesis testing procedure that does not suffer from the problems inherent in both the standard Bayesian and frequentist approaches, and is easy to use in practice. Of interest to anyone who does any statistical hypothesis testing.
+
+
+ + + + +
+In this talk I first present the hurdles and challenges associated with teaching a course with a large cohort using Julia while still in development. I then move on to present a variety of unique perspectives on the presentation of elementary statistical concepts via short and concise code snippets.
+
+
+ + + Eindhoven University of Technology + +
+Scientific modeling concerns a continual search for better models for given data sets. This process can be elegantly captured in a Bayesian inference framework. ForneyLab enables largely automated scientific design loops by deriving fast, analytic algorithms for approximate Bayesian inference.
+
+
+ + + + +
+Some people swear by them. Other, at them. But every language has one. Python has SQLAlchemy, Java has JOOQ, .NET has Entity, Ruby has ActiveRecord. Now Julia has SearchLight. The SearchLight ORM provides a powerful DSL which makes working with SQL databases more productive, secure and fun.
+
+
+ + + + +
+Multi-threading in Julia is an excellent feature to speed up Monte Carlo simulations, e.g. for Asian option pricing. However, if you are not careful how you generate pseudo random numbers you can get wrong results or have your code run slowly. I discuss how one can avoid both problems.
+
+
+ + + U of Copenhagen + +
+Ecological analysis draws upon many different tools - geographic, phylogenetic, bioinformatic and simulation packages and a wide range of statistics. Most ecologists use R, but its package ecosystem is severely fragmented. EcoJulia is a framework to bring cohesive ecological data analysis to Julia.
+
+
+ + + Epiq Solutions + +
+Julia has great potential for signal processing, but it’s DSP.jl package is missing a fundamental filter design algorithm: “remez”, also known as the Parks-McClellan algorithm. I’m going to talk about the algorithm, review efforts to implement it in Julia, and compare it with what’s in Scipy.
+
+
+ + + University of Cologne + +
+I will share my experience on how Julia can improve numerical physics research. This will provide evidence for the claim that Julia can replace Fortran/C++ as workhorses in science. Also I’ll introduce MonteCarlo.jl, a new package for conducting (quantum) Monte Carlo simulations of physical systems.
+
+
+ + + University of South Brittany + +
+
+
+ + + Domo + +
+At Domo we see a LOT of data. Like, Fortune-500-sized automated pipelines of business-critical data kind of data. And now we’re turning to Julia to get smart about all that data. While deploying pre-1.0 may sound risky, Domo is no stranger to blazing trails in search of the right tool for the job.
+
+
+ + + Ministry of Social Development, Mexico + +
+Political data is widely available in the internet but non-informative at all. I use Julia capabilities to extract the information from the Mexican Senate, transform it to a temporal network and get insights from the dynamics of the system.
+
+
+ + + + +
+Julia’s basic Logging package is sufficient for console logging but lacks the features necessary for monitoring large, multi-component systems and cloud applications. This talk will attempt to convince you to use Memento instead and demonstrate its strengths.
+
+
+ + + Warsaw School of Economics + +
+Have you ever wondered what is faster - a supercomputer or a computational cluster in the AWS cloud? Do you want to know what is the easier option to run your massively parallel Julia program? In this presentation you will see how a massively parallel Julia scales with the cluster size increase.
+
+
+ + + Julia Computing + +
+Harness your superpower for good and advocate for public policy issues that are important to you. I’ll tell the story about how I used a cell phone video and a Julia notebook to become part of a local movement for improved bike safety in the city of Pittsburgh.
+
+
+ + + The National Institute of Engineering, Mysore + +
+Minecraft is arguably one of the most popular video games. The sandbox game is successful because it promotes building and creating from imagination. The PiCraft package allows manipulation of the Minecraft world. Programming in Julia we build amazing things like Mobius strips and Aztec Temples.
+
+
+ + + + +
+Julia’s JIT-compilation needs to run on each restart, and the compilation delay can slow development of large projects. I will describe a package, Revise.jl, that allows you to do more testing and debugging in a single Julia session.
+
+
+ + + + +
+Sailing craft experience a range of environmental conditions in their voyages across the seas. I show how Julia can be used to model the weather, compare weather scenarios and optimise the route whilst avoiding the structural failure of the craft and to thus reduce cost and crew injury.
+
+
+ + + + +
+JuliaDBMeta’s macros provide a simple syntax to select, filter, map, group and transform JuliaDB data tables for in memory or out-of-core processing. Plots based visualizations can be incorporated in the pipeline. InteractBase provides a graphical interface to define and compose these opera...
+
+
+ + + The University of Manchester + +
+Modern networks often store the relationship between entities with time stamps. It is difficult to model and study the evolving nature of such network using traditional graph software package. We present EvolvingGraphs.jl, a Julia software package for analysing time-dependent networks.
+
+
+ + + + +
+Parameter estimation is the problem of accurately determining the parameters of a dynamic model. I plan to introduce DiffEqBayes.jl, a package for solving these problems using bayesian techniques.
+
+
+ + + + +
+Big data mass in fields like Bioengineering needs fast computations and simplified operations on complex geometric models. LARLIB.jl is a library for efficient solid modeling operations that works on non-manifold cases with a compact representation that permits fast computations and operations.
+
+
+ + + Kevala Analytics + +
+For decades, conservationists have captured photographs of whales and their flukes (tails) in the open water. Can these images be used to accurately identify whale species? In this talk, see one implementation of an image recognition tool using Julia that may aid global whale conservation efforts.
+
+
+ + + Julia Computing + +
+Have you ever wondered why 0.1 > 1//10, 1*pi < pi or 10^16+1 > 1e16+1? I will explain how equalities and inequalities in Julia work across different numeric types.
+
+
+ + + + +
+Research and development pulls together disparate tools and creates seamless product. Julia is an integrated R&D platform: it can command an instrument, e.g. an android phone, call existing C libraries, perform complex scripting and analysis. But best of all, it can unit-test the whole ordeal.
+
+
+ + + + +
+In the proposed talk an efficient root finding algorithm is presented, which can determine whole high-dimensional submanifolds (points, curves, surfaces…) of the roots of implicit non-linear equation systems, even in cases, where the number of unknowns surpasses the number of equations.
+
+
+ + + + +
+Julia’s built-in numeric and datetime types are very good. Sometimes we need better. We introduce SaferIntegers, ArbNumerics and TimesDates for nanosecond resolution.
+
+
+ + + Etsy + +
+Etsy relies heavily on experimentation to improve our decision-making process. In this talk, I will present how Etsy handles data peeking and how we use Julia to help us investigate and assess the problem on our platform.
+
+
+ + + Julia Computing, Inc. + +
+Over the past year Julia Computing has released a new version of JuliaBox. It was designed to be not just a hosted notebook service but also to let users deploy, scale and share their julia code. This talk describes how we achieve this and other new features.
+
+
+ + + U of Toronto + +
+Recent work in machine learning and deep reinforcement learning uses self-tuning optimization methods which utilize higher-order gradients. Higher-order automatic gradients are challenging to implement correctly, even in Tensorflow and PyTorch. I show how to do this using Flux.jl.
+
+
+ + + U of Cambridge + +
+Our new reaction reader tool is an attempt to automate the boring parts of biochemical modelling (transcribing equations). The user can now spend more time actually analysing those models! Also makes your code prettier.
+
+
+ + + Gandalf Software, Inc. + +
+String performance is important in many areas, such as parsing text formats such as JSON, CSV, or bioinformatics data, for NLP (natural language processing), and for interfacing with other languages/libraries that use other encodings than UTF-8. This talk will discuss the JuliaString “ecosystem”.
+
+
+ + + + +
+This talk will showcase what is possible with the JuliaGeo related packages, with the aim to get you started if you want to do geospatial analysis in Julia. Making full use of the strengths of Julia, examples are shown of that would be either too slow or too much work in other languages.
+
+
+ + + Cambridge University + +
+Latexify.jl allows you to create and render LaTeX code from not only simple types, but also arrays and even systems of equations. In this talk, I will introduce what Latexify.jl can do, how Julia’s metaprogramming makes it possible and how the underlying philosophy can be leveraged for other things.
+
+
+ + + GTRI + +
+The JuliaGraphs ecosystem has expanded this year, with new innovations in abstract representations and modularity. We discuss these improvements, highlighting the effects of changes in Julia 0.6 and 0.7 which affected the design of the JuliaGraphs ecosystem.
+
+
+ + + + +
+Deep neural networks can be highly useful. Nonetheless, some problems require structured programming elements such as variables, conditional execution, and loop clauses. We present a Julia framework that supports gradient based learning even when such programming elements are included in a model.
+
+
+ + + Julia Computing + +
+Julia Computing and EkStep have launched an initiative to train 500k individuals in the field of AI. Come hear how we’re designing the courses and delivery.
+
+
+ + + + +
+My research group uses Julia to solve large-scale industrial inverse problems in geophysics. These are rich computational problems involving differential equations and optimization. I’ll explain how we’ve used Julia to make fast, modular and scalable production geophysical inversion code.
+
+
+ + + University of Edinburgh + +
+Can a shiny new language like Julia easily be added to a mature codebase? Yes it can! Come hear about my experience writing Julia code for Madagascar, an open-source software suite for geophysics. Be prepared for repeated abuse of ccall, metaprogramming and pipelines, but little geophysics (phew!).
+
+
+ + + + +
+Optimal dispatch of pumped storage is an important mechanism when optimizing a portfolio of energy assets with regard to its exposure to the electricity market. We present a solution to this problem in Julia and compare its advantages to some existing application that we use in our everyday work.
+
+
+ + + + +
+You just created an awesome new Julia package – congratulations! How can you show it off to potential users (many of whom may not have used Julia yet)? Create an online, interactive demo!
+
+
+ + + MIT + +
+Earth systems are simulated using numerical models of increasing resolution that play a key role in predicting climate. This talk presents a Julia framework that will help educators and researchers leverage these models via an intuitive and scalable representation of gridded Earth variables.
+
+
+ + + Lund U + +
+Are you interested in high performance code that is also easy to use? This talk will showcase how to price exotic financial derivatives, without having to compromise between speed and code readability.
+
+
+ + + Domo + +
+Client and server web interactions are at the heart of most modern applications, Julia and otherwise. Web APIs open doors for cross-language and service interoperability and HTTP.jl aims to provide a robust, modern foundation for Julia programs needing request or server capabilities.
+
+
+ + + U of Amsterdam + +
+Volatility modeling lies at the heart of much of financial risk management. The workhorse model in this field is the GARCH model, along with its various extensions. The talk describes a package that the author is developing to bring these models to Julia.
+
+
+ + + + +
+In this talk I introduce a new approach to authoring highly polished interactive data visualizations on the web with Julia. Such visualizations historically been difficult to create without writing custom Javascript.
+
+
+ + + + +
+The need for speed: SyMBOL is a model that analyses bank failures. The core of SyMBOL is a Monte Carlo simulation with correlated random shocks and it was written in C. Given the parallel computing capabilities of Julia and a different setup, we were able to reduce the computation time by 50%.
+
+
+ + + IBM Dublin Research Lab + +
+CombineML main feature is to provide a framework for seamless ensembling of existing machine learning implementations from scikitlearn, caret, and Julia. It supports the following ensembles: stack, voting, and best. It is a heterogeneous ensemble driven by a uniform machine learner API designed f...
+
+
+ + + + +
+Analyzing mechanical testing data can be tricky, especially for those conducting interdisciplinary research (e.g. biomechanics) who may not have in-house code. We are using Julia to develop an open source software package to make this process simpler and more reproducible.
+
+
+ + + + +
+Virtual Reality plays the leading role on the new media revolution with Light Field reconstruction as a common technique for content generation.High industrial interests make this technique hard to understand and implement, I will present a novel method to reconstruct the depth of objects in images.
+
+
+ + + Caltech/Lawrence Livermore National Lab + +
+How can we make Julia more inclusive of and accessible to new users from all backgrounds and experience levels? We want to create fantastic teaching materials that don’t assume a ton of prior knowledge. I’ll share what we’ve done so far to make Julia more accessible and how you can help!
++ + University of Copenhagen + +
+People doing numerical computing are greedy. They want results now and accurately, and we have been ready to accept loss of readability and extensibility to get it. As a result, the elementary functions we take for granted in paper math are often coded in low-level languages. We can do better.
+
+
+ + + Universidad de Buenos Aires/CONICET and and + +
+The objective of this talk is to introduce GSReg.jl, a new all-subset-regression package to perform High Performance Computing in econometrics using Julia. GSReg.jl runs 4 to 100 times faster than similar packages and comes with a simplified GUI to allow smooth-transitions for R and Stata users.
+
+
+ + + Domo + +
+What’s new in the data framework package powering some of the most popular data packages in Julia? Come learn about advancements in flexibly typed schemas, querying functionality directly integrated with IO, and automatic data transfer parallelism.
+
+
+ + + + +
+
+
+ + + King's College London + +
+Atomistic simulation needs custom models, to approximate through hard O(N!) scaling of the underlying physical equations. Julia is a natural language to express such physical abstractions in. I will show how you can contribute to materials research with Julia and a fistful of 1960s PhysRevs.
+
+
+ + + + +
+Anyone who works in a technical field has heard something like this from family or friends: “Oh, I was never any good at maths at school.” My job is to set targeted, achievable mathematics homework so that no child ends up feeling this way. Let me tell you how I use Julia to do this.
+
+
+ + + + +
+The Trilinos library features modern iterative solvers for large linear systems. Using the Tpetra library, it can exploit hybrid parallelism and GPUs. We present an overview of the current status of the package that makes this functionality available to Julia.
+
+
+ + + + +
+Highly parallelizable black box combinatorial optimization algorithm that only relies on function evaluations, and which returns locally optimal solutions with high probability.
+
+
+ + + University College London + +
+Julia’s high-level nature and speed helped me to implement an intricate algorithm for converting a set of high-dimensional data into a very compact representation, allowing me to efficiently solve real-world research problems.
+
+
+ + + + +
+With Joulia.jl we developed a package for electricity sector models in Julia, taking advantage of the possibilities to cover all steps of the modeling workflow from data pre-processing, over the algebraic modeling and solution up to the visualization of results in an open-source environment.
+
+
+ + + + +
+Parameters.jl provides a macro to decorate type-definitions which adds keyword constructors and default values. When working with instances it has macros to unpack their fields. I will demo its core features, the resulting cleaner code patterns, and the improvements to code maintainability.
+
+
+ + + + +
+We develop TIM, a computational engine for large-scale forecasting in energy industry covering load, gas, solar and wind. We share our lessons learned when trying to do AOT compilation of TIM and deploying the binary in the cloud. We cover Linux and Windows scenarios.
+
+
+ + + Julia Computing + +
+Computational problems can often be represented as specific types of graphs known as DAGs. That allows an execution framework to execute parts in right order, schedule in parallel, and make optimal use of available resources. We present ideas on which we are building a scalable scheduler for Julia.
+
+
+ + + Budapest University of Technology and Economics + +
+Modelling of stochastic effects in engineering is limited not only by the few existing mathematical methods but also by their low effectivity and high complexity. An easy-to-use Julia package is presented to investigate stochastic linear delayed systems including control and machine-tool vibrations.
+
+
+ + + GERAD, Montréal & INRIA Lille + +
+Increasing the proportion of renewable energy has become a priority for power grids, but their integration requires higher flexibility of consumption times. Using game theory and optimization, we design a framework allowing flexibility and privacy, while reducing costs for both consumer and supplier
+
+
+ + + ETH Zurich, Switzerland + +
+Glaciers and ice caps are projected to dominate global sea level rise up to 2100. To estimate ice thickness maps of such glaciers using mostly surface data, we use a semi-physical forward model combined with a Bayesian inversion scheme. We leverage Julia to allow compute intense MCMC simulations.
+
+
+ + + Dravyaniti Consulting LLP + +
+Life of a Trading strategy is unknown. 'Till how long will this work?'. As markets get more mature, with advent of ML and AI, the designer's job is getting tougher. Using rules to analyse big data by splitting it across Time-Frames, traders can gain significant edges, for all types of traders.
+
+
+ + + University of Luxembourg + +
+Julia accelerates analyses of huge-scale biochemical networks with now more than a million biochemical reactions. Through the open-source high-performance COBRA.jl package, the analysis capabilities of the COnstraint-Based Reconstruction and Analysis community are lifted to another level.
+
+
+ + + British Antarctic Survey + +
+EchoJulia is a software library that is enabling new kinds of fisheries acoustic applications. From big data analysis of ship-based surveys to data collection from ocean gliders, we show how Julia is set to improve ecosystem estimates of Southern Ocean Antarctic Krill.
+
+
+ + + University College London + +
+Handling uncertainty in process design and optimisation is a crucial challenge in current research and in the industry. We believe that Julia has the potential to be used as a comprehensive modelling language to enable designers to develop new systems with greater confidence.
+
+
+ + + Australian Institute for Machine Learning + +
+I will present an approximate maximum likelihood method that encapsulates a gamut of heteroscedastic errors-in-variables regression problems that often arise in computer vision applications. Julia's multiple dispatch and Unicode support facilitates a unique, concise and readable implementation.
+
+
+ + + University of Warwick + +
+Most of the time, neurons in the cortex fire due to randomly arriving inputs. The irregular firing that results is not merely noise, but is thought to play an important role in cortical computation. I show how I have implemented stochastic simulations of this irregular firing in my research.
+
+
+ + + Exegetic Analytics + +
+Bayesian techniques can seem challenging and esoteric. However, they promise a powerful alternative to frequentist statistics, with the possibility of extracting even more useful information from your data. This talk will help you get started with Bayesian analyses.
+
+
+ + + Institute for Economic Forecasting, Romanian Academy + +
+The title of the presentation comes from the my forthcoming book at one of the leading publishers, Academic Press, an imprint of Elsevier. The poster (based on the book) will introduce the audience to state-of-art computational techniques used in economics through examples and applications in Julia.
+
+
+ + + City of London School + +
+The talk is about remote control robots controlled by Julia on a Raspberry Pi. I will show how to do physical computing with Julia using the GPIO pins of the Pi.
+
+
+ + + UNAM + +
+Julia's capabilities are amazing for scientific computing - but how to begin designing your own libraries and packages? With OrthogonalPolynomials.jl, we will showcase the development of a production ready library in 100 lines of code - with a series of video walkthroughs on step by step design.
+
+
+ + + UFPR - Federal University of Paraná + +
+We study the Simplex method, a linear optimization search method. The revised Simplex method was studied and implemented along with the LU update, aiming for the solution of large scale sparse problems. The method was implemented in the Julia Language and tested against available solvers.
+
+
+ + + Karlsruhe Institute of Technology + +
+This poster announces PCE.jl, which is a Julia Package for uncertainty quantification (UQ) using a method called 'polynomial chaos expansion' (PCE). It offers an alternative approach to Monte-Carlo-based UQ, and is also more efficient for certain problem instances.
+
+
+ + + University of Cambridge + +
+Deep Learning's popularity is partly derived from its composability. General probabilistic machine learning is, in fact, just as composable, but technically much more challenging. I present an interesting edge case where life is easy, and discuss how Julia is uniquely positioned to exploit this.
+
+
+ + + University of California, Irvine + +
+Stochasticity (randomness) in biochemical reactions exists. Things diffuse and randomly bump together to bind/unbind. Yet these chemicals form the basis of life. But biological organisms evolve to their surroundings. Have they evolved to use biochemical randomness? I will demonstrate how they do it.
+The Julia Community Prizes have been announced. A certificate of accomplishement and a cash prize of $1000.00 has been awarded to:
+For extending Julia natively to the GPU
+For her enhancements of Julia's test suite and documentation +
+For his development of JuliaDiffEq and his community engagement +
+For his design and stewardship of Julia's binary infrastructure +
++ Our congratulations to the winners, and our thanks to the committee.
+ + +The members of the committee for 2018 are Prof Alan Edelman, MIT; Prof Tim Holy, WU; and Mr Curtis Vogt, Invenia. +
+
+
+ + + + +
+Language developers are torn between the need to quickly iterate on language designs and the need to prove that those designs can be efficiently implemented. I’ll show that Julia neatly captures many of the proposed solutions to this dilemma, making it a compelling platform for language development.
+
+
+ + + + +
+In this talk I will describe the past, present and the future (in the context of recent changes to sequencing technology and genome assembly techniques) of BioJulia, and how we are working towards our mission of provide a performant, human-friendly bioinformatics infrastructure.
+
+
+ + + + +
+Julia is the best language one can do science with. It combines high performance with intuitive & simple code, and allows 1-to-1 correspondence between code and scientific algorithm. I will present an overview of the packages of the JuliaDynamics GitHub org. as examples that justify this claim.
+
+
+ + + + +
+Learn how to turn your software into a portable application you can compile, distribute - and sell - anywhere! Julia is great for building robust, cross-platform software. In April, I published the first-ever app on the Mac App Store written entirely in Julia. Learn how you can do the same!
++ + University of Cambridge + +
+We introduce recent developments in Turing.jl — a probabilistic programming language. Similar to Stan, Turing provides a black box tool for Bayesian inference. Turing provides researchers experts with a research toolbox for implementing, investigating and benchmarking new or composed algorithms.
+
+
+ + + MIT Computer Science and Artificial Intelligence Laboratory + +
+Index notation (Einstein summation) is an elegant representation for array operations, powering several recent high-level compilers for array/tensor algebra. Attend to enjoy a programmer-centric explanation of index notation, its generalizations, and how it will revolutionize array library design!
+
+
+ + + Julia Computing, Inc. + +
+The Circuitscape rewrite in Julia provides a 4-8x benefit in speed and scalability over the old Python package . We show the specific benefits of Julia over Python and how to write an end-to-end application purely in Julia, from native Julia solvers to packaging and shipping.
+
+
+ + + San Francisco Bay Area + +
+The talk shows how to implement some of the best-known attacks on real-world cryptography - in Julia! To break crypto is to solve mathematical puzzles, and it is valuable as a technical exercise, as well as an educational experiment for Julia. Few knows how to actually break crypto, want to see how?
+
+
+ + + + +
+
+
+ + + Fugro Roames + +
+Data comes in all shapes and sizes. While Julia’s built-in arrays are wonderful for dealing with flat or “flattish” data - here I’ll introduce some strategies and tools for dealing with more complex nested data structures, the split-apply-combine paradigm, and working with relational data (tables).
+
+
+ + + + +
+Before Julia, it was not possible, starting from scratch, for one person to make significant progress writing a tool that can compete with Wolfram on a reasonable time scale. But, the many advantages of Julia, for instance syntactic macros and access to the syntax tree, put this goal in reach.
+
+
+ + + Relational AI + +
+In designing a new language for technical computing, we believe the designers of Julia have accidentally created a great language for systems programming. We explain how efficient, low-level data structures like B+-trees can be implemented in high-level Julia code, with help from a recent package.
+
+
+ + + Rutgers University + +
+Real-world data comes to you in tables full of strings, dates, numbers, etc. To analyze this data you often need to wrangle it into a numerical array. The “formula” DSL is a powerful tool to express these transformations, inspired by R but supercharged with Julia’s unique strengths.
+
+
+ + + KLS Gogte Institute of Technology, Belgaum + +
+Welcome to the exciting world of Brain Computer Interface with Internet of Things. With our project we have made an attempt to provide voice to the voiceless and capability to the incapable (paralyzed) with the help of wonderful programming language known as Julia.
++ + Universidad Nacional Autonoma de Mexico andUniversidad Nacional Autonoma de Mexico + +
+We approximate a function rigorously with Julia: find a Taylor series that is close, using automatic differentiation, and bound the resulting error using intervals, giving a “Taylor model”. We use this to get guaranteed approximate solutions of ordinary differential equations in the form of tubes.
+
+
+ + + + +
+Sophisticated tools are required to accurately estimate modern economic models, in the face of unprecedented macroeconomic conditions. The tempered particle filter is a novel method for filtering nonlinear state space models, surpassing conventional tools in accuracy and flexibility. This talk wi...
+
+
+ + + + +
+
+
+ + + University of California, Irvine + +
+Drug development costs $1.2billion over 12 years. Clinical trial simulations, using PKPD models, de-risk this investment. Simulations help narrow-down target patient, dosing schedule and trial size choices. PKPDSimulator.jl is a Julia package for trial simulation.
+
+
+ + + Chalmers University of Technology + +
+Julia 1.0 comes with a brand new package manager, currently called Pkg3. Pkg3 was redesigned from scratch to solve a number of fundamental problems with the old package manager. This talk discusses the decisions we made to ensure that Pkg3 allows the Julia package ecosystem to grow and succeed.
+
+
+ + + GTRI + +
+LightGraphs defines abstractions to implement for any graph or network. Instead of re-inventing the wheel, we can share existing algorithms and functions within the ecosystem. We will live-code a new graph type. Attendees will learn to extend JuliaGraphs with a custom graph type for any application.
+
+
+ + + + +
+We present the package “BoltzmannMachines.jl”: Different types of restricted Boltzmann machines serve as flexible building blocks for our Julia-native implementation of multimodal deep Boltzmann machines, a generative model for unsupervised deep learning on composite or partitioned data sets.
+
+
+ + + MIT + +
+Cassette is a tool for injecting user-defined code transformation passes into Julia’s JIT compilation cycle, enabling normal Julia packages to analyze, optimize, and modify Cassette-unaware Julia programs via both low-level IR transformation and high-level dispatch using Cassette’s context types.
+
+
+ + + + +
+The focus of this talk is DataDeps.jl – BinDeps for Data – Repeatable Data Setup for Replicable Data Science. How to manage data dependencies to ensure any script can be executed by others. The secondary topic is what comes next: data ingestion, with a focus on NLP, though that generalizes.
+
+
+ + + Julia Computing, Inc. + +
+We have many tools to provide some answers when analyzing Julia programs – code_warntype, @profile, VS Code workspace – but many more questions. Let’s explore a new experience for understanding Julia code!
+
+
+ + + PTScientists + +
+Julia might be a secret weapon for the next chapter of the New Space revolution. This talk will present the roadmap for the JuliaAstro and JuliaSpace organizations and demonstrate how Julia can be used to combat the current complexity crisis and enable the next generation of space explorers.
+
+
+ + + Melbourne, Australia + +
+RecSys is based on predicting the best item set for a user. I used Julia in a real-time solution with Genie, DataFrames and XGBoost integrated with a Search Engine. As result, it helped my DS team to deliver impacting results processing +100,000 features for a large set of jobs in incredible 250ms!
+
+
+ + + + +
+TIM (Tangent Information Modeller) is a unified large-scale forecasting system written first in C++ and then in Julia. The key advantages in doing so will be shared covering both the computational and architectural aspects ranging from the engine kernel all the way up to its REST API with examples.
+
+
+ + + + +
+Julia’s multiple dispatch and generic functions lets you reuse code, not just for computing results, but also to visualize how the algorithm works and even prove formal correctness of an implementation. I’ll show this for parallel prefix, a fundamental algorithm of parallel computing.
+
+
+ + + University of Glasgow + +
+Global biodiversity loss is reaching critical levels. Working with 200M plant records, an evolutionary tree of 30k of plant species and global climate reconstructions to understand this process is a huge computational challenge, and one that requires many of Julia’s “ecosystems” working together.
+
+
+ + + + +
+Flux is a new machine learning library that’s easy and intuitive to use with state-of-the-art performance. I’ll show how we achieve this using Julia’s advanced features alongside modern compiler and language technology, as well as cool things that people are doing with Flux.
+
+
+ + + Konstanz U + +
+Value Function Iteration (VFI) is a technique widely used by economists to solve dynamic programming problems. VFI is conceptually simple, but computationally very taxing with complex models or high dimensions. However, using Julia and GPUs, it is possible to run VFI algorithms up to 150x faster.
+
+
+ + + + +
+Building and serving binary dependencies for Julia has been a challenging problem in the past. With BinaryBuilder.jl and BinaryProvider.jl, we present a set of powerful and straightfoward tools to compile, serve and load binary dependencies for packages on all platforms Julia supports.
+
+
+ + + + +
+Numerical optimization is used in many scientific fields such as signal processing, machine learning, finance and control. We propose a new Julia package providing an intuitive language for defining and solving possibly nonconvex, nonsmooth optimization problems using natural mathematical notation.
+
+
+ + + + +
+Julia’s design enables efficient idiomatic code optimizations. I will detail Julia’s main optimizations and explain under which conditions on the code Julia’s JIT compiler can perform them. I will also show how users meet these conditions, using static and dynamic analyses of popular Julia packages.
+
+
+ + + Julia Computing + +
+JuliaDB is a pure Julia analytical database. It support a number of features: releational database operations, parsing text files, parallel computing, tabular data storage and compression. +In this talk you will learn about the underlying building block packages that make up JuliaDB. This talk sho...
+
+
+ + + + +
+The remote memory access routines from MPI-3 are a natural fit for the Julia programming model. We show how to build a custom IO and distributed array on top of them, and how this system can help with interfacing with both Julia native parallelism and external MPI-based libraries.
+
+
+ + + + +
+JuliaDB integrates with OnlineStats to provide scalable single pass algorithms (that can run in parallel) for statistics and modeling on big data. This integration allows you to transform small-scale analyses into out-of-core computations for huge datasets without changing your code.
+
+
+ + + Julia Computing + +
+Have you ever wondered how or why you might create a custom array? Have you never written struct ___ <: AbstractArray{T,N}? It’s easier than you might expect! I’ll give a motivating example, incrementally define and refine a custom array, and demonstrate how to make it robust and fast.
+
+
+ + + University of California, Berkeley + +
+The julia extension for Visual Studio Code provides a convenient coding environment for julia development. This talk will highlight key features of the extension.
+
+
+ + + MIT + +
+Do you want to build Baymax, Data, or Robby the Robot? Do you want a future with more robots for rescue, delivery, and exploration (and fewer C++ linker errors)? I’ll introduce the JuliaRobotics org and show off our work on visualizing, simulating, and controlling a humanoid robot in Julia.
+
+
+ + + Stanford University and Julia Computing + +
+Are you new to Julia?! This introductory workshop should be accessible to anyone with technical computing needs and some experience with another programming language. We will show you why Julia is special, demonstrate how easy Julia is to learn, and get you writing Julia code.
+ +In the first half of this tutorial, we will briefly introduce the language, giving attendees a sense of why Julia is special and what needs Julia meets. After that, we will show how easy it is to pick up Julia’s syntax, covering string manipulation, data structures, loops, conditionals, and functions.
+ +In the second half of this tutorial, we will illustrate Julia’s speed, power, and expressiveness. Among other things, we will look at Julia’s generic linear algebra infrastructure, benchmark Julia against C and Python, and discuss how Julia’s design paradigm leads to flexible performance.
+ +Exercises to ingrain concepts will be included throughout the tutorial with an integrative exercise at the end.
+ + +Jane Herriman is Director of Diversity and Outreach at Julia Computing and a PhD student in the Department of Applied Physics and Materials Science at Caltech. She has completed part of her PhD at Lawrence Livermore National Lab.
+ +Sacha Verweij has recently completed his PhD in Applied Physics and Computational Mathematics at Stanford University, and is a core developer of the Julia language.
+ + + +
+
+ + + + +
+SyMBOL is a micro-funded statistical tool which analyses the consequences of bank failures and is used by the European Commission to assess regulatory proposals to enhance financial stability and prevent future financial crises. At the core of the model, there is a Monte Carlo simulation applying the Basel Foundation Internal Rating Based loss distribution. For security reasons, we were asked not to use our server where the C code is usually run. This forced us to re-code SyMBOL and we opted to do this in Julia. We considered different design options and faced the issue that results must be exactly the same. Our current design uses the main process to generate the random numbers, while the remote processes fetch the random numbers to calculate the correlated random shocks and check whether a bank has defaulted. The simulations stop if a pre-set number of runs (usually 100.000 runs) have at least one defaulted bank. Given this set up and the parallel computing capabilities of Julia we were able to reduce the computing time by around 50% compared to the parallel C-code discussed in Muresano and Pagano (2016). +Muresano, R., Pagano, A., 2016. Adapting and Optimizing the Systemic Model of Banking Originated Losses (SYMBOL) Tool to the Multi-core Architecture. Comput. Econ. 48, 253–280. doi:10.1007/s10614-015-9509-4
+ + ++
+ + +
+
+ + + IBM Dublin Research Lab + +
++
nprocs() ==1 && addprocs()
+ +@everywhere import CombineML.Util
+ +@everywhere import CombineML.Transformers
+ +@everywhere import RDatasets
+ +@everywhere CU=CombineML.Util
+ +@everywhere CT=CombineML.Transformers
+ +@everywhere RD=RDatasets
+ +#Scikit wrapper that provides access to scikit learners
+ +@everywhere sk_gblearner = CT.SKLLearner(
+ +Dict( :output => :class,
+ +:learner => “GradientBoostingClassifier”,
+ +:impl_options => Dict()
+ +) +)
+ +@everywhere best_learner = CT.BestLearner(
+ +Dict(
+ +:learners => [sk_gblearner,CT.PrunedTree(),CT.RandomForest()],
+ +:output => :class, :score_type => Real, :learner_options_grid => nothing
+ +)
+ +)
+ +@everywhere vote_learner = CT.VoteEnsemble(
+ +Dict(
+ +:output => :class,
+ +:learners => [
+ +CT.PrunedTree(), CT.DecisionStumpAdaboost(),
+ +CT.RandomForest(),sk_gblearner,best_learner
+ +]
+ +)
+ +)
+ +@everywhere stack_learner = CT.StackEnsemble(
+ +Dict(
+ +:learners => [
+ +CT.PrunedTree(), CT.RandomForest(),
+ +CT.DecisionStumpAdaboost(),
+ +best_learner, sk_gblearner
+ +],
+ +:stacker => CT.RandomForest()
+ +) +)
+ +pipeline = CT.Pipeline(
+ +Dict(
+ +:transformers => [
+ +CT.OneHotEncoder(), # Encodes nominal features into numeric
+ +CT.Imputer(), # Imputes NA values
+ +CT.StandardScaler(), # Standardizes features
+ +learner
+ +]
+ +) +)
+ +dataset = RD.dataset(“datasets”, “iris”)
+ +instances = Array(dataset[:, 1:(end-1)])
+ +labels = Array(dataset[:, end])
+ +(train_ind, test_ind) = CU.holdout(size(instances, 1), 0.3)
+ +CT.fit!(pipeline, instances[train_ind, :], labels[train_ind])
+ +predictions = CT.transform!(pipeline, instances[test_ind, :])
+ +result = CU.score(:accuracy, labels[test_ind], predictions)
+ +@everywhere function predict(learner)
+ +dataset = RD.dataset(“datasets”, “iris”)
+ +instances = Array(dataset[:, 1:(end-1)])
+ +labels = Array(dataset[:, end])
+ +(train_ind, test_ind) = CU.holdout(size(instances, 1), 0.3)
+ +pipeline = CT.Pipeline(
+ +Dict(
+ +:transformers => [
+ +CT.OneHotEncoder(), # Encodes nominal features into numeric
+ +CT.Imputer(), # Imputes NA values
+ +CT.StandardScaler(), # Standardizes features
+ +CT.PCA(),
+ +learner
+ +]
+ +)
+ +)
+ +CT.fit!(pipeline, instances[train_ind, :], labels[train_ind]);
+ +predictions = CT.transform!(pipeline, instances[test_ind, :]);
+ +result = CU.score(:accuracy, labels[test_ind], predictions)
+ +return result
+ +end
+ +using DataFrames
+ +function main(trials)
+ +learners=Dict(
+ +:gradientboosting=>sk_gblearner, :randomforest=>CT.RandomForest(),
+ +:adaboost=>CT.DecisionStumpAdaboost(), :votelearner=>vote_learner,
+ +:bestlearner=>best_learner, :stacklearner=>stack_learner + )
+ +models=collect(keys(learners))
+ +ctable=@parallel (vcat) for model in models
+ +acc=@parallel (vcat) for i=1:trials
+ +res=predict(learners[model])
+ +println(model,” => “,round(res))
+ +res
+ +end
+ +[model round(mean(acc)) round(std(acc)) length(acc)]
+ +end
+ +| sorted=sortrows(ctable,by=(x)->x[2],rev=true) | +> DataFrame | +
rename!(sorted,Dict(:x1=>:model,:x2=>:mean_acc,:x3=>:std_acc,:x4=>:trials))
+ +return sorted
+ +end
+ +const trials = 5
+ +res = main(trials)
+ +@show res
+ +Learners have only been tested on instances with numeric features.
+Inconsistencies may result in using nominal features directly without a numeric transformation (i.e. OneHotEncoder).
+I am a research scientist at the IBM Dublin Research Lab working in the areas of analytics, datamining, machine learning, and AI. I finished my Doctor of Engineering degree from the Toyohashi University of Technology in Japan (2005). I have a Master’s degree in Computer Science majoring in Artificial Intelligence (Ateneo de Manila University, 1995) and a Bachelor’s degree in Applied Mathematics (University of the Philippines in the Visayas, 1991). I used to work as a technical staff for two years in the Neuroinformatics Lab of RIKEN Brain Science Institute, Japan before finishing my DEng degree. I spent a total of 4 years as a Postdoctoral Fellow in the National University of Singapore and the National Neuroscience Institute working on diverse topics such as context-aware reasoning, datamining models for activity recognition in smarthome environment, detecting biomarkers for Parkinson’s Disease by image processing of fMRI and DTI images, and automated diagnosis of movement disorder for intelligent healthcare. Moreover, I held an Asst. Professorship for a total of 6 years in the University of the Philippines and Ateneo de Manila University. My research interests include datamining, optimization, development of intelligent agents using machine learning and evolutionary computation, neuroinformatics, and biomedical engineering.
+ + + +
+
+ + + + +
+Physicists and engineers have been investigating the mechanical properties of materials for a long time. Biologists, aided by recent developments in microscopy, have gained fascinating insights into the fundamental role mechanical properties play during many biological processes. One of the barriers to entry for biologists interested in biomechanics is the mathematical and programming knowledge required to analyse viscoelastic experimental data. RHEOS, written in Julia, is an open source project aiming to address that issue whilst also providing a more general rheological analysis toolkit for anyone who wants to analyse their viscoelastic material data, biological or otherwise. The software was originally written in Python. It was slow, but just about acceptable for a patient PhD student who had other things to keep busy with whilst the data was processing. Once the decision was made to extend it and publish it as open source software, it was clear that either more of the computationally intense parts would have to be outsourced from Python, or that it should be rewritten in a new language entirely. We chose the latter and the software has now been rewritten in Julia, with a first public release scheduled for March 2018. In this talk I will discuss the software’s capabilities, examples of rheology informing biology, more detail on the motivations for choosing Julia, the features of Julia which has helped the project come together, and any obstacles I ran into along the way and how they were overcome.
+ + ++
+ + +
+
+ + + + +
+Light Field reconstruction is a relatively new technique for 3D reconstruction and rendering, that can be used to compute the depth of objects from a particular scene (physical subspace) given a set of images from different viewpoints. +This technique has gained a lot of interest in the last ten years due the applications to Virtual and Augmented Reality; reflected most recently on the acquisition of the company Lytro (Light Field Camera Developer) by Google on March of this year, and the recent advances presented also by Google and Magic Leap for Light Field Applications on the new VR media revolution. Industrial interest also typically carries development closure and Light Field is not an exception, in addition it involves a great computational complexity. +Inspired by the open source spirit (characterizing the julia Comunity) and the search of interesting applications for the julia package Shearlab.jl (developed by me and presented at the last JuliaCon), I developed a julia library for Light Field reconstruction that optimizes the computation by using the Shearlet transform to represent sparsely the Light Field, called LightFields.jl. In this lightning talk I will present the basics of the LightFields.jl’s API, some nice results, and also a very easy and cheap, open hardware implementation of a Light Field Camera using no more than julia and a Raspberry Pi.
+ + ++
+ + +
+
+ + + Caltech/Lawrence Livermore National Lab + +
+Most of us are here because we’re already using and excited about Julia. How can we make the language and ecosystem more inclusive of and accessible to potential new users coming from all backgrounds and experience levels? I believe the keys are creating fantastic teaching materials and making these materials free, open, and visible. We want to make sure that the barrier to learning Julia is low — and not just for experienced programmers. +I will share with you efforts underway in the Julia community to develop and distribute accessible materials to learn Julia, including in-person outreach at schools around North America and an online tutorial series. Of course, our focus cannot simply be on teaching Julia, but on using Julia to teach other in-demand skills, like programming and data science. To this end, I will also discuss the development of machine learning curriculum using Julia and ways that you can get involved in making the Julia language and ecosystem more accessible.
+ + +Jane is a graduate student in computational materials physics enrolled at Caltech. She is interning at Lawrence Livermore National Lab, where she is working with Xavier Andrade on methods for and applications of density functional theory.
+ + + +
+
+ + + + +
+As machine learning models grow increasingly complex, we suggest that neural networks are best viewed as an emerging, differentiable programming paradigm, and ask what decades of research into programming languages and compilers has to offer to the machine learning world. +Julia is an ideal platform not only for this kind of high-performance, numerical programming, but for the research into compiler and language features needed to push the state of the art forward. Features such as wide hardware support (GPUs, TPUs), kernel fusion, compiler-level automatic differentiation, push-button compilation and deployment and elegant mathematical syntax are all invaluable to researchers. This talk will explain how we are able to take the Julia compiler to its limits and push forward the state of the art in the machine learning world.
+ + ++
+ + +
+
+ + + Konstanz U + +
+Among the many computational techniques that economists, and more specifically macroeconomists use to solve models, value function iteration (VFI) is probably the most commonly used. VFI is simple to implement, conceptually very close to the theoretical results of dynamic programming and works over a wide range of models, especially if these entail complex stochastic elements. Unfortunately, VFI algorithms are computationally very taxing even for modern machines, usually requiring long times (in the order of hours) to converge to a solution. +To address this problem, much in the footsteps laid down by the paper by Aldrich, Fernandez-Villaverde,Gallant and Rubio-Ramirez “Tapping the Supercomputer under your Desk: Solving Dynamic Equilibrium Models with Graphics Processors” , I would like to present how it is almost trivial to use Julia, OpenCL, and the packages GPUArrays.jl and CLArrays.jl to run VFI algorithms orders of magnitude faster, using only a consumer (integrated) graphics card and without loosing appreciable precision. +We focus our attention on the following topics:
+ +I am an M.SC in Economics student in my second and last year at Konstanz University, Germany, in a double degree program with the University of Rome Tor Vergata. I have an undergraduate degree in Mathematics (which is and will be my secret passion), even thought I’ve now turned to Macroeconomics. My passions are: programming, tennis, pasta all’amatriciana and listening to music during long car trips. I don’t have to write code, but it gives me much joy.
+ + + +
+
+ + + + +
+The old world of BinDeps.jl fades slowly into the long, dark sleep of forgotten heroes. From the deep places arises a new contender, strong and eager to lay to rest the complaints of the commonfolk. Songs of ancient deeds and whispers of arcane knowledge wend their ways around the terrible visage of BinaryBuilder.jl like a luminous crown, forcing all who lay eye upon it to tremble in a mixture of fear and awe. The age of terror has passed. A new world dawns. +Building binary dependencies for the wide range of platforms that Julia supports is difficult; BinaryBuilder makes this easier for you. Come to this talk to learn about how we are solving this problem, and how you can use these tools to compile your C/C++/Fortran binary dependencies into tarballs for use in your Julia packages. We will start with a brief introduction to the internals of BinaryProvider and BinaryBuilder, then end with building a tarball for a binary dependency and installing it for a Julia package. By the end of this talk, you should be comfortable with using BinaryBuilder to build tarballs, and using BinaryProvider to install them within your own packages.
+ + ++
+ + ++ + University of Copenhagen + +
+People doing numerical computing are greedy. They want results now and accurately, and we have been ready to accept loss of readability and extensibility to get it. As a result, the elementary functions we take for granted in paper math are often coded in low-level languages. We can do better. +The talk will go through the motivation, the work done, what remains to be done, and what further possibilities there are to improve performance and accuracy of elementary function evaluations in Julia. Collectively, these functions are often provided in so-called “libm”’s (library of mathematical functions), and many languages oriented towards numerical computing tend to call libraries written in C or Fortran. +Julia has depended on a collection of functions bundled in the C-based openlibm to provide this functionality. As we will see, there has been a push to free Julia of openlibm and similar C- or Fortran-libraries without loss of speed, accuracy or readability.
+ + +Ph.D. student in economics, JuliaNLSolvers owner and developer, Julia nerd.
+ + + +
+
+ + + + +
+StructuredOptimization provides a modelling language to formulate and solve optimization problems, using a syntax that closely resembles the original mathematical formulation. This user-friendly interface acts as a parser to use three different packages:
+ +The package will be presented by illustrating the high versatility of the PG algorithms through a series of application examples. In particular, classical signal processing applications (sparse deconvolution and line spectra estimation) will be shown together with audio, image and video processing applications (audio de-clipping, total variation denoising and video background removal) and nonlinear classification using machine learning techniques.
+ + ++
+ + +
+
+ + + Universidad de Buenos Aires/CONICET and and + +
+Econometrics allows researchers to deal with competing theories about complex processes which could lead to very different diagnosis and even opposite policy advises. Advances in model selection techniques, driven by the increasing number of available HPC algorithms, constitutes one of its major contributions to Economic Theory. +In-sample model selection has benefited from using mathematical developments to reduce the search space (e.g. Branch and Bound theorems) and efficiently find the best subset regression (in terms of defined information criteria). It is also possible to use heuristic approaches like Genetic algorithms, or different dimension reduction methods like Stepwise, Lasso or Ridge estimators. While failing to guarantee global optimality, they are fast and well-suited for Big and/or Sparse Data. +On the contrary, out-of-sample model selection techniques require more computing resources. In a Machine Learning environment (e.g. problems focusing on predictive analysis) there is an increasing universe of “training/test” algorithms (many of them showing very interesting performance in Julia) to compare alternative results and find-out a suitable model. In Econometrics (e.g. problems focusing on causal inference) we require five important features which narrow the set of available algorithms: 1) Parsimony (to avoid very large atheoretical models); 2) Interpretability (for causal inference, rejecting “intuition-loss” transformation and/or complex combinations); 3) Across-models sensitivity analysis (economic theory is preferred against “best-model” unique results); 4) Robustness to time series and panel data information (preventing the use of raw bootstrapping or random subsample selection for training and test sets); and 5) advanced residual properties (e.g. going beyond the i.i.d assumption and looking for additional panel structure properties -for each model being evaluated-, which force a departure from many algorithms). +For these reasons, most economists prefer flexible all-subset-regression approaches, choosing among alternative models by means of some out-of-sample criteria, model averaging results, theoretical limits on covariates coefficients and residual constraints. While still unfeasible for Sparse Data (p>>n), hardware and software innovations allow researchers to choose among one billion models in a few hours using a standard personal computer. Therefore, almost all statistical applications have an all-subset regression function. Some of them, have even developed a parallel version of their core algorithm (pdredge in R or gsregp in Stata). +The objective of this talk is to introduce GSReg.jl (https://github.com/ParallelGSReg/GSReg.jl), a new package to perform the all-subset-regression approach exploiting Julia’s parallel capabilities and allowing users to choose between a simple GUI (https://github.com/ParallelGSReg/GSRegGUI) or an R/Stata-friendly command line interface. We will discuss its main features, pros and cons, limitations, future extensions and differences with similar existing Julia packages like BestSubsetRegressionl.jl, LARS.jl Lasso.jl, Mads.jl, ParallelSparseRegression.jl or SubsetSelection.jl. +We will show that GSReg.jl is 4 to 10 times faster than other similar alternatives and more than 100 times faster than the original (sequential) Gsreg Stata version (using a last generation personal computer). A forthcoming paper will include programming details, profiling data, extended examples and benchmarking results.
+ + +HPC, Parallel Programming, Disitributed Systems, Applying parallel resources to real life applications
+ + + +
+
+ + + Domo + +
+The DataStreams.jl framework is behind a number of key packages in the Julia data ecosystem. At it’s core, it defines the “Source” and “Sink” interfaces that various formats can implement to automatically integrate with other formats that also implement the interfaces. This solves the one-to-many interop problem that always plagues data formats (“what? it only takes CSV files??”). With DataStreams, it’s quick and easy to implement the interface and automatically hook into the rest of the Julia data ecosystem. +So what’s new and noteworthy in DataStreams?
+ +Attended Carnegie Mellon for a master’s degree in data science and active Julia contributor for 4 years now.
+ + + +
+
+ + + + +
+The Julia language has been designed in order to offer performance without sacrificing productivity. Its secret is a combination of carefully chosen features, such as multiple dispatch and rich type annotations, and some optimizations like inlining done by the just-in-time compiler. I will explain how the code is optimized by Julia’s JIT before being given to the LLVM back end, and, as a consequence, why a specific coding style is required for performance. I will also look at a selection of fifty popular Julia packages to see how amenable they are to these optimizations, using static and dynamic analyses. Finally, I will briefly talk about Julia’s design against the context of other related programming languages, to show the singular place it occupies.
+ + +Currently in first year of Master at the École Normale Supérieure.
+ + + +
+
+ + + Julia Computing + +
+JuliaDB is a pure Julia analytical database. It makes loading large datasets and playing with them easy and fast. JuliaDB needs to support a number of features: releational database operations, quickly parsing text files, parallel computing, data storage and compression. +This talk is a bottom-up look at the construction of JuliaDB. We will talk about the scope and implementation of underlying building block packages, namely IndexedTables, TextParse, Dagger, OnlineStats and PooledArrays. This talk should help beginners get started using, as well as hacking on JuliaDB!
+ +I’m a Julia programmer at Julia Computing.
+ + + +
+
+ + + + +
+The objective of this talk is to illustrate how some of the “modern” MPI functions can be used to build new parallel tools in Julia and interface with existing native parallelism in Julia. The motivation for this work is to simplify working with libraries such as Trilinos. +We will begin by outlining the differences between the Julia native parallelism and the MPI “single program, multiple data” approach. Next follows a gentle introduction to the MPI-3 calls (now available in MPI.jl master), which perform communication in a one-sided way, so not all processes need to call MPI routines at the same time. This property is very useful to build a custom Julia IO (similar to TCPSocket) for point-to-point communications over MPI. This IO can then be used to build a Julia cluster manager, enabling native Julia parallelism over asynchronous MPI communication. The steps required to build this system (code here) will be outlined, together with some caveats encountered when implementing the interface required for IO. Once a program is running on an MPI cluster manager, it becomes possible to switch on the fly between native Julia parallel calls and MPI calls, which we will illustrate using a simple example. +Distributed arrays are another key area where one-sided MPI calls can be put to use. The MPIArrays.jl package provides such an array type. The advantage of using MPI directly rather than the Julia parallel framework is that the “single program, multiple data” paradigm is preserved, so interfacing with external libraries using MPI becomes trivial. Furthermore, MPI supports the high-performance interconnects such as Infiniband that are available on many clusters. We will present the basic ideas behind MPIArrays, and show how building the basic distributed AbstractArray takes just a few lines of Julia code. A benchmark using a dense matrix-vector product will show it compares favorably to DistributedArrays.jl and the C++ library Elemental. We will then finish the talk with a concrete example of using MPIArrays to build the sparsity structure of a linear system to be solved by the Trilinos C++ library.
+ + ++
+ + +
+
+ + + + +
+Term rewriting is essential to a wide variety of fields, including elementary, boolean, and abstract algebras. Because existing symbolic simplification tools in Julia typically operate within fixed domains, it is difficult to obtain a level of control which allows for flexible inclusion and exclusion of specific mathematical properties. This talk discusses SymReduce.jl, a new term rewriting library written in Julia that simplifies algebraic expressions based on custom, domain-specific axioms. We will highlight aspects of our implementation and demonstrate the simplification process within sample domains.
+ + ++
+ + +
+
+ + + + +
+JuliaDB is a distributed database for high performance analytics that allows you to load large multi-file datasets across multiple processes, index the data for fast queries, and save tables to disk for quick reloading. JuliaDB is 100% Julia, so user-defined functions are compiled and you can efficiently store any data type. +OnlineStats is a Julia package that provides online algorithms for statistics, machine learning, and big data visualization. Online algorithms update estimators one observation at a time in a single pass, making it unnecessary that your data fit in memory. JuliaDB interfaces with OnlineStats to provide a scalable analytical framework that does the heavy lifting for you. The same operations used on toy datasets can therefore be efficiently executed on a cluster without changing your code. +This combination provides a powerful workflow for dealing with both large and small datasets. This talk will demonstrate how you can take advantage of these packages to implement scalable analytics over your own datasets.
+ + ++
+ + +
+
+ + + King's College London + +
+We can predict the properties of materials entirely within a computer. All material properties - strength, colour, opacity, conductivity etc. - come about as a result of the electronic structure adopted by the electrons in a material. This we can calculate by solving the Schrodinger equation. Unfortunately exact solutions are computationally intractable due to the O(N!) scaling with the number of electrons - the electron correlation problem. Progress in computational materials design has been made by solving approximate forms of this equation, numerically. +Venerable codes written in Fortran (and to a limited extent in C) consume the majority of cycles on public super conductors. The often archaic code bases limits how easily they can be extended. The existence of standard, optimised, codes has enabled an enormous amount of research. At the same time, development of codes in relatively few walled gardens of physics has reduced the scope of techniques that are applied. +Modern materials design attempts to go beyond predicting properties of pure crystals. Generally this is because disordered materials can be made with less energy and time. Trying to predict the properties of these materials is a challenge, as the length and time scales so exceed that which we can get to even with approximate theories. As such, we need bespoke codes and models to be able to model these systems. +I will describe successful research projects in condensed matter theory which have made essential use of Julia, and will attempt to explain why Julia, with its mathematical expressiveness, physical abstraction, and high performance, is a natural language for future work in condensed matter theory. +I will discuss revisiting Polaron mobility theories from the 1960s (https://github.com/jarvist/PolaronMobility.jl), approximate forms of quantum-nuclear effects (https://github.com/jarvist/FeynmanKleinert.jl) and Tight-Binding approaches to large scale electronic structure calculations.
+ + +A simple physicist who works in computational materials design. Everything we make is wiggling and jiggling atoms, and these are fun to simulate.
+ + + +
+
+ + + + +
+Teaching children is hard, mathematics in particular. It’s all too easy for a student to shrug and say, “I’m just no good at maths.” Perhaps the most important way we can support them is by showing that they can always get better with practice, and one of the great promises of educational technology is to help busy teachers assign targeted and achievable tasks… but while it’s easy to gamify some parts of mathematics, it’s harder to produce something that meets every student at their level. +My job at a UK educational research company is to do just that. We work in local classrooms to design and evaluate mathematics lessons and we produce personalised homework every week. As we work with more schools, it’s increasingly important to quickly try new things and carry out experiments to check that what we’re doing is effective. I’d like to share how I have increasingly been using Julia in my investigations into effective mathematics homework, giving you an inside view on what it has made easy (and what still causes pain).
+ + ++
+ + +
+
+ + + + +
+JuliaPro is a free prepackaged bundle of Julia which includes debugger, integrated development environment, 100+ curated packages, data visualization and plotting tools. More than 15,000 users have downloaded JuliaPro since its inception, and the number of JuliaPro users are growing every day. +Julia 1.0 is bringing in a lot of new exciting features to Julia ecosystem. With this in mind, we’re improving JuliaPro to take advantage and enhance its usability. We are also adding new features to JuliaPro such as GPU support, reduced installer size, long term support and many more. All these exciting features will be showcased in this talk.
+ + ++
+ + +
+
+ + + + +
+The Trilinos C++ library features a large collection of packages, with a focus on solving large linear systems. The Trilinos.jl package is an effort to provide access to the modern iterative solvers from the Belos package from within Julia. It focuses on using the sparse matrix structures from the Tpetra package, which enables features such as hybrid parallelism and GPU computing. +In Trilinos, the solvers are driven by so-called parameter lists, which allow setting up the linear solver and preconditioner to use. This way, all iterative solvers from the Belos package (including GMRES and CG) are available from Julia, with preconditioners from the Ifpack2 package (providing ILU-type preconditioners) and the MueLU algebraic multigrid package. As with all of Trilinos, these support parallel execution using MPI. In our talk, we will show how to configure a parameter list from within Julia, build the linear system and finally solve it. In many places, native Julia interfaces are implemented, such as an array interface operating directly on views of Trilinos vectors, the Associative interface for parameter lists and the \ operator to perform the actual linear system solution. +The talk will conclude with an example, showing how to solve the 2D Laplace equation and presenting a timing comparison with other Julia packages and native C++ Trilinos, showing that using the Julia interface does not slow down the system assembly.
+ + ++
+ + +
+
+ + + + +
+Combinatorial optimization is a common theme in computer science which underlies a considerable variety of problems. While in general such problems are NP-Hard, from a practical point of view, locally optimal solutions can be quite useful. However, combinatorial problems require special solution strategies, and generic approaches like gradient methods for the continuous setting are hard to come by. We present a new stochastic optimization algorithm that can be applied in a generic fashion to a variety of combinatorial problems, and which only relies on function evaluations. In contrast to standard optimization algorithms, the new algorithm is highly parallelizable, and can rely on multiple evaluations simultaneously. The new algorithm is provided as part of a new Julia package that capitalizes on Julia’s parallel computation infrastructure in a manner that is completely transparent to the end user. Together with Julia’s excellent JIT compilation, this leads to a highly effective distributed optimizer for combinatorial problems that requires end users to provide nothing more than the function they seek to optimize.
+ + ++
+ + +
+
+ + + Julia Computing + +
+The ability to define fully-functional custom arrays with a struct definition and just a handful of methods is a powerful tool in Julia, but there are some tips and tricks that are essential to making them both fast and robust. In this talk, I’ll implement a custom array following the AbstractArray interface, and then we’ll dig in deeper to examine and iteratively optimize the generated code in a typical use-case. We’ll examine some key examples where custom arrays can completely transform an algorithm. You’ll be able to follow along with an incremental approach to defining and improving the arrays. Along the way, you’ll learn about the key idioms — like Holy traits and bounds-checking — that are integral to this interface. Finally, I’ll take a look at some of the more advanced custom arrays that are published, useful, and widely used.
+ + +Matt Bauman is a Senior Research Scientist at JuliaComputing at their Chicago outpost, where he spends lots of time working on Julia’s arrays. He’s been contributing to both the core language and multiple packages since 2014. At his previous position as a Data Science Fellow at the University of Chicago’s Center for Data Science and Public Policy, he longed for dot-broadcasting in Python. He recently defended his PhD dissertation in Bioengineering from the University of Pittsburgh, focusing on neural prosthetics.
+ + + +
+
+ + + University College London + +
+Tensor decompositions are a powerful method to compactly represent high-dimensional data. Such data is encountered quite naturally in the numerical treatment of quantum systems with many particles, e.g. small molecules. In this talk I will show how Julia helped me to represent a nine-dimensional potential energy surface for the H3O2- molecule as a compact hierarchical tensor, which allowed for a very efficient numerical computation of its ground state. The resulting Julia code for computing hierarchical tensor decompositions may be of general use for dealing with structured high-dimensional data.
+ + +Frank has a PhD in Theoretical Chemistry, and many years of experience with scientific software development and high performance computing. In 2017 he joined the Department of Chemistry at University College London as an HPC support specialist. Frank has been keenly following the development of Julia since 2013, and continues to advocate its use to his colleagues.
+ + + +
+
+ + + + +
+In this paper, we develop a fully open-source bottom-up electricity sector model with high spatial resolution using the Julia programming environment, describing source code and data set. This large-scale model of the German electricity market includes both generation dispatch in the spot market as well as the physical transmission network, minimizing total system costs in a linear approach. It simulates the market on an hourly basis, taking into account demand, renewables infeed, storages, and exchanges with neighboring countries. Following an open-source approach, model code and used data set are being made fully publicly accessible and open-source solvers like ECOS and CLP are being used. The model is then being benchmarked regarding runtime of building and solving against a representation in GAMS as a commercial algebraic modeling language and against Gurobi, CPLEX, and Mosek as commercial solvers. With this paper we want to show the power and abilities as well as the beauty of open-source modeling systems, increasing transparency in policy advice, available free of charge to everyone and using the advatages of open data, open-source modeling, and open-access publications.
+ + ++
+ + +
+
+ + + University of California, Berkeley + +
+This talk will give an overview of the Julia extension for VS Code. The extension currently provides syntax highlighting, an integrated REPL, code completion, hover help, an integrated linter, code navigation, integration with the Julia testing infrastructure and integrated support for Weave documents (Julia’s knitr equivalent). A 30-minute version of this talk would talk about the internals of the extension. We would describe the Julia language server (our implementation of the Microsoft Language Server Protocol) that provides the integration with the VS Code UI. Other topics we would cover are our approach to build a robust and reliable software delivery mechanism that does not depend on the shared Julia package directory, our custom parser that is used in the language server and the developments currently being made to provide actionable parse-time formatting and linting hints, as well as any other features we might add between now and JuliaCon.
+ + +David Anthoff is an environmental economist who studies climate change and environmental policy. He co-develops the integrated assessment model FUND that is used widely in academic research and in policy analysis. His research has appeared in Science, Nature Climate Change, the Journal of Environmental Economics and Management, Environmental and Resource Economics, the Oxford Review of Economic Policy and other academic journals. He contributed a background research paper to the Stern Review and has advised numerous organizations (including US EPA and the Canadian National Round Table on the Environment and the Economy) on the economics of climate change.
+ +He is an assistant professor in the Energy and Resources Group at the University of California, Berkeley. Previously he was an assistant professor in the School of Natural Resources and the Environment of the University of Michigan, a postdoc at the University of California, Berkeley and a postdoc at the Economic and Social Research Institute in Ireland. He also was a visiting research fellow at the Smith School of Enterprise and the Environment, University of Oxford.nHe holds a Ph.D. (Dr. rer. pol.) in economics from the University of Hamburg (Germany) and the International Max Planck Research School on Earth System Modelling, a MSc in Environmental Change and Management from the University of Oxford (UK) and a M.Phil. in philosophy, logic and philosophy of science from Ludwig-Maximilians-Universität München (Munich, Germany).
+ + + +
+
+ + + + +
+Parameters.jl is a small package providing macros which add keyword constructors to types including the possibility to set default values for each field. This allows to effectively construct with types which have a large number of fields, as often encountered –for instance– to hold configurations of programs. Additionally, it provides macros to unpack (and pack) the values within a type, thus allowing to access them easily inside functions (or other scopes). +using Parameters @with_kw struct MyT a::Int = 1 # … m = 1:3 # … z::String = "zzz" end myt = MyT(z="j") # MyT(1, 1:3, "j") function f(myt::MyT, x) @unpack a, m = myt m + a + x end f(myt, 1) # 3:5 Keyword constructors and default field values are so useful that they are scheduled to hit Julia during a 1.x release (#10146). But don’t wait until then, unleash their power now!
+ + ++
+ + +
+
+ + + MIT + +
+Robotics research combines some of the best challenges from optimization, differential equations, machine learning, and high-performance computing. Robots are complex dynamical systems, and the fundamental questions of how to coordinate and control all but the simplest of robots are still open. It’s up to us as scientists and engineers and makers to bring about the best robotic future we can, and Julia will be part of that future. +In this talk, I’ll discuss how we’re replacing Python, C++, and MATLAB with a new set of tools in Julia to simulate, visualize, and control robots. I’ll also introduce the JuliaRobotics organization, which has been founded to coordinate and promote robotics software development in Julia. +In particular, I’ll discuss our work at MIT towards a major goal: controlling a 350 pound hydraulic walking humanoid robot in Julia. In the process, I’ll talk about the custom tools that we’ve built in JuliaRobotics as well as the ways we’re integrating with the excellent tools from JuliaDiffEq, JuliaOpt, FluxML, JuliaGeometry, JuliaGizmos, and more. You’ll hear about:
+ +Robin is a PhD student at MIT who should probably be working on his thesis instead of writing JuliaCon talk proposals. His early PhD work involved planning and control of the Atlas humanoid robot at the DARPA Robotics Challenge, and he is now interested in helping walking robots safely move through the world without falling. He’s a recovering former MATLAB user, and he’s been developing robotics tools in Julia for the past few years. You can see some of his work on github some of his silly projects on his blog and some of his thoughts on Julia for robotics at Julia Computing’s case studies.
+ + + +
+
+ + + + +
+We followed AOT capabilities of Julia closely since very early, i.e., Julia in v0.3 as this is one of the crucial capabilities for a commercial product development. Recently there was a useful article written by Viral which guided us through the AOT compilation process. After some trials we successfully managed to compile our Julia source code and put it in the production. Moreover, we enhanced the original scripts to make the compilation process smoother and enabled its automation. We would like to share our journey through this entire mission in detail covering compilation on Linux and Windows too. +We shall also take into account performance comparisons of JIT compiled routines to their AOT versions.
+ + ++
+ + +
+
+ + + + +
+Many problems turn out to be compiler problems, in fields as diverse as database querying, ‘big data’ engines, machine learning, probabilistic programming, web APIs, GUI development, network configuration, distributed systems and model checking. +But creating a quality compiler from scratch takes an incredible amount of effort. The PL community has long recognized this problem and has produced a whole zoo of proposed solutions, including shared virtual machines (eg JVM, CLR), staging (eg Terra, Squid) and partial evaluation (eg RPython, Truffle). +Using examples from both personal and commercial projects, I’ll show that many of these approaches are already available in Julia, and can be mixed and matched as needed to produce fast language implementations with minimal effort. I’ll also cover problems we’ve encountered along with workarounds.
+ + +I make programming languages and interfaces. Until recently a researcher at RelationalAI, working on declarative languages for in-database machine learning.
+ + + +
+
+ + + Julia Computing + +
+We at Julia Computing are working on a scheduler for running large DAGs (directed acyclic graphs) on many nodes in parallel. Though the concepts it is being built on are generic, it currently leverages on the existing Julia package Dagger (for representing computation DAGs) and is intended to be used with JuliaRun (to deploy Julia applications in production at scale). +Based on experiences in running large scale DAG computations with JuliaDB, this talk will present problems we encountered and our approach to tackle them. In particular: - minimizing data transfer across process and node boundaries - inter-process data transfer without blocking computation - avoiding single point scheduler bottleneck - graceful failure handling
+ + ++
+ + +
+
+ + + + +
+At JuliaCon 2015, Daniel Jones presented BioJulia: A modern Bioinformatics framework. In the years following, as julia has developed, so has BioJulia grown in the number of packages, and the number of contributors. +At the same time, sequencing technology has moved at a rapid pace, resulting more data, and in new techniques for assembling and analysing genomes. As a result biologists and bioinformaticians face both conceptual, scientific, and engineering questions: What is the canonical representation of a genome? What is the best way to analyse genomic data to address my hypothesis? How can these analyses be made reliable and repeatable? How do we do it quickly and efficiently, and on commonly available hardware? +In this talk I will present how BioJulia has developed since 2015 and how we have addressed some of the challenges current Bioinformatics practices have presented us with. I will also talk about some of the directions Bioinformatics research (in particular genome assembly and multi-genome analyses) is heading, and where I think BioJulia development will be heading in anticipation of this comming “pan-genomics era”.
+ + ++
+ + +
+
+ + + Budapest University of Technology and Economics + +
+During investigation of dynamical systems, stochastic effects are often neglected, however stochastic excitations many times influence the behaviour of the systems. In case of applying deterministic models to approximate stochastic systems, during the identification process of system parameters usually their mean value is used as the parameter, while the measured variation is used to qualify the measurements. This approach often does not describe well enough the behaviour of the investigated system and leads to false results. +An example from mechanical engineering problems is machine tool vibrations, where the goal is to avoid vibration during the material removal process in order to ensure the best surface quality, while maintaining the highest possible material removal rate. The mathematical models, through which the dynamics of the machining is investigated are almost exclusively deterministic delayed differential equations. However, the forces originating from the cutting depend on a large number of factors (e.g. friction, high frequency changes in chip formation, material inhomogeneity), which gives the process a highly stochastic nature. +Another possible application is the investigation of traffic dynamics in the presence of vehicles equipped with connected cruise control (CCC), using vehicle-to-vehicle (V2V) communication. One goal of the corresponding researches is to avoid a phenomena called phantom traffic jam, during which spontaneous traffic jam forms without any accident or roadblock, due to the drivers’ large reaction times and limited perception range. The use of autonomous vehicles decreases the reaction times, but to gain beyond line of sight information one has to apply V2V communication. The simplest method for this technology is that each vehicle measures its position and velocity (e.g. with GPS and on board velocity sensors) and broadcasts it to the other vehicles. The broadcasted signal is received by the other vehicles, and they use this data to control their velocity. A challenge is that packet losses occur, which results in a “jerky” behaviour of the vehicle. To investigate the effect of the packet losses, usually deterministic packet loss patterns are used, introducing time-dependent time delay into the system. However, these packet losses occur stochastically, causing the time delay to be stochastic.
+ +To facilitate the investigation of the stationary behaviour of such systems, a Julia package was created. This package is able to handle stochastic delayed linear systems, which can be written in the following structure:
+ +\[\mathrm{d}\mathbf{x}_t = \left(\mathbf{A}(t) \mathbf{x}_t + \mathbf{B}(t) \mathbf{x}_{t-\tau(t)}\right)\mathrm{d}t +\left(\boldsymbol{\sigma}(t)+\boldsymbol{\alpha}(t)\mathbf{x}_t + \boldsymbol{\beta}(t) \mathbf{x}_{t-\tau(t)}\right)\mathrm{d}W_t,\] + +where $\mathbf{x}(t)\in \mathbb{R}^d$ is the $d$-dimensional state vector, $\mathbf{A}(t),\mathbf{B}(t),\boldsymbol{\alpha}(t),\boldsymbol{\beta}(t) \in\mathbb{R}^{d\times d}$ are deterministic, time dependent coefficient matrices, $\sigma(t)\in\mathbb{R}^d$ is the vector corresponding to the additive noise $\tau(t) \in \mathbb{R}$ is the time delay, which can change between discrete values stochastically. To model the stochastic effects in the parameters, the $W_t$ Wiener process is used. +The package is capable to compute moment stability and stationary $\lim_{t\to\infty}\mathbb{E}\left(\mathbf{x}_t\mathbf{x}_t^\top\right)$ second moment of the delayed system. Furthermore, the method is generalised to handle multiple time delays and stochastic excitations. One has to only supply the coefficient matrices and the time delay as functions of time, then the package calculates the mentioned stationary properties of the investigated system.
+ +Machine tool vibrations: +Conference proceeding at ASME, Homepage of the ERC SIREN project +Connected cruise control V2V communication: Book chapter on Springer.com
+ + +Henrik Sykora is a PhD student at the Budapest University of Technology. His main research topic is the investigation of the behaviour of linear stochastic delayed differential equations. After spending some time in Karlsruhe University of Technology and a few months in University of Michigan, he realized that even if there is a good mathematical method, it is worth few, if it cannot be used by others quickly and simply. That’s why he is striving to create a Julia package, with which he can give not only published results, but also a possible tool for others. +When he is not glued to a chair gazing at a computer screen, he tries to teach mechanics to mechanical engineering students, reads books about great and not so great (but nevertheless successful) people, and tries not to tap too much during his brazilian Jiu-Jitsu trainings.
+ + + +
+
+ + + GERAD, Montréal & INRIA Lille + +
+Power grids are evolving with the integration of distributed and renewable generation sources and with the possibility of exchange of information between consumers and the aggregator supplying them. We highlight an application of bi-level optimization for such situation involving a new energy tariff setting for residential consumers, implemented in Julia first as a black-box problem, then decomposed as a set of linear problems with JuMP.
+ + +Mathieu Besançon is a PhD student in a double program between Ecole Polytechnique of Montréal, Canada at GERAD, and the INOCS team at INRIA Lille, France. His research focuses on optimization in smart grids for the development of simple, robust and scalable Demand Response programs.
+ + + +
+
+ + + ETH Zurich, Switzerland + +
+The around 200’000 glaciers and ice caps around the world are projected to dominate global sea level rise up to 2100. Whilst air-borne and ground-based ice penetrating radar works very well, it cannot be applied to all glaciers. Thus to estimate their thickness methods based on remotely sensed surface data are needed. We present such a method based on a simple, semi-physical forward model based on mass conservation and basic ice physics and combine it with a Bayesian inversion approach. Using MCMC techniques we can estimate maps of ice thickness and their errors. The forward model is reasonably well tuned and can calculate a thickness map of a big glacier in less than 0.1s. The inversion is done using KissMCMC.jl which implements a Affine Invariant Markov chain Monte Carlo (MCMC) Ensemble sampler modeled after the Python emcee implementation.
+ + ++
+ + +
+
+ + + Dravyaniti Consulting LLP + +
+How often have we across trading strategies that work well in back-test, but don’t do as well after going live. Or they may do well, and then stop working abruptly. The problem is very challenging to deal with, especially when clients also start losing faith with the draw-down duration getting extended. What is, then a way to get the edge on your side? How to design effective systems which gain advantage of price moves when in favour, but go on the defensive when the markets are not in favour. This is a classic combination of combining defensive and attacking strategies simultaneously, to build highly effective systems. By combining price action and indicators on multiple time-frames, analysing larger chunks of data like a parallel processor would do, we can make more robust and profitable strategies.
+ +In the talk, I’ll be showing: +a) Guide-lines around how to select time-frames, and selection of indicators to apply on the different time-frames. +b) Compare and show some couple of examples from single time-frame systems v/s multi-time frame systems coded in Julia in different asset classes.
+ + +I have been involved in systematic trading for the past 10 years and developed over a 100 models across various frequencies i.e. high, medium and low, across global markets. Currently, I manage a suite of non-correlated strategies which are being used by Proprietary Desks, Hedge Funds, High Net Worth Individuals to manage their portfolio risks and generate absolute returns. A large part of the reason of our systems having survived is due to the usage of Multiple Time Frames in analysing market data, and using Julia to work with multiple Time-Series in parallel.
+ +I have coded in multiple languages using VBA, C++, Java, Python, Julia and have hands on experienced working on large scale complex projects for enterprises. I found trading systems to be the area that helps me use and apply multi-disciplinary skills and I continue to learn and develop on that. It’s a journey, which I believe is best lived by sharing ideas and continuously growing, learning from mistakes.
+ + + +
+
+ + + University of Luxembourg + +
+The COnstraint-Based Reconstruction and Analysis (COBRA) community is developing ever larger biochemical networks. Reconstructions with millions of biochemical reactions are on the horizon. The limits of traditional implementations in MATLAB, Python, or C, are reached when exploring such large networks, especially when performing the same analysis on thousands of these large models. +A main requirement for accelerating existing and new COBRA methods is a short development time and the ability to gain speedups with the convenience of writing code similar to Python or MATLAB while assuring parallelism across multiple nodes without traditional MPI- based languages. This is why the COBRA community turned towards Julia, and released the high-level, high-performance, and open-source COBRA.jl package. +DistributedFBA.jl [1], part of COBRA.jl, allows to perform a flux variability analysis or any of its related types efficiently, especially on large (up to 500’000 reactions) and huge-scale models (more than 500’000 reactions). PALM.jl [2] allows to launch analyses based on the COBRA Toolbox [3] across several computing nodes simultaneously, and this for hundreds of models. The COBRA Toolbox is a comprehensive software suite of interoperable COBRA methods written in MATLAB, which has found widespread applications in biology, biomedicine, and biotechnology because its functions can be flexibly combined to implement tailored COBRA protocols for any biochemical network. +Julia is the language of choice when it comes to accelerating analyses of large and huge-scale biochemical networks. With the COBRA.jl package, reconstruction and analysis of large and huge-scale models is made possible and accelerated.
+ + +Laurent Heirendt was born in 1987 in Luxembourg City, Luxembourg (Europe). He received his BSc in Mechanical Engineering from the Ecole Polytechnique Fédérale de Lausanne, Switzerland in 2009. A year later, he received his MSc in Advanced Mechanical Engineering from Imperial College London in the UK, where his research and thesis focused on developing a general dynamic model for shimmy analysis of aircraft landing gear that is still in use today. He received his Ph.D. in 2014 in Aerospace Science from the University of Toronto, Canada. He developed a thermo-tribomechnical model of an aircraft landing gear, which led to a patent pending design of a critical aircraft landing gear component. He then worked in industry and oversaw the structural analysis of large aircraft docking structures. Recently, Laurent started as a Research Associate at the Luxembourg Centre for Systems Biomedicine, where he works in the numerical optimization of large biochemical networks using Julia. Besides his mother tongue Luxembourgish, he is fluent in English, French, and German, and he is currently learning Brazilian Portuguese.
+ + + +
+
+ + + British Antarctic Survey + +
+Fisheries surveys are typically conducted using echosounders on research ships to estimate animal abundance and biomass. New unmanned, marine autonomous vehicles and underwater gliders are being used to increase spatial and temporal sampling, but existing acoustic processing software is inadequate for embedded, autonomous applications. +EchoJulia is a new, open source software library being developed at the British Antarctic Survey, Cambridge, UK as part of a PhD studentship. We found that the Julia programming language has enabled the same code to be used for embedded systems prototypes, desktop interfaces, and batch-mode, big data processing. +Rob will talk about his field work in the Southern Ocean, his decision to use Julia for acoustic data processing, as well as the resulting applications in acoustic noise removal and Antarctic krill swarm detection.
+ + +After a long career in the computer software industry, Rob Blackwell is now a PhD candidate at the British Antarctic Survey learning about Scientific Computing and Data Science applied to fisheries acoustics. It’s really just an excuse to hack Julia code.
+ + + +
+
+ + + University College London + +
+The global energy sector has now sustainability as one of its main objectives and solar technology is amongst the most viable options for a reliable and clean energy production. Reducing the cost of solar modules is a crucial element to increase the potential of such a solution. Solar cells are based on Transparent and Conductive Oxide (TCO) films, which can be produced via a process called Aerosol-Assisted Chemical Vapour Deposition (AACVD). Concisely, this process is based on sequential stages. Firstly, aerosol is generated from a solution containing TCO precursors. Then, the aerosol is transported to a heated chamber, where the solvent evaporates and the precursors deposit, forming the desired film. Not only can TCOs be produced by this process, but also composites, powders, coatings, nanotubes, etc.
+ +Although there is some research available in the literature reporting small scale experimental results of the AACVD technique, there is little about computational modelling. The latter would nevertheless be crucial for the design and scale-up of the AACVD. Consequently, we present an integrated model composed of aerosol generation, transport and delivery. For the aerosol generation, we predict the range of droplet sizes obtained via ultrasonic atomisation of the precursor solution. This is done using probability distributions, which become one of the inputs for the transport model. We can then predict the aerosol loss as a function of the properties of the droplets, the flow and the piping system. The model output shows the fraction of aerosol that reaches the heated chamber as well as its size range. It has been tested for a variety of scenarios, using different combinations of horizontal, inclined and vertical pipes. Finally, the solvent evaporation in the heated chamber is modelled, which depends mainly on the temperature profile of the site and the flow conditions. The precursors are now free to deposit and form the desired products. Uncertainty and sensitivity analyses are performed throughout the process.
+ +The stochastic aspects of aerosol generation, transport and delivery were incorporated using probability distributions. Experimental results were used to validate the model predictions for droplet sizes for the generated aerosol and the loss during transport. Through the formulation of an optimisation problem, the model presented has been used to suggest possible designs for the transport system, minimising the aerosol loss. This approach is suitable for transport distances on the scale of industrial processes. Other applications based on particle atomisation and transport, such as fuel combustion and spray drying or cooling, can also use the models presented here. Finally, the knowledge acquired while handling uncertainties in the modelling of the AACVD process has been used to plan a modelling framework based on Julia that will enable us to represent uncertainties and manipulate variables with uncertain values.
+ + +Pedro received his BEng in Chemical Engineering with first-class honours in 2015 from the Federal University of Minas Gerais (UFMG). He was part of the Scientific Initiation Program in Mathematics at the same university (2011-2014). He was a fellow of the Science without Borders program at McMaster University, Canada (2012-2013). In 2015 Pedro started his PhD studies at University College London, while maintaining hobbies like football, volunteering, activities related to the work of J. R. R. Tolkien and C. S. Lewis, etc.
+ + + +
+
+ + + Australian Institute for Machine Learning + +
+A central task in computer vision involves fitting parametric models to digitised images. In particular, given a collection of image feature locations, one seeks a set of parameters that describe a specific relationship between the image locations. Often the data-parameter connection takes the form of a system of equations, and the underlying estimation task falls into the category of non-linear heteroscedastic errors-in-variables regression problems. +I will present an approximate maximum likelihood cost function and concomitant numerical scheme which encapsulates a broad class of problems including conic fitting, optical flow, homography and fundamental matrix estimation; trifocal tensor estimation; camera calibration and three-dimensional rigid motion estimation. Thanks to Julia’s Unicode support and multiple dispatch capability I will be able to demonstrate a clear and concise implementation which embodies the various natural levels of mathematical abstraction that lead to generic code.
+ + +Zygmunt L. Szpak received his Ph.D. degree in Computer Science from the University of Adelaide, Australia, in 2013, and his M.Sc. degree in Computer Science from the University of KwaZulu-Natal, South Africa, in 2009. He is a senior research fellow at the Australian Institute for Machine Learning—an institute at the University of Adelaide. He works on numerous industry inspired computer vision problems. In the last couple of years, his work has focused on the application of machine learning and multiple-view geometry techniques for the development of smart medical devices.
+ + + +
+
+ + + + +
+Because scientific computing requires the highest performance, most science related libraries are written in C/Fortran and define a high-level API, most commonly in Python. Julia solves this “two-languages” problem, and also offers many more benefits. In my talk I want to focus on something that I consider a big, but often unstressed, asset of Julia: the fact that it brings unprecedented code clarity and intuition, both of which are crucial for scientific progress. I want to argue about how Julia removes “black-boxes” and “blind-trust” by allowing you to easily inspect and understand source code without being a developer. +The packages of the JuliaDynamics GitHub organization (currently: DynamicalSystemsBase.jl, ChaosTools.jl and DynamicalBilliards.jl) have been written to take full advantage of this asset of Julia. In my talk I will briefly overview them and show examples of how one can have a 1-1 correspondence between computer code and scientific thought and algorithms.
+ + ++
+ + +
+
+ + + University of Warwick + +
+Neurons in the brain are highly complex structures which are bombarded by randomly arriving synaptic inputs. Indeed, most of the time, neurons in the cortex fire due to random fluctuations and are in the “subthreshold regime”. Understanding how neurons behave in this noisy environment is important to understanding computation in the brain. My poster gives an overview of how I have used Julia for my theoretical models, numerical simulations and data analysis.
+ +Neurons are highly elongated with differences in synapses along their length, and I am interested in how the spatial properties of neurons affect their firing behaviour. Therefore, it is necessary to numerically solve stochastic differential equations in both space and time. Julia allowed me to create and run these simulations with little difficulty. Since I am interested in numerous random trials to calculate the average firing rate from a population of neurons, the relative ease of simple parallelisation in Julia has been very helpful to me. The profiling of simulations has also been very useful for finding inefficiencies and making my code run faster.
+ +A wide range of different neuronal parameters are typically explored during simulations, and it is therefore useful to save these parameters of a simulation in an easy to read manner with the simulation data itself. To this end, the HDF5 derived JLD file format has been invaluable. It has also been useful in restructuring real-world data obtained from experiments, in which I used various techniques to infer the parameters.
+ + +I am a second year PhD student at the University of Warwick currently doing research in computational neuroscience. Previously, I have done some research in thin film transistors and resistive memory. I have been using Julia for about 3 years now, when I used it to find all possible solutions to a puzzle.
+ + + +
+
+ + + Exegetic Analytics + +
+What are the minimum things you need to know to start applying Bayesian techniques in Julia? This talk will provide an entry level discussion covering the following topics:
+ +Andrew Collier is a freelance Data Scientist, working at the interface between Academia and Industry. He spends most of his time in R, Python, SQL and the BASH, but dabbles in a wide range of other technologies. He enjoys giving training and public speaking.
+ + + +
+
+ + + Institute for Economic Forecasting, Romanian Academy + +
+The presentation is based on the results in my forthcoming book “Introduction to Quantitative Macroeconomics using Julia” forthcoming at Academic Press. The presentation will deal first with general numerical techniques, covering techniques related to linear algebra, root finding or optimization based on available packages in Julia. The presentation becomes more technical in the second part, where I cover specific techniques employed in macroeconomics, but that can be used in related disciplines like finance, operation research, statistics, optimization: dynamic programming, simulation techniques, solving and simulating systems of stochastic difference equations. +The presentation will balance theory with applications in Julia and the code to accompany the book will be available online.
+ + +I am a Senior Researcher at the Institute for Economic Forecasting, Romanian Academy. I have a PhD in economics and I do research in quantitative modeling. I have published numerous papers in peer-reviewed journals.
+ + + +
+
+ + + City of London School + +
+This talk is about remote-control robots using by a Raspberry Pi, with code written in Julia. The motors and other peripherals are connected to the Raspberry Pi via the GPIO pins. This shows physical uses of Julia and teaches how to access motors and other elements attached to a Pi via GPIO in Julia. In addition, it also shows how to hack wireless third-party video game controllers in Julia. In this program, Julia will communicate wirelessly with the controller and control the motors and the other miscellaneous accessories of the robot. Julia will also process the images coming out of the robot’s camera.
+ + +I’m 12 years old and have a great interest in programming. I started coding in Scratch when I was 9 years old but I can now code in Python and Julia.
+ + + +
+
+ + + UNAM + +
+Getting started is hard. +As of yet, there is no standard “Practices and principles of Software design in Julia” canonical reference. +This talk seeks to add a resource to beginner steps STEM people face when starting with package development in design. +Yes, our manuals state explicitly how different functions work by themselves, but composing simple behaviors to build a tool and solve a problem is a rich and complex design space where no obvious answers exist. Adventurous early adopters haven’t necessarily slogged in this phase due to prior experience in other languages, but a repertoire of incremental handheld software design practices and principles is welcome. +This is where I find OrthogonalPolynomials.jl exciting. In a terse ~100 lines of code, one can produce arbitray order generalized canonical orthogonal polynomials that have a myriad of applications in numerical computing. This means that a vast amount of functionality can be obtained with very little Julia code through the simple use of multiple dispatch a little metaprogramming, and generated functions. +So OK, you can build a Julia package that has stellar functionality. This is not new - what is new is to produce documentation of the entirety of the design process in curated Youtube Videos and livestreams to answer questions about the increasing simplifications and tradeoffs of the design, and extending the conversation to the viewership is where I believe the added value for the Julia Community in this talk lies.
+ + +I am a Mexican physics student interested in the overlap of HPC and physics with the use of Julia. +I participated in competitive debating in HS and university, landed handstands all around the world and am a wannabe polyglot. +I enjoy climbing, reading long form foreign policy analysis, and building communities to care for those most vulnerable. +If you see my tweets, I’ve probably added you to the ever-growing list of Julia tweeters, and if you see my posts on Discourse, you will have probably seen my push for a growing resource for Spanish speakers diving into Julia. +To wanna see what I’m about, feel free to drop into my stream for some casual programming riffing on the speedrunning videogame community online. +(Although its probs best to wait until school is over.) +God bless summer!
+ + + +File not found
+ ++ The site configured at this address does not + contain the requested file. +
+ +
+ If this is your site, make sure that the filename case matches the URL.
+ For root URLs (like http://example.com/) you must provide an
+ index.html file.
+
+ Read the full documentation + for more information about using GitHub Pages. +
+ +
+
+
+
+
+
+
+
+ + + UFPR - Federal University of Paraná + +
+Linear programming is highly used for problem solving, since many real life applications can be well represented by minimizing costs under constraints, allowing the most efficient way to allocate and manage resources. This study is focused in the Simplex method, a linear optimization search method characterized by moving along the edges of the viable region while always decreasing the function value.
+ +The revised Simplex method was studied and implemented along with the LU update for performance improvement, aiming for the solution of large scale sparse problems. The method was implemented fully in the Julia Language and tested against the available solvers in the JuMP platform.
+ + +I’m an undergraduate chemical engineering student from Brazil. I love science and computational mathematics and hope to be working with research in the future.
+ + + +
+
+ + + Karlsruhe Institute of Technology + +
+Uncertainties and inaccuracies pervade all kinds of models that are derived from experimental data. Introducing random variables into the governing equations of a dynamical system is one way to describe the inherent uncertainty. A polynomial chaos expansion (PCE) of a random variable is a spectral representation in terms of an orthogonal polynomial basis and can be used as a technique for uncertainty quantification and uncertainty propagation. +This poster announces PCE.jl, a Julia Package for uncertainty quantification that was part of my masters thesis at the Optimization & Control Group at KIT, Germany.
+ + +Hey, my name is Florian and I’m from Karlsruhe, Baden-Württemberg, Southern Germany. I studied cognitive and computer science in Tübingen and Karlsruhe and next month I am starting a Phd in CS at KIT. I am interested in numerical computing, image processing and beer :) +I once climbed a mountain near Reykjavik while it was hailing and I will never do it again.
+ +My favorite member of One Direction is, of course, Louis Tomlinson.
+ + + +
+
+ + + University of Cambridge + +
+The goal of a Probabilistic Programming Language (PPL) is to make probabilistic modeling as composable and straightforward to use as Deep Learning (DL). A PPL enables domain experts to compose probabilistic models and perform inference, without having to worry precisely how inference happens. This is analogous to how DL frameworks let you compose various layers and learn their parameters, without having to worry about the details of how their gradients are computed.
+ +Unfortunately, a PPL that works well in practice is significantly harder to implement than a DL framework. This is because a PPL ultimately approximates high-dimensional integrals (hard), whereas a DL framework is concerned with computing high-dimensional gradients (easy-ish). There is, however, an edge case in which PP is easy: if all of the random variables in our programme are jointly Gaussian, then these high-dimensional integrals can be computed exactly. Perhaps surprisingly, by considering very large collections of jointly Gaussian random variables, known as Gaussian processes (GPs), we can construct a large class of useful probabilistic models for functions.
+ +In this poster I
+Will is a PhD student in the Computational and Biological Learning lab at the University of Cambridge, working on problems in probabilistic machine learning. He is particularly interested in Gaussian processes, automating Bayesian inference, and the use of machine learning to solve problems in climate science. When not working he can be found playing the guitar, or listening to people play it well.
+ + + +
+
+ + + University of California, Irvine + +
+Randomness and stochasticity are prevalent features of biological phenomena. Usually, experiments are repeated multiple times and the average results are taken to be indicative of the truth. However, I will show that the randomness in the data due to the experimental variation is not “just noise”, but rather a rich source of information. We will focus on retinoic acid signaling in the developing zebrafish hindbrain. There it will be demonstrated using stochastic differential equation models in via DifferentialEquations.jl that the protein crabp2a is able to control the level of biological noise without changing the mean values, a feature we will call mean-independent noise attenuation. We will describe how a very specific level of randomness in the retinoic acid signal is required for hindbrain segmentation to properly occur, and show that mean-independent noise attenuation causes crabp2a to act as a control knob to achieve the appropriate noise levels and allows the rhombomere boundaries to sharpen. Additionally, we will show that this information about the internal biochemical randomness constrains the possible models of hindbrain signaling networks, and use this to mathematically deduce the source of the random variation. Together, the audience should leave with an understanding that randomness may be far more insightful than the average behavior.
+ + +I am a mathematician and theoretical biologist at the University of California, Irvine. My programming language of choice is Julia and I am the lead developer of the JuliaDiffEq organization dedicated to solving differential equations (and includes the package DifferentialEquations.jl). My research is in time stepping methods for solving stochastic differential equations (SDEs) and applications to stochastic partial differential equations (SPDEs) which model biological development.
+ + + +
+
+ + + + +
+Healthcare, law enforcement, and regulatory bodies worldwide are working hard to keep up with the recent outpour of new designer drugs hitting the streets. The poster child of the phenomenon, fentanyl, is a notoriously addictive synthetic opioid with numerous potent derivatives, some deadly in milligram quantities. Quite a few of these are routinely encountered in drug samples throughout Canada, often mixed with various cutting agents. Drug overdose related to fentanyls took the lives of 2,861 Canadians in 2016 alone. +Whatever the appropriate response to the crisis, it would requires a new breed of analytical technique that can quickly differentiate between and quantify the many members of this growing zoo of opioids. To this end, a recent addition to the toolbox at Health Canada is nuclear magnetic resonance (NMR) spectroscopy, which studies the interaction between radiofrequency (RF) waves and atomic nuclei (typically hydrogen, i.e. proton) placed in a very strong magnetic field. The resulting spectra reflect the electronic/magnetic environment of each proton in a given chemical compound, giving an indication of its molecular structure. Although they provide a wealth of quantitative structural information about sample constituents, NMR spectra of complex mixtures are difficult to manually interpret, especially by non-experts. This is often the case with street drugs, where samples often contain 3-6 major components. +Luckily, the NMR spectrum of a mixture can often be approximated by the linear combination of those of its constituents. We have used this property to write a Julia program that, given the NMR spectra for various compounds of interest, uses this mathematical decomposition scheme to find the exact composition of an unknown mixture. As always, things do get more complicated since the above relationship is only approximately true. In reality, mixing different chemicals together slightly modifies each compound’s contribution to the overall spectrum. Still, we found it straightforward to prototype and implement more robust implementations of the algorithm in Julia that could deal with this added complexity. +The end result, NMR.jl, is the core project of the nascent JuliaNMR ecosystem on GitHub. NMR.jl aims to be a general-purpose NMR processing library and comes with state-of-the-art routines for automatic quantitative analysis of mixtures. Julia’s multiple dispatch semantics, excellent performance, and interactive development style allowed us to design much of the library in an exploratory manner and freely experiment with different ideas. +This talk gives an overview of NMR.jl and how its spectral decomposition algorithm is being used at Health Canada’s Drug Analysis Service. We hope to demonstrate the unique features of the Julia programming language that helped quickly prototype and implement NMR.jl and the custom automation routines around it, all without sacrificing performance. Aside from the language itself, we hope to credit the excellent Julia libraries (e.g. Plots.jl) without which NMR.jl would not have been possible.
+ + +Hessam Mehr is an electrical engineer turned synthetic chemist who graduated from the University of British Columbia last year and badly misses the good old days of graduate school. Between September 2017 and March 2018, Hessam was working with Health Canada to develop techniques for analyzing drug samples using nuclear magnetic resonance. Currently, he is a post-doc at the University of Glasgow where he continues to spend his free time biking, learning new human and computer languages, practicing calligraphy (not very well at all), and baking bread.
+ + + +
+
+ + + + +
+Burkitt’s lymphoma is a highly aggressive B-cell non-Hodgkin lymphoma that accounts for about half of all childhood cancers in areas of holoendemic malaria across Africa and Papau New Guinea. This rapidly growing malignancy has a cell doubling time of every 24-48 hours, suggesting that the tumor microenvironment plays an important role in tumor evolution and progression. To study the tumor microenvironment, we used Jupyter Notebook to implement a game theoretic, ordinary differential equation-based framework. We seek to understand the dynamics between lymphoma cells, fibroblasts, and macrophages using DifferentialEquations.jl. To this end, we parameterized our mathematical model using longitudinal cell-growth data from triple culture experiments with different initial conditions of each cell type, using MonteCarloProblem with Optim.jl and L1-Loss Regularization with PenaltyFunctions.jl. Julia’s platform provided a cohesive, easy to use environment, customizable to our specific problem, allowing us to easily estimate our model parameters simultaneously over 47 different growth conditions. From our parameter estimated, we could infer the biological interactions in the lymphoma tumor microenvironment. This will enable us to propose better detection and treatment strategies for lymphoma. Julia provided an integrated ecosystem which allowed us to use one single platform to create our model, estimate parameters from experimental data, and make predictions from in silico simulations.
+ + ++
+ + +
+
+ + + Fugro + +
+Fugro has collected huge amounts of data relating to the Earth’s surface and subsurface. Manual methods of classification are time-consuming and expensive. In the last year, we have developed algorithms using Julia to provide per-point classification of 3D point clouds using our own spatial feature libraries in combination with classifiers such as XGBoost. This work has been so successful that we’ve been able to provide detail about a range of real-world objects, such as buildings, roads, powerlines, vehicles and fences, to our clients without requiring expensive and slow human quality assurance processes. +In this talk I’ll discuss the machine learning algorithms we use, approaches for optimisation, data storage, and our greatest challenges and opportunities going forward.
+ + +Josh is a data scientist/engineer at Fugro, where he develops machine learning algorithms to model the world from lidar and imagery data.
+ + + +
+
+ + + Fugro Roames + +
+In many programming environments, user friendliness must be traded of with execution speed. Using abstractions or “generic” code may come with a run-time overhead. Avoiding abstract or generic code exposes the user to underlying details that they may not care about, making code harder to read and reason about at a higher level, reducing programmer productivity. Often two languages are even employed - one for rapid prototyping, and one for deployment.
+ +It doesn’t have to be this way. The Julia language has been carefully constructed to allow for many common abstractions to be dealt with statically at compile time and have a have a zero run-time cost. This workshop will cover the topic of “metaprogramming” in Julia, which plays a large role in providing for low-cost abstractions and generic APIs. Traditionally, a “meta” program is logic which executes at compile time to help generate the code of a resulting program - that is, it is code that generates other code.
+ +In this workshop we will cover the building blocks of metaprogramming in Julia, starting with one of its core concepts - multiple dispatch, which in combination with the type system is itself is a Turing-complete computational environment. We will then begin working our way to more advanced topics such as traits, macros, constant propagation and generated functions, following approximately this order:
+ +I am an algorithm and software engineer at Fugro Roames, applying machine learning techniques to big data in order to make sense of and to model the physical world. I have been using Julia since v0.3 for both research and commercial production-at-scale, and am the author of several Julia packages including StaticArrays.
+ + + +
+
+ + + Sorbonne Université + +
+Background Coevolution methods generate a growing interest in the scientific community due to its usefulness to predict the tridimensional protein structures, protein-protein binding interfaces and functionally important sites [1,2]. Mutual Information (MI) algorithm is useful for determining covariation or coevolving between positions in a Multiple Sequence Alignment (MSA). There is a great number of tools for estimating MI and derived scores from a MSA [3,4]. Although, none of them use a high level programming language, easy to use and modify, while having a good performance. As the Julia language is a high level programming language for scientific computing with a close to C performance [5], MIToS implements MI analysis and several useful tools for MSA and protein structure management in it. +Materials and methods MIToS starting point was an improvement of the algorithm published by Buslje et. al. [1]. Other MI derived scores described in Brown & Brown [3] and Dickson & Gloor [4] were also included in MIToS. MIToS implements all the necessary tools for developing and testing new scores based on amino acid frequencies: functions and types for dealing with MSAs, parsing protein structures and determine inter residue contacts, mapping information between sequence and structure using SIFTS and predictive performance testing using ROC curves. MIToS also allows running these analysis from a command line, without requiring programming knowledge. We successfully used it to integrate structural and sequence information from a protein family large dataset. +Results MIToS modules allow to write and run an entire protein sequence and structure analysis pipeline in a single programming language. Julia performance and easy to use parallelism allow us to run these analyses on a large dataset of protein sequence and structures and to test multiple hypotheses, parameter combinations, etc. As a result, we were able to create new knowledge about the relation between the evolutionary signals and the change of protein structures through the evolution [6]. +Conclusions MIToS allows users to access the the Julia language programming power for analysing and managing protein multiple sequence alignments. The implementation of several useful scripts in MIToS for command line execution allows acceding to this new MI implementations and its derived score to non-programmers. MIToS tools makes MSA editing and MI calculation easy and facilitates the integration of sequence and structure information. +References <ol type="1"> <li>Buslje, C. M., Santos, J., Delfino, J. M., & Nielsen, M. Correction for phylogeny, small number of observations and data redundancy improves the identification of coevolving amino acid pairs using mutual information. Bioinformatics 2009, 25(9), 1125-1131.
+I learned C at the university, then I did Bash, Perl, Python and R during the PhD. Now I’m a postdoc student doing Bioinformatics that has moved all its research pipeline into Julia. I think that Julia and its ecosystem are mature enough to do research with it. Also, MIToS shows how Julia can be used to solve the two/multiple language problem in Bioinformatics. MIToS also uses high-level abstractions that are possible in Julia to be faster than its C predecessor, even for someone without a strong programming background.
+ + + +
+
+ + + + +
+BayesTesting.jl implements a fresh approach to hypothesis testing in Julia. The Jeffreys-Lindley-Bartlett paradox does not occur. Any prior can be employed, including uninformative and reference priors, so the same prior employed for inference can be used for testing, and objective Bayesian posteriors can be used for testing. In standard problems when the posterior distribution matches (numerically) the frequentist sampling distribution or likelihood, there is a one-to-one correspondence with the frequentist test. The resulting posterior odds against the null hypothesis are easy to interpret (unlike p-values), do not violate the likelihood principle, and result from minimizing a linear combination of type I and II errors rather than fixing the type I error before testing. The testing procedure satisfies the Neyman-Pearson lemma, so tests are uniformly most powerful, and satisfy the most general Bayesian robustness theorem. +BayesTesting.jl provides functions for a variety of standard testing situations, along with more generic modular functions to easily allow the testing procedure to be employed in novel situations. For example, given any Monte Carlo or MCMC posterior sample for an unknown quantity, θ, the generic BayesTesting.jl function mcodds can be used to test hypotheses concerning θ, often with one or two lines of code. +The talk will demonstrate application of the new approach in several standard situations, including testing a sample mean, comparison of means, and regression parameter testing. A brief presentation of the methodology will be followed by examples. The examples illustrate our experiences with implementing the new testing procedure in Julia over the past year.
+ + ++
+ + +
+
+ + + + +
+Turning your Julia software into a compiled, portable application is simple. In only a few steps you can have your code compiled to run on any computer, even if your users have never heard of Julia. +We will use ApplicationBuilder.jl to build an application together, starting from scratch and ending with a complete, distributable application. +We will also discuss a few options for adding a GUI to your application. +After this talk, you will be empowered to write, compile, and sell software written in Julia!
+ + ++
+ + ++ + University of Cambridge + +
+Probabilistic programming is becoming an attractive approach to probabilistic machine learning. Through relieving researchers from the tedious burden of hand-deriving inference algorithms, not only does it enable the development of more accurate and interpretable models but it also encourage reproducible research. However, successful probabilistic programming systems require flexible, generic and efficient inference engines. In this work, we present a system called Turing for flexible composable probabilistic programming inference. Turing has an intuitive modelling syntax and supports a wide range of sampling based inference algorithms. Most importantly, Turing inference is composable: it combines Markov chain sampling operations on subsets of model variables, e.g. using a combination of a Hamiltonian Monte Carlo (HMC) engine and a particle Gibbs (PG) engine. This composable inference engine allows the user to easily switch between black-box style inference methods such as HMC, and customized inference methods. Our aim is to present Turing and its composable inference engines to the community and encourage other researchers to build on this system to help advance the field of probabilistic machine learning.
+ + ++
+ + +
+
+ + + + +
+For several years, Julia has been used as a tool of choice for several specialized courses around the globe. However, with V1.0 still in the works, using it as a teaching tool for massive (service) statistics courses bears some risks. Nevertheless, in a second year engineer statistics course, taught to a student body involving 500 students, we have used Julia and JuliaBox for two years consecutively. Through this experience, we have also developed an array of elementary to intermediate coding examples, each presenting a different aspect of probability, statistics, and the Julia language.
+ + ++
+ + +
+
+ + + Eindhoven University of Technology + +
+Scientific modeling concerns a continual search for better models for given data sets. This process can be elegantly captured in a Bayesian (probabilistic) inference framework. ForneyLab is an open source probabilistic programming toolbox that enables largely automated design loops by deriving fast, analytic algorithms for message passing-based approximate Bayesian inference. +Probabilistic programming extends conventional programming languages with the facility to compute rationally with random variables through probability calculus. ForneyLab is a Julia package that allows the user to specify a probabilistic model and pose inference problems on those models. In return, FL automatically constructs a Julia program that executes a message passing-based approximate inference procedure. In conjunction with a specification of (possibly streaming) data sources, the inference program can be executed to fit the model to the data. Additionally, ForneyLab provides a measure of the performance of the model fit, thus facilitating comparison to alternative models. Typical applications include the design of dynamic models for (Bayesian) machine learning systems, statistical signal processing, computational neuroscience, etc. +More specifically, a design cycle in ForneyLab consists of three phases. First, in the build phase, the end user specifies a (probabilistic) model. Through the use of macros, the model is specified in a domain-specific syntax that strongly resembles notational conventions in alternative probabilistic programming languages. Usually, even complex model specifications fit on less than one page of code. Under the hood, ForneyLab builds a Forney-style factor graph (FFG), which is a computational network representation of the model. A strong feature of the FFG formalism includes its extremely modular make-up, which allows re-use of computational inference primitives. The choice for FFG-based model specifications (and consequently, message passing-based inference procedures) is where ForneyLab differs from competing probabilistic programming languages (aside from our choice for a native Julia realization). +Next, in the schedule phase, the user specifies the inference problem. This is usually encoded by a few lines of code. ForneyLab then automatically derives a message passing algorithm that, when executed, computes the posterior marginal probability over the desired variables. The generated message passing code may contain thousands of code lines, depending on the size of the model. A clear asset of message passing-based inference algorithms is that they are comprised of many cheap and analytical updates that can be re-used across models, and furthermore can potentially be implemented on dedicated (parallel) hardware configurations. This contrasts to modern sampling-based approaches to inference, such as Markov chain Monte Carlo and Automatic Differentiation Variational Inference, which usually require massive computational resources. +In the final infer phase, ForneyLab parses and executes the automatically generated inference program. For the user, this action is initiated by one statement. Additionally, a separate function can be generated to evaluate the model fit, which provides insights on model quality and algorithm convergence during inference. +ForneyLab relies heavily on Julia’s meta-programming functionality. Not only does it use macros for the model specification, but the main output is also a Julia program by itself. This flexibility, together with benefits of the modular FFG approach, makes it a powerful tool for a scientist or engineer who wants to develop models for a given data set.
+ + +Thijs van de Laar received his MSc degree in natural sciences from the Radboud University Nijmegen in 2010. Currently he works as a PhD student in the BIASlab group (http://biaslab.org) at the Electrical Engineering department at Eindhoven University of Technology (TU/e). He is interested in Bayesian machine learning for personalized audio processing.
+ + + +
+
+ + + MIT Computer Science and Artificial Intelligence Laboratory + +
+The task of writing a complete library for linear algebra can be summarized as:
+I write algorithms to improve interfaces and automate performance engineering tasks in scientific computing. When I get distracted, I enjoy woodworking, glassblowing, burritos, and climbing. I am a second year computer science graduate student at MIT, and Department of Energy Computational Science Graduate Fellow.
+ + + +
+
+ + + + +
+SearchLight is an Object Relational Mapping layer for Julia. It exposes a concise but powerful API for database querying and persistence by simply manipulating Julia objects – while also packing a versatile DSL for database migrations, and a robust helper for data validation. It can future-proof your code with its transparent support for multiple backends (SQLite, MySQL, PostgreSQL, ODBC and JDBC) while implementing best practices with automatic user input escaping, support for environments, file generators, database seeding, logging and more. +SearchLight models are nothing but Plain Julia Objects so they can augment your existing codebase. Or they can be the foundation for building your next data-centric applications: SearchLight promotes a streamlined workflow through convention over configuration and handy generators. +It can also considerably reduce development time with its large set of built-in types and the wide support for CRUD operations. And if you need more control, you can always get down to the metal and run raw SQL queries or retrieve the underlying DataFrame results, through SearchLight’s lower level API. +Join me on a quick tour of the main features and learn how to use SearchLight to tame your databases!
+ + +Seasoned web developer on a quest to reinvent web development through Julia. Creator of Genie, the highly productive Julia web framework. Author of “Julia v1 By Example”.
+ + + +
+
+ + + + +
+During the talk I discuss how to use MersenneTwister pseudorandom number generator in-built into Julia in multi-threading computations. +It is divided into three parts:
++
+ + +
+
+ + + Julia Computing, Inc. + +
+Circuitscape is a widely used tool in landscape ecology. It borrows ideas from electronic circuit theory to predict connectivity in heterogeneous landscapes. We have re-implemented Circuitscape (originally a Python package) in Julia, providing a 4-8x benefit in speed and scalability. This talk will focus on two main thrusts: 1. The specific benefits that Julia provides over Python, and how that manifests in the end-user experience. The Julia package has several additional features as compared to the Python package: the ability to switch solvers seamlessly, single precision support, and the ability to provide parallelism on all three platforms (Mac, Linux and Windows). 2. How we developed a complete end-to-end product in pure Julia, from writing native Julia iterative solvers (AMG.jl) to packaging and shipping, including writing our own Windows installers.
+ + +Ranjan Anantharaman is a data scientist at Julia Computing. His interests span applied mathematics and numerical computing, and he enjoys working with computation across a variety of fields and domains.
+ + + +
+
+ + + Julia Computing, Koç University, and University College London + +
+Machine Learning (ML) is at its core the art of programming by data, rather than by hand, and ML has risen to become one of the most desirable skills in academia and industry. The common maxim is that two traits control who rules the ML landscape, ability to find and ingest more data and those that can innovate the quickest. Given these traits, we argue that Julia is uniquely poised as a very strong contender as the language for ML; as we allow for quick development cycles and offer unrivalled speed. After a quick introduction to the basics of ML, we will give the audience a description of the lay of the land in terms of libraries and frameworks in Julia, and finally proceed to build simple to complex models using the premier framework Flux. After attending the workshop the audience will be familiar with the basics of ML to avoid common pitfalls and be ready to tackle their own ML problems the Julian way.
+ + +Mike Innes is a software engineer at Julia Computing, where he works on among other things the Juno IDE and the machine learning ecosystem. He is the creator of the Flux machine learning library.
+ +Deniz Yuret is an associate professor of Computer Engineering at Koç University in Istanbul working at the Artificial Intelligence Laboratory, as well as a long-time Julia contributor and original creator of the deep learning framework Knet.
+ +Pontus Stenetorp is a senior research associate at University College London, where he spends most of his research time on natural language processing and machine learning.
+ + + +
+
+ + + U of Copenhagen + +
+Today’s ecologists rely increasingly on complex data analysis, and the ability to creatively define new analyses and design new computational tools has become a key component of ecological research. Ecologists generally rely on the R programming language for this, which has opened up exciting new possibilities, but also has inherent problems. Performance-critical functionality in R generally needs to be implemented in C or Fortran, making library code essentially a black box for scientific users. But more fundamentally there isn’t a strong culture for widespread collaboration on developing software tools in the ecological community, meaning that useful functionality is scattered across a fragmented package landscape. +Becaus of its combination of clear syntax and quick processing speed, Julia has the potential to solve these issues. Julia makes the development of efficient libraries easy for any researcher, and anyone familiar with the language can easily understand package code. But more importantly, Julia creates an opportunity to start from scratch, and develop a package ecosystem for ecology where different packages use the same types and interfaces. +We present the beginnings of such an infrastructure for ecological data analysis in Julia, that allows for an integrated and cohesive ecosystem of packages, without sacrificing the freedom of creating new packages with new implementations. We will also demonstrate the SpatialEcology package, which makes it easy to analyse ecological data in a split-apply-combine framework.
+ + +I’m a tenure-track professor at University of Copenhagen. I’ve used Julia since 0.4 and has used it for several published papers. I run EcoJulia together with Tim Poisot (Uni Montreal) with collaboration with Richard Reeve (Uni Glasgow). I’ve also been heavily invested in JuliaPlots in the past. Michael Krabbe Borregaard, MSc, PhD Assistant Professor (TT), Center for Macroecology, Evolution & Climate Natural History Museum of Denmark, University of Copenhagen Universitetsparken 15, DK-2100 Copenhagen Subject Editor, Ecography Associate Editor, Global Ecology and Biogeography Featured recent papers: Island biogeography: Taking the long view of nature’s laboratories, Science (2017) Oceanic island biogeography through the lens of the general dynamic model: assessment and prospect, Biological Reviews (2016). An Anthropocene map of genetic diversity, Science (2016)
+ + + +
+
+ + + San Francisco Bay Area + +
+To break cryptography is to solve mathematical puzzles, so Julia is perfect for the mission of attacking crypto. With this new use case, I would like to share what I discovered about Julia’s advantages and limitations. This includes: what are the kinds of crypto-puzzle-solving that Julia is best suited for? How is Julia used in building up these attacks? How would Julia be used for further cryptanalysis? +Some well-known but hard-to-get-right attacks I plan to share may include: block cipher cryptography (CBC) bitflipping attack, breaking fixed-nonce CBC in CTR mode, attacking a popular random number generator (RNG), breaking fixed-nonce XOR, and breaking stream cipher from a RNG. Want to see Julia in the wild in real-world hacking? Curious about how Julia functions in this not-so-common use case? This talk may be just right for you.
+ + +Helen does research and development at the intersection of cybersecurity and machine learning, solving problems and building solutions. Because she is not good at writing her own bio, she welcomes you to ask her in person about her stories, learnings, research, experiences, and evolution.
+ + + +
+
+ + + + +
+Abstract + Omega is a library for probabilistic and causal inference. It started with the question “How can we say what we want to say in probabilistic languages?”. More precisely, we wondered why frameworks for deep learning and probabilistic inference provide little support to add declarative knowledge to our models. For instance, we should be able to simply assert that our classifiers are robust from adversarial attack; that they and are algorithmically fair; that physical objects persist continuously through time, in order to make make object tracking more robust; that human and mouse models are similar, so that measurements from mice help us make better inferences about humans, where data is expensive. Omega is the culmination of a theoretical and engineering effort to address this challenge. In short, an Omega program is a normal Julia function augmented with uncertainty, and inference is execution of that function under constraints. The salient features that distinguish Omega from other approaches are:
++
+ + +
+
+ + + Epiq Solutions + +
+The existing Finite Impulse Response (FIR) filter design routines in the DSP.jl package are window based - a suboptimal technique that starts with an optimal L2 approximation to a desired response, and then applies a window to smooth out the ringing around the transition band. “remez” - the common name for the Parks-McClellan algorithm - is a better technique that gives much better control over the filter’s deviations from the desired response in the pass- and stop-bands. It designs FIR filters with optimal Chebyshev approximations to the desired response. In this talk I’ll provide an overview of the algorithm and efforts to include a pure Julia implementation in DSP.jl, and compare it to scipy’s C implementation.
+ + +I’ve been working in signal processing and wireless communications, doing software and system development for over 20 years. I worked 5 years at MathWorks (makers of MATLAB) between my MS and PhD, and 15+ years combined at Motorola and Epiq Solutions. I am coinventor on 15 issued US patents and have authored or coauthored over 20 conference and journal papers. I am on linked in and github. I gave a talk at my son’s High School AP CS class (click on a slide to zoom in, arrow keys to navigate) about computers and engineering that also includes some of my personal philosophy about learning and life.
+ + + +
+
+ + + University of Cologne + +
+Julia has the potential to become the major programming language in numerical physics. In this presentation I will share my personal story about how switching to Julia has improved my physics research as well as outline some issues I have encountered. I will explain how I replaced an opaque C++ quantum Monte Carlo code by a clean and simple Julia implementation. While showing similar performance in large scale simulations of so-called metallic quantum critical points the Julia code has an order of magnitude fewer lines and allows one to perform number crunching and analysis in the same framework. I will argue that Julia’s type system and multiple dispatch paradigm naturally leads to flexible code which can be used in many different projects. As an implementation of this idea, I will conclude by introducing MonteCarlo.jl, a new package for simulating physical systems such as spin models and itinerant fermions by various (quantum) Monte Carlo flavors.
+ + +Carsten is a Ph.D. student in the theoretical physics department of the University of Cologne working on quantum criticality in metals. He studied physics and computer science at the Goethe University Frankfurt, the University of Florida, and the TU Darmstadt.
+ + + +
+
+ + + Fugro Roames + +
+In this talk I will identify some commonly occurring data manipulation tasks, and introduce strategies to deal with them concisely and generically. By the end, you will be equipped with the tools to
+I am an algorithm and software engineer at Fugro Roames, applying machine learning techniques to big data in order to make sense of and to model the physical world. I have been using Julia since v0.3 for both research and commercial production-at-scale, and am the author of several Julia packages including StaticArrays.
+ + + +
+
+ + + University of South Brittany + +
++
+ ++
+ + +
+
+ + + Domo + +
+Domo is the operating system for your business. Bring all your data into one place, transform it, and start getting real insights and value out of it. Automatically generating insights on petabytes of Fortune 500 data is no trivial task, so we turned to Julia for a solution that has performance, scale, and most importantly, statistics close to the heart. +Come learn about our custom Julia stack: how it came together, what we’ve learned scaling it, and how we’re leveraging it to bring automatic insights to Domo users.
+ + +Attended Carnegie Mellon for a master’s degree in data science and active Julia contributor for 4 years now.
+ + + +
+
+ + + Ministry of Social Development, Mexico + +
+Complex Network Analysis of Political Data The Mexican Senate was recently awarded for fulfilling its transparency obligations, meaning that a vast amount of information is on their website. The problem is that the way in which they present it is largely uninformational so a complex network approach is proposed to study the dynamics of the given system. +We use Cascadia package and Julia’s parallelization capabilities in order to scrap the data that we consider useful for our research and export it to the graph oriented database Neo4j and make an exploratory data analysis for attendancy and voting patterns. Using LightGraphs package we build a temporal weighted network and apply a self developed algorithm for community detection in order to study coalition dynamics. Finally we make use of RCall to build a visualization that represents such dynamics through an alluvial diagram getting interest insight such as party switching and opposite parties coalitions. +As we want to make this as automatic and portable as possible, everything runs in Docker containers and is orchestrated via Docker Compose and a Luigi Pipeline. That gives us the opportunity to enlarge and analyze new information automatically once a week.
+ + +Musician who studied Physics and Data Science. Currently working at the Ministry of Social Development in Mexico using data science to focalize aid to those with greater needs.
+ + + +
+
+ + + Imperial College, London + +
+This workshop proposal brings together 4 speakers on different topics in numerical analysis. The aim of the workshop is to have demonstrations of Julia packages in this area in a way to motivate the results to a “general” audience. Our speakers cover a variety of areas to give a broad demonstration of what is now possible using Julia.
+ +ApproxFun.jl, Approximating Functions and Solving Differential Equations +Sheehan Olver, Imperial College, London
+ +ApproxFun.jl is a Julia package that makes working with functions on a computer fast and easy. Basic algebra and calculus operations are available, so that one can, for example, differentiate the function $\sin\cos^2 x$ as easy as typing sin(cos(x)^2)'. Further capabilities include solving differential equations and random number sampling. This talk will demonstrate the capabilities of ApproxFun, and how Julia’s approach to typing allows for these capabilities to be used with other types, such as Dual numbers (from DualNumbers.jl) or BigFloats.
ValidatedNumerics.jl, Rigorous Floating-point Calculations with Interval Arithmetic +David P. Sanders, Universidad Nacional Autónoma de México
+ +I will present a suite of Julia packages in the JuliaIntervals organisation which provide implementations of numerical methods that provide results that are guaranteed to be correct. These are based on interval arithmetic, i.e. defining arithmetic and elementary functions acting on intervals of real numbers.
+ +This gives us a tool to calculate with continuous sets of real numbers, and thus rigorously bound the range of a function over a given set. Applications of this technology include finding, in a guaranteed way, all the roots of a multivariable function in a given region of space, and finding the global optimum of a function.
+ +FastTransforms.jl, Fast Orthogonal Polynomial Transforms +R. Mikael Slevinsky, University of Manitoba
+ +FastTransforms.jl allows the user to conveniently work with orthogonal polynomials with degrees well into the millions. Transforms include conversion between Jacobi polynomial expansions, with Chebyshev, Legendre, and ultraspherical polynomial transforms as special cases. For the signal processor, all three types of nonuniform fast Fourier transforms available. As well, spherical harmonic transforms and transforms between orthogonal polynomials on the triangle allow for the efficient simulation of partial differential equations of evolution. Algorithms include methods based on asymptotic formulae to relate the transforms to a small number of fast Fourier transforms, matrix factorizations based on the Hadamard product, hierarchical matrix decompositions à la Fast Multipole Method, and the butterfly algorithm.
+ +MatrixDepot.jl, Testing Linear Algebra Algorithms in Julia +Weijian Zhang, University of Manchester
+ +Test matrices are important for exploring the behavior of linear algebra algorithms and for measuring their performance with respect to accuracy, stability, convergence rate, speed, or robustness. We give a brief historical remark on the development of test matrices in different programming languages and then focus on the advantage of using MatrixDepot.jl for testing and exploring new algorithms in Julia. Using both contrived and real-world examples, we demonstrate the power of MatrixDepot.jl which takes advantage of many nice Julia features, such as using multiple dispatch to help provide a simple user interface and to allow matrices to be generated in any of the numeric data types supported by the language.
+ + +I am a Reader (equivalent to Assoc. Professor) in Applied Mathematics and Mathematical Physics at Imperial College, London. My research is in numerics, in particular spectral methods and complex analytical methods. I have extensive experience with programming Julia, having developed several packages (ApproxFun.jl, BandedMatrices.jl, BlockBandedMatrices.jl, etc.).
+ + + +
+
+ + + + +
+Memento is a logging library for Julia designed for software systems and cloud applications. It’s the ideal choice in Julia for monitoring large, multi-component applications as it gives users control and flexibility over all aspects of logging for each component. +Memento’s main features:
++
+ + +
+
+ + + + +
+The same unique feature set that makes Julia great for a variety of numerical domains makes it the best choice today for implementing a general-purpose symbolic math language. I’ll begin with a brief zoology of symbolic math languages, and explain why I am interested in those that focus on giving the user great flexibility in rewriting essentially meaningless symbolic expressions. I’ll give an overview of the distinct achievements of the projects in the Julia community that share this focus. Symata.jl is the most highly developed of these projects. I’ll show how Symata.jl provides another example of how the astonishing productivity of the Julia ecosystem allows one to compete with industry heavy-weights, and opens possibilities that are closed to these existing systems.
+ + +John Lapeyre has worked in industry in device physics and data science, and in academia in statistical physics. Before working on symbolic math in Julia, he was a developer for the Maxima computer algebra project.
+ + + +
+
+ + + Relational AI + +
+Computer system software, like operating systems, database management systems, or video game engines, has traditionally been implemented in low-level programming languages like C or C++. There are good reasons for this: among them, systems programmers must routinely cope with resource constraints dictating low-level control over memory layouts and memory management. Such concerns are some of the very ones that productivity languages like Julia seek to hide from view.
+For example, consider the venerable B+-tree, which has been used for decades in database systems, file systems, and elsewhere. A B+-tree is a tree-structured index (over, say, file system metadata or SQL tables) aiming to minimize disk I/O for datasets too large to fit in main memory. It achieves this by using large nodes, sized to some multiple of operating system pages, with wide fanout. Because nodes are so wide, the tree is very shallow, and searching from root to leaf incurs just a few disk I/Os. Here’s a picture from Wikipedia (in a real B+-tree, the nodes would contain thousands of entries each and have more intricate internal structure):
+
B+-tree In a student project, B+-trees could be implemented in a straightforward way, with e.g. search through a node done by deserializing the page’s contents into appropriate heap-allocated data structures in the host language, and then working with those data structures. In a real implementation, however, this is considered unacceptably slow and resource-intensive; instead the page itself is simply “cast” to a C/C++ data structure, for example, and worked with directly. Systems languages are distinguished by their capability to support this style of programming.
+At the same time, systems programmers are painfully aware of the productivity limitations of languages like C/C++, and recurrent attempts have been made over the years in nearly every systems context to experiment with the use of higher-level languages. Indeed, the most famous and successful example of this is C itself, which replaced assembly language as the “high-level” systems alternative of its time.
+Recently, in database systems, the use of query compilation (on-the-fly compilation of ad-hoc SQL queries into machine code) has become more or less ubiquitous in high-performance systems. The pain of implementing query compilation in a traditional systems language like C/C++ has motivated researchers to explore the use of higher-level languages like Scala, equipped with staged code generation libraries like LMS or Squid, in order to build high-performance systems prototypes.
+In such a context, Julia presents an intriguing alternative, due to its excellent performance and well-developed staged metaprogramming facilities. But if we want to build a full-blown database system in Julia, can we also implement low-level data structures like B+-trees in a way that is both idiomatic to Julia (and therefore productive), but also efficient?
+In this talk, we answer this question in the affirmative, by showing how such data structures can be implemented with help from a recently-developed package called Blobs package. Blobs (see also ManualMemory) uses Julia metaprogramming techniques to make it easy and efficient to lay out complex data structures within a memory region, such as an OS page. Data structures are defined as ordinary isbits Julia structs, and can have rich nested structure. Rather than give examples here, take a look at the package overview.
+We’ll give a quick and self-contained overview of the necessary background on paged data structures, and then show how to use Blobs to implement such data structures natively in Julia.
+B+-trees are a bit old-fashioned nowadays, so time allowing, we may also try to cover an example of a more recent paged data structure, the Bε-tree. This data structure allows a precisely tunable tradeoff between read- and write-performance, and has been used recently in advanced database systems (TokuDB, LogicBlox) and file systems (BetrFS).
T.J. Green is a Computer Scientist at Relational AI. Previously, he was a Computer Scientist at LogicBlox, and an Assistant Professor at UC Davis. He received his B.S. in Computer Science from Yale University in 1997, his M.S. in Computer Science from the University of Washington in 2001, and his Ph.D. in Computer and Information Science from the University of Pennsylvania in 2009. His awards include Best Student Paper at ICDT 2009, the Morris and Dorothy Rubinoff Award in 2010 (awarded to the outstanding computer science dissertation from the University of Pennsylvania), an honorable mention for the 2011 Jim Gray SIGMOD dissertation award, an NSF CAREER award in 2010, and Best Paper Runner-Up at ICDE 2012. Prior to beginning his Ph.D., he worked at Microsoft as a Software Design Engineer and Development Lead, and at Xyleme as a Software Design Engineer.
+ + + +
+
+ + + Warsaw School of Economics + +
+In this presentation performance of Julia in-built parallelism will be demonstrated on Cray supercomputer (Okeanos - https://www.top500.org/system/178753) vs a cluster of AWS Spot Fleet instances. For illustrative purposes a massively parallelized version of the classical Schelling (1974) segregation social model will be used. Scaling of the parallelized simulation from 400 up to 4096 cores will be discussed and compared. I will also share my experience about those small details that you should know before trying to setup a Julia cluster on AWS and a Cray.
+ + +Przemyslaw Szufel is an Assistant Professor in the Decision Support and Analysis Unit at the Warsaw School of Economics, Poland. His current research focuses on distributed systems and methods for execution of large-scale simulations for numerical experiments and optimization. Dr. Szufel is currently working on asynchronous algorithms for the parallel execution of large-scale computations in the cloud and distributed computational environments.
+ + + +
+
+ + + Julia Computing + +
+Everyone here has a hidden superpower: you know how to code! Given the right situations, this can serve as a powerful tool to shape public discourse as citizen scientists. +Following several cyclist fatalities around the University of Pittsburgh, there was a strong advocacy movement for improved traffic safety. I was curious about the raw data underlying the issue, so I put together a Julia notebook that processed a short video of the traffic through campus and calculated each vehicle’s speed. Given more time I could have put together a thorough study, but this was enough: a local bicycling advocacy group picked up the story, leading to a blog post, newspaper story, and several radio interviews. I was just one more voice, but connecting with a non-profit amplified and unified the call for change. Since then the road has been re-designed with an emphasis on bicycle and pedestrian safety. +This talk will focus on the key takeaways from my interactions with an advocacy nonprofit and local community, and what I believe made it a compelling story. I’ll have some key pointers on how you might be able to find success with your own project.
+ + +Matt Bauman is a Senior Research Scientist at JuliaComputing at their Chicago outpost, where he spends lots of time working on Julia’s arrays. He’s been contributing to both the core language and multiple packages since 2014. At his previous position as a Data Science Fellow at the University of Chicago’s Center for Data Science and Public Policy, he longed for dot-broadcasting in Python. He recently defended his PhD dissertation in Bioengineering from the University of Pittsburgh, focusing on neural prosthetics.
+ + + +
+
+ + + The National Institute of Engineering, Mysore + +
+The Minecraft API allows us to communicate with the Minecraft world to do simple things like placing blocks and teleporting players. This is functionality is enough to do big and beautiful projects in no time. A talk on building using Julia and some fun stuff like playing “Snake” using a Joystick connected to the Raspberry Pi GPIO pins inside the Minecraft world. This package is a great way to introduce kids to Julia and computer programming in general. +A lot of functionality is being worked on right now. This includes a dozen building tools accompanied with guides. The work will be completed well before JuliaCon.
+I am a Google Summer of Code Student working on the PiCraft.jl package for Julia. Currently a 2nd year student studying Computer Science at “The National Institute of Engineering, Mysore”.
+ + + +
+
+ + + + +
+Julia’s interactivity and just-in-time (JIT) compilation are major assets for developers; however, as codebases grow larger, compilation time becomes a burden on the write-test-debug cycle. While the ultimate answer might be faster JIT-compilation, an alternative is to compile less often: specifically, to do more useful development per unit of compilation. This necessitates the ability to fix bugs—and test these fixes—interactively without restarting Julia. Until relatively recently, this was difficult especially for highly-modular projects involving many packages, where the right fix might lie at a deep layer in the package hierarchy. Fortunately, recent work in base Julia laid the groundwork for a more efficient approach in which functions can be arbitrarily redefined and their dependencies recompiled; however, to use this capability one had to re-evaluate these functions manually. +I will describe a package, Revise.jl, that automates much of the work of the test-debug cycle. Revise scans “active” source files for changes and automatically updates function definitions in a running Julia session. In this talk I will describe the main things Revise can and can’t do, explain some of the strategies that Revise uses to limit the amount of code that needs re-evaluation, and emphasize some of its new capabilities present only in Julia 0.7/1.0.
+ + ++
+ + +
+
+ + + Rutgers University + +
+In order to analyze real-world, tabular data, it needs to be transformed into a suitable numerical format. The @formula domain-specific language in StatsModels.jl provides a way to specify table-to-numerical array transformations. This DSL was inspired by R and should be familiar to Julia users who have experience with R, but Julia has unique strengths and constraints. In this talk, I’ll talk about recent, ongoing, and future developments of a distinctly Julian formula DSL. Some of these make the formula more flexible and useful for users, like using metaprogramming to provide performant support for arbitrary Julia code in a formula, and support for any type of tabular data store (including streaming and out-of-core datasets), using NamedTuples as a common interchange format. But equally important are changes under the hood to make the formula DSL more useful and extensible for package developers. These changes draw on unique language features like multiple dispatch to allow packages to extend the formula syntax at multiple levels, from low-level details of how the underlying formulae expressions are parsed, to high-level specialization of the conversion from formula parts to specialized types of model matrices (as in MixedModels.jl). Together, this makes the formula DSL a solid foundation for building general purpose data analysis and modelling tools that can be applied across a variety of domains and data sources.
+ + +Like many before and after him, Dave started hacking on Julia to procrastinate finishing his dissertation. Despite his best efforts he finished his PhD in Brain and Cognitive Sciences in 2016. In his day job as an Assistant Professor of Psychology at Rutgers New Brunswick, he works on understanding how people understand spoken language with such apparent ease, combining behavioral, computational, and neural approaches. Otherwise he’s committed to promoting open, reproducible science, and designing tools that empower researchers and lower the barrier to entry for data analysis and statistics.
+ + + +
+
+ + + KLS Gogte Institute of Technology, Belgaum + +
+Brain Computer Interface and Internet of Things are the two sides of a river. On one side, we have Internet of Things which connects electronic gadgets used in our daily life. On the other side we have, Brain Computer Interface which is still in its infancy, but has shown great potential to influence our lives. We made an attempt to build the bridge between Brain Computer Interface and Internet of Things with the help of Julia programming language and achieved satisfactory results. For our experiment we used Raspberry Pi, muse a consumer grade electroencephalography device, sensors, lab streaming layer library written in Python, JuliaBerry package for programming GPIO pins of Raspberry Pi using Julia. +The process followed for performing the experiment is described below: +Step 1: Prepare Raspberry Pi 3 by Installing and Configuring necessary, Python and Julia software packages for Raspberry Pi like JuliaBerry, PiGPIO.jl, pylsl. +Step 2: Connect Raspberry Pi with Muse EEG device via Bluetooth. +Step 3: Record raw EEG signals from muse brain sensing device using pylsl lab streaming layer library written in Python. The signal processing of raw EEG signals includes filtering, feature extraction, noise reduction and spike classification techniques and implemented in Julia. +Step 4: Interface Raspberry Pi and devices in home environment. +Step 5: Based on neural activity of brain i.e., brainwave measurement of concentration, Julia programs perform variety of tasks such as control devices at home, play prerecorded audio file. +We believe that the above application is useful to people who are suffering from medical conditions such as Paralysis and Laryngeal Surgery by helping them controlling the devices, generating voice input commands and voice output through EEG signals.
+ + +Mr. Gajendra Deshpande holds a masters degree in Computer Science and Engineering and working as Assistant Professor at the Department of Computer Science and Engineering, KLS Gogte Institute of Technology, Belgaum, Karnataka, India. He is pursuing Ph.D. under the guidance of Dr. S.A.Kulkarni at VTU, Belagavi. He has a teaching experience of 10 years and Linux and Network Administration experience of one year. He is winner of Smart India Hackathon 2018. He is Technical Director for Sestoauto Networks Pvt. Ltd. and Founder of Thingsvalley. His areas of Interest include Programming, Web Designing, Artificial Intelligence, Machine Learning, Brain Computer Interface, Internet of Things and Virtual Reality. Dr. S.A.Kulkarni is working as Associate Professor at Vellore Institute of Technology, Vellore, Tamil Nadu, India. He has a Ph.D. in faculty of Computer and Information Science from National Institute of Engineering Research Center under Visvesvaraya Technological University. He loves pursuing certifications and has done many online MOOC and related courses. He is an avid writer and enjoys writing research papers, technology and programming related articles in journals and computer magazines.
+ + + +
+
+ + + + +
+The problem of sailing craft route optimisation involves considering a range of stochastic factors, from weather model used to prediction of performance and structural failure. This research introduces the sailing craft routing problem as a bi-level optimisation problem, with the leader problem being the route optimisation problem and the follower problem being the speed attainable at different reliability levels. The key issue is of how to model these stochastic factors. I use Julia exclusively due to its speed and the ability to rapidly develop code. +In this talk I will introduce how I generate probabilistic temporal weather models. From these I am able to generate weather scenarios. To reduce computational running time I identify a representative collection of scenarios through comparing based on comparing probability metrics, solved using JuMP. I then show how I use monte carlo simulations to model the reliability of a sailing craft and then optimise the route using a recursive algorithm. +This talk will demonstrate how I solve many optimisation and statistical problems which are common across engineering and scientific disciplines with respect to modelling and solving stochastic optimisation problems. As a result it has broad appeal across the scientific modelling community with a specific application in an unusual and interesting area.
+ + ++
+ + +
+
+ + + University of California, Berkeley + +
+This talk will give an update on the current state of the Queryverse. I will highlight packages for file IO (CSVFiles.jl, ExcelFiles.jl, StatFiles.jl, FeatherFiles.jl, ParquetFiles.jl), querying and manipulating data (Query.jl), visual data exploration (DataVoyager.jl) and graphics (VegaLite.jl). I will show how all of these pieces are designed to work together and provide a unified API for users that spans traditional tabular data and data in custom julia types. I will also highlight how the Queryverse integrates smoothly with all the other julia packages in this space.
+ + +David Anthoff is an environmental economist who studies climate change and environmental policy. He co-develops the integrated assessment model FUND that is used widely in academic research and in policy analysis. His research has appeared in Science, the American Economic Review, Nature Climate Change, the Journal of Environmental Economics and Management, Environmental and Resource Economics, the Oxford Review of Economic Policy and other academic journals. He contributed a background research paper to the Stern Review and has advised numerous organizations (including US EPA and the Canadian National Round Table on the Environment and the Economy) on the economics of climate change.
+ +He is an assistant professor in the Energy and Resources Group at the University of California at Berkeley, a senior fellow at the Berkeley Institute for Data Science and a University Fellow at Resources for the Future. Previously he was an assistant professor in the School of Natural Resources and Environment at the University of Michigan, a postdoc at the University of California, Berkeley and a postdoc at the Economic and Social Research Institute in Ireland. He also was a visiting research fellow at the Smith School of Enterprise and the Environment, University of Oxford.
+ +He holds a PhD (Dr. rer. pol.) in economics from the University of Hamburg (Germany) and the International Max Planck Research School on Earth System Modelling, a MSc in Environmental Change and Management from the University of Oxford (UK) and a M.Phil. in philosophy, logic and theory of science from Ludwig-Maximilians-Universität München (Germany).
+ + + ++ + Universidad Nacional Autonoma de Mexico andUniversidad Nacional Autonoma de Mexico + +
+We will show how to use Julia to approximate functions in a rigorous way: find a truncated Taylor series that is close to the function, using automatic differentiation techniques provided by the TaylorSeries.jl package. Next, bound the error from truncating the series, using intervals from the IntervalArithmetic.jl package. The resulting object is a Taylor model, as provided by the new TaylorModels.jl package. +We can now perform rigorous calculations on functions, e.g. multiplying two functions or finding sin(f) for a function f, by manipulating the corresponding Taylor models. This has many applications, for example global optimization: we can find rigorous optima of arbitrary functions by optimizing a polynomial instead, which is easier (although not “easy”). +We will focus on showing how Taylor models can be used as a building block to solve ordinary differential equations (ODEs): find a Taylor series expansion of the solution to the ODE and bound the error. This gives approximations to the solution, in the form of tubes that are guaranteed to enclose the true solution of the ODE.
+ + +David P. Sanders is associate professor of computational physics in the Department of Physics of the Faculty of Sciences at the National University of Mexico in Mexico City. His previous Julia tutorials on YouTube have a total of more than 80,000 views. He is a principal author of the packages in the suite of packages for interval methods.
+ + + +
+
+ + + + +
+In this talk, I will highlight StateSpaceRoutines.jl, a repository containing state space filtering and smoothing methods such as the Kalman filter, Durbin Koopman smoother, and others. Specifically, I will discuss our latest addition to StateSpaceRoutines.jl, the “tempered particle filter” (TPF) which was developed by Ed Herbst (Federal Reserve Board of Governors) and Frank Schorfheide (University of Pennsylvania). TPF provides a robust way to simulate the distribution of the states and to calculate the likelihood in a general state space model. Furthermore, I will explain why TPF produces more accurate approximations than the standard bootstrap particle filter, and provide some results showing this. Because TPF is an inherently parallelizable algorithm, I will also delve into some details of the computational implementation and some lessons that we have learned along the way about Julia’s parallel framework. I will highlight a few issues we are still currently facing with regards to optimizing the performance of TPF. StateSpaceRoutines.jl should prove useful to economists, statisticians, and those generally interested in Bayesian methods as a stand-alone suite of tools, which can be used to estimate a variety of both linear and non-linear state space models. Lastly, I will briefly highlight the NY Fed DSGE team’s recent work on implementing various kinds of heterogeneous agent models, both in discrete and continuous time, and discuss the relevance of our implementations of TPF and other sequential Monte Carlo methods to estimating these models in the future.
+ +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.
+ + +Michael Cai is a recent graduate of NYU and a senior research analyst working on dynamic stochastic general equilibrium (DSGE) models at the New York Fed. I am interested in using Julia to make the research and policy work at the New York Fed more performant, extensible, and beautiful. More broadly, I want to engage in the frontier of economic research to produce actionable public policies and to improve effective governance and societal welfare.
+ + + +
+
+ + + + +
+JuliaDB is a library for tabular data manipulation (either in memory or out of core) that is recently becoming more and more popular. To simplify the JuliaDB user experience , I have designed the metaprogramming based package JuliaDBMeta . JuliaDBMeta, starting from a user provided expression with symbols corresponding to fields, detects which columns of the dataset will be used and what anonymous function will be applied to them, then proceeds to iterate data only from the relevant columns and compute the relevant transformation. All operations can be concatenated and can then be piped in a plotting command using StatPlots. +To maximally simplify the user experience, we try to support both grouped data and out of core data as much as possible out of the box. All column based macros have an optional grouping argument, whereas all row-based macros work out-of-core out of the box. Furthermore special macros are provided to apply a pipeline separately on each processor (or on each group) and then join the results together.For users preferring a more graphical environment, the packages InteractBase and TableWidgets allow to define, select and compose data manipulations and visualizations interactively in a web-based UI with immediate visual feedback.
+ + ++
+ + +
+
+ + + The University of Manchester + +
+In this talk, we present EvolvingGraphs.jl, a Julia software package for working with time-dependent networks. Many modern real-world networks are time dependent. Consider a group of online users interacting through messaging. Each message sent from user A to user B at time stamp t can be represented as an edge from A to B at time stamp t in an evolving graph. Ignoring the direction of time in a network flow can result in wrong information. However, it is difficult for researchers to model and study the evolving nature of such networks using traditional graph software package. EvolvingGraphs.jl is designed to meet this need. The source code is available at: https://github.com/EtymoIO/EvolvingGraphs.jl. We discuss the structure of EvolvingGraphs.jl and demonstrate a real life use case: tracing the development of ideas in research literature.
+ + +I am a fourth year PhD student in Numerical Analysis at the University of Manchester and I was a visiting student at MIT Julia Lab. I am the creator of EvolvingGraphs.jl (https://github.com/EtymoIO/EvolvingGraphs.jl) and MatrixDepot.jl (https://github.com/JuliaMatrices/MatrixDepot.jl).
+ + + +
+
+ + + + +
+Have you ever wondered how Julia dispatches method calls? As an answer, have you been pointed to a mysterious .c file in the source tree understood by at most five people on Earth? Are you afraid of complex type annotations? If yes, do not wonder anymore. This talk will be a friendly walkthrough across the rules that govern subtyping, the relation at the very core of method dispatch. We will start from the basics and we will build intuitions to grasp the intricate but unavoidable interactions between the various features of Julia type system. As a result you won’t be afraid to rely on the most advanced features of Julia type system anymore, and won’t be puzzled by runtime error messages or odd dispatch behaviors ever again.
+ + ++
+ + +
+
+ + + + +
+Many disciplines of science involve mathematical modeling of phenomena with dynamic systems. The general trend is to model complex dynamical systems through the use of differential equations. These differential equation models often have non-measurable parameters such as planetary masses or chemical reaction rates. The “forward-problem” of simulation consists of solving the differential equations for a given set of parameters. The “inverse problem” or parameter estimation in this case, is the process of using data to determine these model parameters. The inverse problem has been heavily studied in certain fields as has already been presented in the case of Geophysics in the previous JuliaCon with jInv.jl, additionally because of its applications in different fields like systems biology, HIV-AIDS study, and drug dosage estimation it presents a good avenue for further research. This talk will introduce the attendees to the parameter estimation problems and show how to use DiffEqBayes.jl to perform Bayesian parameter estimation via techniques like Markov Chain Monte Carlo, Stochastic Approximation Expectation Maximization algorithm and Maximum A Posteriori estimation. Through this talk attendees will learn the purpose of parameter estimation and leave with knowledge of tooling for estimating parameters of differential equation models created using Julia’s differential equations suite.
+ + ++
+ + +
+
+ + + + +
+Increased geometric data complexity, operations on n-dimensional manifold and non-manifold geometries are the modern challenges of many field like CAD, Biomedical Imaging and Physical Simulations. Therefore there is the need of a representation scheme capable to handle these challenges with ease. For this task we propose LAR (Linear Algebraic Representation) which offers many interesting features such as efficient support for topological queries and construction, data representation via matrices and the opportunity for easy parallel processing. LARLIB.jl is the official Open Source implementation of LAR which enables the user to use the features of LAR with operations like: incidences and adjacencies between topological entities, boundary and co-boundaries of Cellular Complexes, Boolean Operations such as union of several complexes. This was possible thanks to the Julia ecosystem that provides and easy environment for scientific computation such as parallel capabilities, definition and operations on CSC Sparse Matrices builtin types, and third-party scientific libraries (IntervalTrees.jl and NearestNeighbors.jl). We will demonstrate the library efficiency through the union of big random cellular complexes and a real Bioinformatics use case with the creation of a compact model from MRI images.
+ + +I have a B.Sc. in Computer Engineering at the University of Roma Tre which is the host of the Computational Visual Design Lab (CVDLAB). I worked there as a research fellow for more than a year. During this period I developed LARLIB.jl with Francesco Furiani and Prof. Alberto Paoluzzi.
+ + + +
+
+ + + Kevala Analytics + +
+I will discuss one image recognition algorithm I have created using Julia to train and classify images of whale flukes. This talk will demonstrate a convolutional neural network used to train and test whale images contributed by photographers around the world. It aims to demonstrate Julia’s capabilities for use in machine learning, image recognition, and conservation efforts.
+ + ++
+ + +
+
+ + + Julia Computing + +
+Julia provides many different numeric types, including signed and unsigned integers, floating point numbers, rationals, arbitrary precision numbers, and irrational constants. The type hierarchy and multiple dispatch allow all these different types to be used together. For most operations, this is handled via promotion to common type, however comparisons such as equalities and inequalities are handled in a more complicated manner, in order to obtain the mathematically correct result.
+ + +Simon started using Julia in 2012. He promptly found a bug. Since then, he’s made some pull requests, created some packages, and spent a lot of time waiting for tests to finish running (arguably not as much as he should).
+ + + +
+
+ + + UC Irvine and MIT + +
+Partial differential equations (PDEs) are used throughout scientific disciplines, modeling diverse phenomena such as the spread of chemical concentrations across biological organisms to global temperature flows. However, solving PDEs efficiently is not easy: it requires a vertical toolkit with many interconnected pieces. In this workshop we will introduce the participants to some basic PDEs, where they come from, and how to tie together the various tools across the Julia package ecosystem to solve them efficiently.
+ +We will start by focusing on elliptic problems and show how these decompose into solving sparse linear systems. To solve the resulting linear systems, the participants will be introduced three methods: Julia’s special matrix types for efficient dense solutions, BandedMatrices.jl for more generic banded operators, and IterativeSolvers.jl for Krylov methods. The differences between the methodologies and the current status of distributed and GPU compatibility will be discussed. From there, the extension to nonlinear elliptic problems will be shown as effectively solving nonlinear systems with sparse Jacobians, and demonstrations/comparisons of Roots.jl, NLsolve.jl, and Sundials.jl’s KINSOL for solving the resulting systems will be addressed. Lastly, the concept of pseudospectral discretizations will be introduced using the library ApproxFun.jl, it will be shown how this methodology simply leads to different linear/nonlinear systems.
+ +After understanding the tooling for elliptic PDEs, “time-dependent” PDEs such as parabolic and hyperbolic PDEs will be introduced. It will be shown how similar discretizations as done in the elliptic portion lead to systems of coupled ordinary differential equations (ODEs). It will be demonstrated how to efficiently solve the resulting ODE systems via DifferentialEquations.jl using methods such as via banded Jacobian Rosenbrock integrators, Newton-Krylov BDF, Implicit-Explicit (IMEX) Runge-Kutta, and exponential integrators like ETDRK4. Participants will be shown how to integrate pseudospectral operators from ApproxFun.jl and linear solvers from IterativeSolvers.jl to customize the integrators to their problem. Additionally, special time-stepping issues for hyperbolic PDEs and the strong-stability preserving (SSP) integrators will be introduced.
+ +Together, the workshop participants should be able to leave with a good understanding of how to tie together the Julia scientific packages to efficiently solve a large class of partial differential equations.
+ + +I am a mathematician and theoretical biologist at the University of California, Irvine. My programming language of choice is Julia and I am the lead developer of the JuliaDiffEq organization dedicated to solving differential equations (and includes the package DifferentialEquations.jl). My research is in time stepping methods for solving stochastic differential equations (SDEs) and applications to stochastic partial differential equations (SPDEs) which model biological development.
+ + + +
+
+ + + + +
+Much of research comes down to giving commands to instruments, and pulling results, and then performing some sort of analysis. Each of these tasks is generally done via an interface or language of its own: Bash or similar to give commands to instruments and manipulate files, some scripting language for analysis, and a sprinkling of libraries to read input data and perform more complex analysis. Eventually the manifestation of this type of work is a set of scripts with vaguely defined input and outputs. These are passed on semi-religiously from one PhD student to the next, until modifying them becomes almost an act of sacrilege, thus limiting what new science can be attempted (until a student throws it all out of the window, restarting the process from scratch). +Julia has the potential to remediate to this situation. It offers a platform where it is easy to combine systematic testing with every aspects of an R&D workflow, from command-line calls, to wrapping C libraries, to beautiful plots. I illustrate this workflow using my experience in a startup developing a quantum random number generator on an android phone. Julia allowed me to test and analyse the random number generator by simply issuing commands to the android bride as an external program, pull results from the phone as files via the same android bridge, open these files by wrapping an external C library, and then analyse and plot the results, all in the comfort of an IJulia notebook. Other than the fact that Julia solved these problems within a single language, it also allowed me to easily integrate testing directly into the notebook, thus ensuring that the workflow remains tested, and legible, even as it grows. Julia decidely lowers the barrier to reproducible, auditable research.
+ + ++
+ + +
+
+ + + University of California, Irvine + +
+Informed decision-making across various phases of drug development is challenging as it has to utilize an enormous amount of information produced during the development process. Models of drug, disease and trials are particularly useful in summarizing essential information in a succinct and efficient manner, allowing the integration of knowledge from different studies and external sources. Simulations combined with appropriate assumptions, such models can explore the potential outcomes of yet-to-be-conducted studies, enabling optimization of the study design to increase the probability of success and de-risk investment. +Pharmacokinetic and Pharmacodynamic (PK/PD) models are one such class of models used by pharmaceutical professionals to guide drug development and clinical therapeutic decisions. These models allow forecasting drug concentrations in the body and the response to the drug at various dose levels. Further, these models require flexible and high performance solving of differential equations to simulate patient data. However, the development of open-source software tools for this discipline lag due to the requisite performance and domain-expertise. In this talk we will introduce PKPDSimulator.jl, a Julia package for simulation of PK/PD models. This package includes the addition of functions for implementing compartmental PK/PD models and schedules of dosing and other discrete events. We will demonstrate how models of clinical trials are developed to simulate clinical measurements and responses to drug administration. Unique features which make new ground in the field, such as the ability to incorporate stochastic differential equations, delay differential equations, and discrete stochastic models will be emphasized.
+ + +Chris Rackauckas is a 4th year Ph.D. Candidate in Mathematics at the University of California, Irvine. He is the principal author of many Julia packages, including the JuliaDiffEq packages (DifferentialEquations.jl) and ParallelDataTransfer.jl, and has contributed to numerous other packages related to scientific computing. Chris is also actively engaged in the Julia community as the author of the StochasticLifestyle blog and the tutorial “A Deep Introduction to Julia for Data Science and Scientific Computing”.
+ + + +
+
+ + + + +
+Multi-Dimensional Bisection Method for finding the roots of non-linear implicit equation systems Introduction The bisection method - or the so-called interval halving method - is one of the simplest root-finding algorithms which is used to find zeros of continuous non-linear functions. This method is very robust and it always tends to the solution if the signs of the function values are different at the borders of the chosen initial interval. +Geometrically, root-finding algorithms of f(x)=0f(x)=0 find one intersection point of the graph of the function and the axis of the independent variable. In many applications, this 1-dimensional intersection problem must be extended to higher dimensions, e.g.: intersections of surfaces in a 3D space (volume), which can be described as a system on non-linear equations. In higher dimensions, the existence of multiple solutions becomes very important, since the intersections of two surfaces can create multiple intersection lines. +Multiple solutions The original form of the bisection method can easily be extended to find numerous roots of a non-linear equation in a given interval. If the function values are computed in an initial mesh on the examined interval, then the original method can be used for each neighboring points where the sign of the function values are different. This way, some roots may be omitted if the initial mesh is not fine enough, and even number of roots are placed inside one interval. +Generalization for higher dimensions In many applications, the roots of a system of non-linear implicit equations
+ + ++
+ + +
+
+ + + + +
++
+ ++
+ + +
+
+ + + Chalmers University of Technology + +
+Julia 1.0 comes with a brand new package manager under the working name Pkg3. It has been rewritten from scratch based on the experiences of the previous package managers—both Julia’s an those in other languages. This talk discusses some of the design and implementation choices made and the reason behind them. Some of the topics included in the talk are: +Federated package ecosystem. This means that multiple independent parties can maintain both public and private packages and registries of them, and that projects can depend on a mix of public and private packages from different registries. Packages from various registries are installed and managed using a common set of tools and workflows. One consequence of federation is that there cannot be a central authority for package naming: different entities may use the same name to refer to unrelated packages. Instead, packages are identified by universally unique identifiers (UUIDs) assigned to them prior to registration. UUIDs are mostly invisible to the casual user of Julia—they are used in project and manifest files maintained by the package manager but regular Julia code continues to use packages by name as it always has. +Environments. Julia’s code loading and package manager natively support having multiple independent sets of packages at different versions. This alleviates “DLL hell” for Julia packages since unrelated projects don’t need to fight about what version of their dependencies to use—they can each use whatever version of a dependency they prefer. Manifest files record the exact version of each dependency in a complete dependency graph for a given application and can be reconstituted with a single command on the same system or a different one—a huge boon for reproducibility. +Immutability and content addressing. One of the basic design principles of Pkg3 is that an installed version of a package is immutable and identified by its content. In other words, once a version of a package is installed, it is never changed and anyone who wants that version asks for by a hash of its source tree. When a version is no longer needed anywhere, it is automatically deleted. Identifying package versions by content rather than git commit also means that packages are free to rewrite their development history—for example to discard large objects—and allows packages to be installed without any need for git history at all, so long as the source tree is correct.
+ + +Ph.D. student in computational mechanics at Chalmers University of Technology. Using Julia both for studies and as a hobby.
+ + + +
+
+ + + + +
+This talk introduces three packages: SaferIntegers, ArbNumerics and TimesDates. SaferIntegers are safer because they do not allow numerical overflow to occur silently. ArbNumerics provides best-in-class performance with 35..350 digits, and accurately encloses its values. TimesDates provides nanosecond timestamps over timezones.
+ + ++
+ + +
+
+ + + Etsy + +
+At Etsy, we leverage our internal A/B testing tool when we launch new campaigns, polish the look and feel of our site, or even make changes to our search and recommendation algorithms. As our experimentation platform scales and the velocity of experimentation increases rapidly across the company, we also face a number of challenges. In this talk, I will talk about how we utilize Julia to investigate and evaluate one of the problems, “peeking” at results early in order to detect maximum significance with minimum sample size. +We used Julia to assess the overall problem and how it affected experiments at Etsy. We also used Julia to evaluate a few solutions that have been proposed and applied in industry and academia, keeping in mind the unique challenges we face as a fast-paced e-commerce company. After going through the analysis and evaluation, I will discuss the approach we at Etsy took to tackle the peeking problem.
+ + +Kelly Shen is a data engineer at Etsy, where she works on improving the e-commerce company’s in-house A/B testing platform. Previously, she was an undergraduate student at MIT studying computer science and mathematics and used Julia extensively in both her classes and research.
+ + + +
+
+ + + Julia Computing, Inc. + +
+JuliaBox is an online service for running julia from the browser. With over 70,000 users since 2015, JuliaBox is used by scientists, engineers and universities worldwide. We present the new JuliaBox that was released over the past year. New features have been added to support courses for universities. We now provide GPU enabled notebooks with drivers, libraries and packages fully setup. Users can now deploy their julia code on JuliaBox as interactive web applications. We have also introduced UI for scaling CPU and memory for the notebook or any custom app.
+ + +Software Developer at Julia Computing Inc.
+ + + +
+
+ + + U of Toronto + +
+Gradient-based optimization is the main trick of deep learning and deep reinforcement learning. However, it’s hard to estimate gradients in the most interesting settings - when the mechanism being optimized is unknown (as in reinforcement learning) or involves discrete operations (such as in optimizing programs). +I’ll give a quick overview of the tricks of the trade:
+Jesse Bettencourt is a graduate student in the Machine Learning group at the University of Toronto and the Vector Institute. He is supervised by David Duvenaud and Roger Grosse and teaches the undergraduate/graduate course on probabilistic models and machine learning. He is very excited to use Julia in his ML research and possibly in future course offerings.
+ + + +
+
+ + + GTRI + +
+LightGraphs offers both (a) a set of simple, concrete graph implementations – Graph (for undirected graphs) and DiGraph (for directed graphs), and (b) an API for the development of more sophisticated graph implementations under the AbstractGraph type. The data structures and algorithms are now decoupled in order to allow users to extend the basic graph implementations with novel data structures which include support for weights, properties, and more efficient storage. +We have integrated with EvolvingGraphs.jl, MetaGraphs.jl, and SimpleWeightedGraphs.jl. These packages allow you to use graphs with various forms of metadata attached to the nodes or edges. From traditional weighted graphs, to dynamic graphs with changing edge sets, to MetaGraphs.jl which allows you to ingest a DataFrame as a property graph. MetaGraphs provides the foundation for an in memory GraphDB. +Demo! We will live-code a simple graph type defined by its adjacency matrix and leverage LightGraphs for different applications. This talk will show how anyone can extend JuliaGraphs with a custom graph implementation for their application.
+ + +Mathieu Besançon is a PhD student in a double program between Ecole Polytechnique of Montréal, at the GERAD lab and the INOCS team at INRIA Lille, in mathematical optimization and game theory for smart grids. James Fairbanks earned a Ph.D in Computational Science and Engineering at Georgia Tech. My research focuses on numerical, statistical, and streaming algorithms for data analysis. The applications include complex networks, online media, medical data, and sensor data.
+ + + +
+
+ + + MIT Sloan + +
+JuMP is a multi-award-winning domain-specific language for mathematical optimization. JuMP has already been successfully used in academic and industrial problems related to marketing, causal inference, daily fantasy sports, optimal control of aerial drones, machine learning, school bus routing, sustainable power systems expansion, and decarbonization of electrical networks. The JuMP ecosystem gives access to a wide range of highly-effective commercial and open-source optimization tools in a natural syntax that requires only a basic knowledge of mathematical optimization. JuMP provides this access with a performance that matches or exceeds those of commercial and open-source alternatives, as well as unparalleled versatility and extensibility allowed by the advanced features of the Julia language. In particular, JuMP and its infrastructure was used to develop the solver Pajarito.jl, which is currently the state-of-the-art for the class known as mixed-integer conic optimization problems. JuMP has recently received a major overhaul that should further facilitate the development of similar advanced optimization tools.
+ +In this tutorial, we begin with basic syntax and features of JuMP and associated packages assuming no previous knowledge of JuMP and only an elementary knowledge of mathematical optimization. We then cover more advanced features, give performance tips, and cover the recent improvements to JuMP developed in the second Annual JuMP-dev Workshop. Finally, we demo some state-of-the-art features, including showing how various packages in the rich Julia ecosystem can be seamlessly combined to provide simple solutions to complicated problems in the optimal control of aerial drones.
+ + +Juan Pablo Vielma is an associate professor at MIT’s Sloan School of Management and is also associated to MIT’s Operations Research Center. Juan Pablo’s research interests include the development of theory and technology for mathematical optimization and their application to problems in marketing, statistics and sustainable management of energy and natural resources. Juan Pablo is the Ph.D. advisor of two of the creators of JuMP and continues to be closely involved in JuMP’s development. Some projects he is currently associated with are the Pajarito Solver, JuMP’s extension for piecewise linear optimization and the Cassette and Capstan tools.
+ + + +
+
+ + + + +
+Deep learning algorithms have proved to be very successful on image data: Facial recognition and autonomous cars are already out there. The analysis of biomedical data, however, is an exciting new field that still waits for such breakthroughs because it poses different challenges. Genomic sequencing data, e. g., usually encompasses a large number of variables, so-called single nucleotide polymorphisms (SNPs). But since DNA sequencing is still expensive, the available sample sizes are very low compared to the number of measured variables for each sample. This new area is what we want to target with our package “BoltzmannMachines.jl”. With the ability to partition layers of deep Boltzmann machines, the number of model parameters that are to be estimated can be reduced significantly. This makes deep learning possible in a setting with a high number of dimensions but low sample size. We showed that partitioning on basis of correlation structure can enable deep Boltzmann machines to learn meaningful SNP patterns (Hess M., Lenz S., Blätte T. J., Bullinger L., Binder H. Partitioned learning of deep Boltzmann machines for SNP data. Bioinformatics 2017 btx408. doi: https://doi.org/10.1093/bioinformatics/btx408). Besides partitioned modeling, multimodal deep Boltzmann machines are in particular capable of modeling different types of input data, e.g., datasets also containing continuously valued variables. In our implementation, this is possible by using different types of restricted Boltzmann machines and plugging them in at the level of the visible layer. +When training on heterogeneous types of data, the choice of the hyperparameters is especially challenging. Therefore, our package puts a strong focus on evaluation and monitoring during model training. As primary evaluation criterion, the likelihood can be estimated using annealed importance sampling. Additionally to that, the package offers convenience methods to monitor a number of other statistics. Also, the monitoring is designed to be easily customizable, which allows the user to examine the learning process and gain more insights into the nature of deep Boltzmann machines.
+ + ++
+ + +
+
+ + + MIT + +
+Cassette is a tool for injecting user-defined code transformation passes into Julia’s JIT compilation cycle, enabling normal Julia packages to analyze, optimize, and modify Cassette-unaware Julia programs via both low-level IR transformation and high-level dispatch using Cassette’s context types. This latter feature, dubbed “contextual dispatch”, allows users to safely and quickly overload existing Julia methods with context-specific behaviors, like graph construction or derivative computation, without ever needing to handle Julia’s IR directly. +Importantly, Cassette requires no manual source annotation or refactoring of target code. Cassette even works in the presence of structural and/or dispatch type constraints. This renders traditionally “invasive” techniques, like automatic differentiation, applicable to previously inapplicable Julia programs. +Downstream applications for Cassette include lightweight multistage programming, dynamic code analysis (e.g. profiling, rr-style debugging, etc.), compilation to new hardware/software backends, automatic differentiation, interval constraint programming, automatic parallelization/rescheduling, automatic memoization, and more. +In this talk, I’ll discuss Cassette’s design, implementation, and show how it can be used to implement automatic differentiation for native Julia code.
+ + +I like to make Julia code differentiate itself.
+ + + +
+
+ + + + +
+This talk will cover the fundamental process of getting from a dataset on a web-server, into data in your program. Almost all empirical research work is data driven. This is particularly true of any field that is using machine learning. As such, setting up your data environment in a repeatable and clean way is essential for producing replicable research. Similarly, many packages have some requirement on data included to function, for example WordNet.jl requires the WordNet database. Deploying a package based on using an already trained machine learning model requires downloading that model. +This talk will primarily focus on DataDeps.jl which allows for the automatic installation and management of data dependencies. For researchers and package developers DataDeps.jl solves 3 important issues:
+ +To achieve this DataDeps.jl needs each data dependency to be declared. This declaration requires information such as the name of the dataset, it’s URLs, a checksum, and who to give credit to for its original creation etc. I found myself copy-pasting that data from the websites. DataDepsGenerators.jl is a package that can generate this code given a link to a supported webpage describing. This makes it really easy to just grab someone else’s published data, and depend upon it. Then DataDeps.jl will resolve that dependency to get the data onto your machine. +Once you’ve got the data onto your machine, the final stage is to load it up into a structure Julia can work with. For tabular data, julia has you well covered with a number of packages like JuliaDB, DataFrames.jl and many other supporting packages. MLDatasets.jl, uses DataDeps.jl as a backend, provides specialised methods for accessing various commonly used machine learning datasets. CorpusLoaders.jl provides a similar service for natural language corpora. Corpora often have factors that differ from other types of data.
+ +Packages discussed Packages discussed in great detail:
+ ++
+ + +
+
+ + + U of Cambridge + +
+Many biological models consider biochemical reaction networks. However, as these grow in size they also produce large amount of equations which needs to be transcribed into computer code. This is a monotonous task of little fun and which is prone to generating bugs (and finding these bugs is even less entertaining). Fortunately we have been able to automate it. By using Julia’s capability of meta programming we have created a DSL (domain-specific language) allowing its user to input their reaction network as chemical equations (as opposed to mathematical ones). This format both look aesthetically pleasing and efficiently handles features such as coupled noise. The DSL generates an IR (intermediate representation) which have been constructed with Julia’s high-performance DifferentialEquations.jl library in mind. It can be used to create ODE, SDE and JumpProblems, all of which can be solved using DifferentialEquations’ solvers. Taken in total this can significantly cut the amount of code required, as well as making what remains much prettier.
+ + +Torkel is a mathematician and first year Ph.D. student at the University of Cambridge. With the use of mathematical models he investigates how B. Subtilis responds to various forms of stress by producing alternative sigma factors.
+ + + +
+
+ + + Gandalf Software, Inc. + +
+JuliaString is a new organization, formed with the goal of creating an ecosystem of standards compliant, fast, and easy to use string handling packages. Many people using Julia are scientists, and don’t really wish to deal with the complexities with things like indexing into variable-length string encodings, why their data loaded from a CSV file or from a database sometimes seem to be corrupted. There are also people interesting in writing Julia code for NLP (natural language processing), where the speed can be critical. Many fields such as bioinformatics have their own text file formats, and the new Strs package provides easier to use functions for writing fast string handling code. The talk will cover the added functionality of the Strs package, the importance of having validated strings for avoiding a number of known security exploits, the relative performance of the new strings, and its use for interfacing with other languages, databases, and libraries that frequently use other Unicode encodings, such as UTF-16. It will also cover the string literal format, with support for LaTeX, Unicode, HTML entities and Emojis, as well as easy to use formatted output that builds upon string interpolation, using the Julia type system, or alternatively using a C-like or Python-like format code syntax (but without having to count positions, or use a macro. Other topics such as thread-safe regex support, handling non-Unicode string encodings, optimized dictionaries for string keys, will be discussed, time permitting.
+ + +Consulting for Dynactionize.com, working fulltime in Julia
+ + + +
+
+ + + + +
+This talk will showcase what is possible with the JuliaGeo related packages, with the aim to get you started if you want to do geospatial analysis in Julia. The foundation here lies in solid, easy to install wrappers to established OSGeo (Open Source Geospatial Foundation) projects such GDAL (Geospatial Data Abstraction Library), GEOS (Geometry Engine Open Source) and PROJ (coordinate transformation software library). On top of this, inspired by the Python ecosystem, we implemented a GeoInterface, to make sure the different geometry representations can talk to each other. From this basis some examples are given of customized processing that could not be done as efficiently in Python.
+ + ++
+ + +
+
+ + + Cambridge University + +
+In this talk, I will both introduce Latexify.jl and explain how Julia enabled the creation of this package in a way that few other languages could. +Latexify.jl allows you to convert Julia objects, and even equations, to LaTeX and Markdown. While Latexify.jl is useful for typesetting a matrix to a latex array, its practical value extends far beyond that. In this talk, I will: - describe how Julia’s metaprogramming facilities allows for not only create clever ways of inputting information to our programs, but also for extracting that information; - demonstrate how Latexify.jl uses this to latexify and render things ranging from strings to systems of differential equations and symbolically calculated Jacobians; - showcase how this has become an addictive and ubiquitous part of my work as an applied mathematician; +and finally, I will reflect upon how the Julia features that allowed the making of Latexify.jl could be leveraged for other things.
+ + +I am the author of Latexify.jl, a member of the JuliaDiffEq organisation and a PhD student of applied mathematics at Cambridge University. I started tinkering with Julia a few years ago and I have for the last year and a half done almost all my work with Julia. I dabble in computational biology, non-linear dynamics, programming and occasionally beer brewing.
+ + + +
+
+ + + GTRI + +
+Many areas of technical computing use graphs or networks and LightGraphs provides a common base of data structures and algorithm to manipulate and analyze these graphs. The JuliaGraphs ecosystem is evolving integrations with many other Domain ecosystems such as Optimization, Biology, Image Processing, and Statistics and 127 distinct packages. +The JuliaGraphs ecosystem has expanded this year, with new innovations in abstract representations and modularity. We discuss these improvements, highlighting the effects of changes in Julia 0.6 and 0.7 such as Type System / Type Parameters, Traits, Module dependencies, Threading and Atomics which affected the design of the JuliaGraphs ecosystem. +We will present developments in the JuliaGraphs community and celebrate the 1.0 release.
+ + +Mathieu Besançon is a PhD student in a double program between Ecole Polytechnique of Montréal, at the GERAD lab and the INOCS team at INRIA Lille, in mathematical optimization and game theory for smart grids. James Fairbanks earned a Ph.D in Computational Science and Engineering at Georgia Tech. My research focuses on numerical, statistical, and streaming algorithms for data analysis. The applications include complex networks, online media, medical data, and sensor data.
+ + + +
+
+ + + Julia Computing + +
+In this hands on workshop, we will explore the use of natural language processing tools in Julia, with a particular focus on statistical machine learning based approaches. The content will be based primarily around the TextAnalysis.jl and Flux.jl packages. We will learn some of the primary algorithms in this area, and implement practical examples using these packages. The course will be aimed at someone who has a basic understanding of the Julia programming language, but no prior experience of natural language processing
+ +Avik has spent many years helping investment banks leverage technology in risk and capital markets. He’s worked on bringing AI powered solutions to investment research, and is currently the VP of Engineering at Julia Computing.
+ + + +
+
+ + + + +
+Deep neural networks have been tremendously successful in approaching a variety of learning problems. Nonetheless, the basic building blocks that make up such models are mostly designed to facilitate gradient based parameter learning, rather than to enable productive programming, or to provide a fully fledged programming language. Standard programming languages on the other hand provide programming elements such as variables, conditional execution clauses, and definitions of subroutines that facilitate succinct descriptions of programs, but lack the flexibility that gradient based learning allows. We set on combining the best of both worlds in a new Julia framework that on the one hand supports structured programming elements, and on the other, supports gradient based parameter learning. The main challenge in combining the two is to provide an efficient algorithm for calculating the gradient when variables, and loops are involved. In such cases, the complexity of calculating the gradient using standard backpropagation grows exponentially with the number of iterations and the number of variables. To circumvent this problem, we present a new auto-differentiation mechanism that can handle such cases in linear time, and a new framework that supports it. We supplement our framework with operations that are typical of neural networks, paving the way to new kinds of adaptive programs. In particular, we show that convolutional neural networks that incorporate variables and loops can solve image classification problems with significantly less parameters, and more importantly, solve image classification tasks that standard neural networks fail to solve.
+ + ++
+ + +
+
+ + + Julia Computing + +
+Julia Computing in partnership with Ek Step foundation (https://ekstep.org/) has started an initiative in India to train 500,000 individuals in machine learning to accelerate their upskilling and improve the AI and ML communities. The current state of talent in the field of AI and ML in India falls short of the requirements. We have designed the course content and delivery mode such that, the learning is great fun. It has been very well received by the first hundreds of students and professionals we have trained so far. This is one of the largest AI/ML outreach and training programs, and it has Julia at the center.
+ + +I am currently working as a data scientist at Julia Computing, Bangalore. I have masters in Applied Mathematics from Linkoping University, Sweden. I have been using Julia since 2013, I love training in the field of machine learning, and Julia has been my choice as a programming since 2013.
+ + + +
+
+ + + + +
+This talk will discuss how we’ve used Julia at scale, both on private clusters and the cloud, to solve industrial problems in Airborne electromagnetic (AEM) geophysical surveying. AEM surveying is a geophysical technique that uses electromagnetic induction to map the structure of the earth’s subsurface. Think of a giant metal detector attached to a helicopter flying low over the earth’s surface. The technique is used in mineral, oil and gas, and groundwater exploration as well as in environmental monitoring. Transforming the raw data collected by these surveys into 3D models of subsurface physical properties that can be used by geologists and other domain scientists is a computationally challenging problem—known as geophysical inversion. It is normally posed as a problem in partial differential equation (PDE) constrained optimization. Solving such problems requires repeatedly solving partial differential equations numerically as part of an iterative optimization process. +Our research group at the University of British Columbia has developed a modular framework for solving PDE-constrained optimization problems, particularly those arising in applied geophysics. This framework, called [jInv] (https://github.com/JuliaInv/jInv.jl) was presented at JuliaCon 2017—find the video here. Inversion of large-scale AEM survey data is a key application of the jInv framework. Cutting edge approaches to the problem involve dividing the PDE based survey simulation component of the problem into many quasi-independent subproblems. Julia is a great environment to exploit the parallelism inherent in this approach. We use a combination of Julia’s built in distributed memory parallelism, nested with shared memory parallel linear algebra libraries to take advantage of modern cluster architecture. In this talk we will describe how we’ve structured our code to use Julia’s distributed memory parallelism and will also emphasize how developing in Julia has allowed us to add new features to our inversion codes quickly while retaining the ability to deploy them on large-scale real world problems in mineral exploration. +The work described here was conducted at the University of British Columbia and at Computational Geosciences Inc.
+ + ++
+ + +
+
+ + + University of Edinburgh + +
+Whenever a new programming language appears, first there is excitement: “It can do X and Y so well! Amazing!” Soon, however, reality sets in and you start having to rewrite vast swathes of your workflow in this shiny new language. Well, Julia is shiny, and it can certainly do many things very well, but can it also be easily incorporated into a mature codebase? My experience with Julia and Madagascar—an open-source software package for geophysics—suggests that it can. In this talk I will explain how Julia’s C interface and metaprogramming support combine naturally with Madagascar’s main pillars: its C API and its user-contributed programs. I will show that my relatively small Julia API (now sitting in upstream Madagascar), can provide functionality that is either lacking in other APIs (e.g. MATLAB), or requires complex external tools (e.g. Python+SWIG). Using these examples, I will make the case that Julia is not only a welcome addition to scientific computing communities, but that it can also be incorporated into established workflows with minimal effort. Indeed, I will show that one of Julia’s key advantages is its flexibility in being integrated into mature projects.
+ + +Carlos is an applied scientist currently working as a postdoctoral researcher at the University of Edinburgh. He is interested in imaging and inversion, particularly large scale problems in Earth sciences. From Brazil, Carlos obtained a B.Sc. in Mathematics from PUC-Rio and an M.Sc. in Applied Mathematics from the University of Campinas, before moving to (equally sunny!) Scotland where he obtained his Ph.D. in Geophysics from the University of Edinburgh.
+ + + +
+
+ + + + +
+Electric utilities in Europe are faced with squezeed margins in the marketing of its production units due to increased pressure on the electricity price levels assigned to renewable energy effects. As electricity markets gain dynamics and move closer to real-time redispatch and planning of the production facilites, partly also due to technical requirments of the transmission grid which maintains the energy balance in the system at all times, efficient and performant asset optimization and management software solutions become increasingly important. Well studied algorithms like the linear or mixed integer programming reach their limits in the ability to find the optimal dispatch in short time while taking volatility of the input parameters in consideration, such as water inflow or intraday prices. We are trying to tackle the challenges of the fast changing electricity market by developing models in different systems which satisfy our requirements for optimality and performance. We were happy to find out that an open-source programming language Julia with good performance reputation offers a great support for optimization solutions and algorithms, even more the trending ones like dynamic programming or stochastic dynamic programming. We were happy to find out that we dont have to ‚reinvent the wheel‘ and implement the algorithm ourselves but rather focus on the analysis part and analyse the results. We have built an optimized dispatch application of our pumped-storage hydro power plant in Julia and would like to share our experiences in working with SDDP Packages in Julia, while benchmarking it with the existing applications that we use in our everyday work.
+ + ++
+ + +
+
+ + + Julia Computing, Inc. + +
+Julia is a great language for code analysis tools. The combination of dynamic and static features gives a very rich environment for both producing and exploring the program full stack. +Current tooling can provide essential insights into the workings of a program. These including everything from simple annotation and highlighting functions such as code_warntype, to performance testing tools like @profile and BenchmarkTools’s @benchmark, to tests and documentation, to Revise.jl workflows. This talk will open by exploring the strengths, limitations, and purposes of several of these. +However, these tools share one significant common aspect: they are not especially interactive. Indeed, as a goal, these try to be absolutely stateless. +What tools do we need to complement these and expand our workflow? One traditional stateful tool is the lowly – but essential – debugger. But in Julia, can we do even better? What if we could explore the compilation space just as easily as exploring the execution space? In what ways can we combine the insights from a debugger with the insights from the compiler to further our real understanding of the program (and, inevitably, its flaws)? How would we aggregate that information and present it in a way that can be exported and shared? +In this talk I’ll introduce my new tool for interactive program analysis, aka debugging. Julia has a unique combination of dynamic features and a standard library designed to be strongly amenable to static analysis. These aspects make possible the integration of a range of the development aids mentioned earlier to benefit developers and users alike. Let’s see what a bright new future for analyzing Julia code might look like!
+ + +I’ve been a Julia contributor since before it was cool. Now, I’m working for Julia Computing, as the static compilation champion, compiler correctness fiend, and performance cliff jumper.
+ + + +
+
+ + + + +
+One way to attract new users to specific Julia packages (and the language in general) is to showcase our work to a wide audience of non-Julia users. There are many ways to do this including Julia blog posts, conference presentations and sandbox environments like JuliaBox, but this talk will focus on creating web-based demonstrations that allow anyone with a browser to interact with Julia code. I will discuss three sample projects:
++
+ + +
+
+ + + MIT + +
+Earth systems are simulated using numerical models of increasing resolution that play a key role in helping us understand and predict climate. The MIT general circulation model and MIT Darwin Project developers strive to provide open-source and user-friendly solutions to a wide user community of researchers and educators. In this talk, I will present an initial effort to interface these powerful and versatile tools with Julia. Emphasis, for now, is on porting the gcmfaces toolbox to Julia. This Matlab / Octave toolbox allows users to analyze ocean model output using code that is readily applicable to all supported grid types. Porting it to Julia notably aims to (1) improve scalability to increasingly large data sets, (2) alleviate costs associated with proprietary software, (3) increase integration with cloud services, and (4) facilitate access for educators and researchers via jupyter notebooks. Examples will be taken from a recent simulation of marine ecosystems by the MIT Darwin Project. In the longer term, this effort aims to allow users to leverage MITgcm capabilities (parallel solvers, automatic differentiation, virtual particle tracking, etc.) via Julia.
+ + +I work as a research scientist at the Massachusetts Institute of Technology (MIT) where I investigate oceanography and climate. As part of the Department of Earth, Atmospheric and Planetary Sciences, my work focuses on ocean modeling and the analysis of global ocean data sets such as Argo profile collections and satellite altimetry. Amongst other approaches, I carry out ocean state estimation using the MIT general circulation model to interpolate and interpret ocean observations. I also participate in the development of the MITgcm and its adjoint. My scientific interests include: Ocean circulation and Climate variability; tracer transport and turbulent transformation processes; interaction of bio-geochemistry and physical processes; global cycles of heat, water, and carbon; observational statistics; forward and inverse modeling.
+ + + +
+
+ + + PTScientists + +
+Space science and industry have seen massive changes in recent years. New Space companies are bringing down the cost of space exploration and are achieving impressive technological milestones. Feats that have eluded established organizations for years. This new generation of space hardware is driven by the use of open and affordable technologies such as Cubesats and a willingness to re-examine old assumptions and for radical simplification. +With the hardware revolution well under way the next big frontier in space systems engineering is software. The existing ground control systems and scientific mission data analysis tools have accumulated decades of technical debt and accidental complexity and thus cannot hold step with the rapid changes in the space segment. A fresh approach is needed to lower the barrier of entry for the next generation of space explorers and further bring down the cost of access to space. +This presentation examines how Julia’s unique properties make it ideal for tackling the challenges in space science and exploration and will present the roadmaps for the JuliaAstro and JuliaSpace organizations.
+ + +I am a mission analysis and flight dynamics engineer at PTScientists, space nerd, Julia enthusiast since the beginning, and like to photograph remote moutains.
+ + + +
+
+ + + Lund U + +
+Stochastic differential equations is an important class of models with a wide range of applications, commonly used in finance. Pricing of exotic financial derivatives is often a very computationally intensive process, emphasizing the need to simulate models as time-efficient as possible. The general experience though, is that fast often means less flexible. With this in mind I developed SDEModels.jl, a package dedicated to simulation of stochastic differential equations. Using features available in Julia, such as metaprogramming and a very fast RNG, I was able to achieve both lightning-fast simulation with barely any overhead, and managed to make it very simple to define and switch models. +Together with additional package OptionPrice.jl, which implements fast and accurate state-of-the-art pricing algorithms, the goal is to give you a great toolbox for pricing derivatives in Julia both easy and fast for a wide variety of models and contracts.
+ + +Carl is doing his PhD studies in mathematical statistics at Lund University, Sweden. The focus of his research is inference methods for stochastic models used in mathematical finance, with a strong aspect of compuational methods and computational efficency. He has a strong interest of writing highly performant code, squeezing out every possible flop.
+ + + +
+
+ + + Melbourne, Australia + +
+This presentation has the aim of presenting a Content-Based (combination of Retrieval Phase; + Learning2Rank algorithm) solution made in Julia to improve the quality of Job Recommendations on the SEEK Asia homepage. As a topic to make accessible to any audience, I will present all components in high level and focus in how Julia helped to make it possible to process all features and natural language models necessary to generate high-quality recommendations using Genie API. The solution was deployed in AWS for production using Docker and Ansible. Key Points of Julia in the Presentation: • Speed-up the process in more than x10 • Make easy the natural language preprocessing • Give total control how to manipulate arrays and matrix for efficiency • Turns flexible the feature engineering calculation without adding much complexity by the language • It is capable to be used as API in a real system environment that need to scale to thousands of users • Last version v0.6.x is a remarkable achievement and stable to make the code go to production • Present performance improvements showing Sparse Matrix, @views, @. and special use of @inbounds, @simd, and @fastmath. • Quick highlights on the packages Genie, DataFrames, and XGBoost
+ + +I`m a Lead Data Scientist specialized in Recommender Systems, Machine Learning, and Natural Language Processing.
+ + + +
+
+ + + + +
+This breakout session is intended for people who teach or plan to teach Julia language to share their experiences and best practices. Authors of books about Julia are also welcome to join the discussion how their materials can be best used to support teaching.
+ +When you start teaching Julia there are several natural questions that you typically have to answer, like:
+ +An ultimate objective of this breakout session is to prepare a material summarizing the conclusions from the discussion that would be openly shared to the community after the conference.
+ + ++
+ + +
+
+ + + + +
+Motivation & TIM +Liberalization of energy market in Europe in recent years have made balancing the electricity grid a challenging task. Nowadays, there are diverse consumption patterns and highly variable re-newable power sources like solar, wind, small-scale hydro, etc. at play. Energy companies need to forecast both consumption patterns of their clients and production capacities of their power sources in large numbers. +TIM (Tangent Information Modeller) is a unified large-scale forecasting system written first in C++ and then in Julia. The engine builds time-series models automatically with no human intervention fulfilling the industry need for forecasting at scale. TIM ranked no. 1 in recent GEFCom 2017 competition (https://juliacomputing.com/press/2017/11/21/tangent-works-uses-julia-to-win-ieee-competition.html). +TIM in Julia This high performance engine relies heavily on Julia’s computational paradigms like loop fusion, map, mapreduce, SIMD support, direct calls to BLAS etc.. +TIM is AOT compiled and deployed in the cloud as a RabbitMQ worker. It is then used via an REST API in production by different energy platforms. In the talk, we would like to go through qualities of Julia which made this transition from C++ to Julia in production perfectly possible and share lessons learned. We also talk about entire architecture of the solution starting from the computational kernel all the way up to its REST API. +Live demonstration showing how to set up your own forecasting system using TIM in Julia may also be included.
+ + ++
+ + +
+
+ + + + +
+Parallel prefix (aka scan) is one of the basic algorithms underlying parallel computing, regrouping associative operations as necessary to provide scalability. In this talk, I will demonstrate how to implement parallel prefix as a higher order function in Julia, offering generic scan operations using any user specified function, on any indexable type. Simply by changing the type of the input indexable allows the exact same code to run in parallel as well as in serial. The serialized equivalent program can be introspected in new ways - by passing in a customized array type that logs accesses in getindex and setindex! operations, the algorithm can be made to generate its own visualization. Finally, by passing in formal types that do not contain data, but rather store only the relevant program invariants, we can use multiple dispatch to prove or disprove the correctness of any claimed implementation of parallel prefix.
+ + ++
+ + +
+
+ + + Domo + +
+The HTTP protocol is a foundational building block of modern computing. Powering complex microservice architectures to individual Jupyter notebooks, programmers from all domains are constantly faced with tasks of interoperating with web REST APIs, scraping web pages, or spinning up servers to provide data and computation to others. +This lightning talk will focus on: * Brief overview of HTTP.jl’s history and inspiration from other language http libraries (python requests and go net/http) * Request functionality, including automatic cookie handling, builtin AWS authentication, custom timeout handling, and more! * A powerful new middleware Handler framework for flexibly layering server functionality +Come get up to speed on the latest and greatest web functionality in Julia and leave with a sharpened toolset that every coder needs in today’s computing world.
+ + +Attended Carnegie Mellon for a master’s degree in data science and active Julia contributor for 4 years now.
+ + + +
+
+ + + U of Amsterdam + +
+The volatility of a financial asset is an important ingredient in asset allocation, derivative pricing, and Value at Risk calculations, among others. Consequently, there is a large literature on volatility modeling. The most successful class of models is that of (generalized) autoregressive conditional heteroskedasticity, or (G)ARCH models, pioneered by econometrician Robert Engle in his seminal 1982 paper, and for which he received the Nobel Memorial Prize in Economics in 2003. The author is developing a package which implements these models in Julia, which as a language is particularly well suited for this task.
+ + +I am an assistant professor of econometrics at the University of Amsterdam, but currently on leave to the University of Zurich under an MSCA indiviual fellowship.
+ + + +
+
+ + + Caltech/Lawrence Livermore National Lab + +
+We’ll have a birds of a feather session (concurrent with part of the poster session) to discuss and brainstorm diversity and inclusion in the Julia community. All are welcome!
+ + +Jane is a graduate student in computational materials physics enrolled at Caltech. She is interning at Lawrence Livermore National Lab, where she is working with Xavier Andrade on methods for and applications of density functional theory.
+ + + +
+
+ + + + +
+It is now possible to create create beautiful, engaging, and interactive data visualizations that can easily reach a wide audience from the comfort of your Julia REPL. This short talk introduces a new way to create dynamic visualizations on the web for a large class of applications. The ideas are simple — the basic approach is to enumerate visual states ahead of time and compile them from Julia into a JSON representation — but can be usefully applied to a very wide range of use cases, many of which I’ll showcase during the talk.
+ + +I am an independent consultant in high-impact data visualization, design, and software development, and am an active member of the Julia community.
+ + + +
+
+ + + University of Glasgow + +
+Biodiversity loss has reached critical levels in the past decade, just as computational techniques and available data sources have put us in a position to begin to quantify this reduction. The Global Biodiversity Information Facility (GBIF) holds hundreds of millions of records of plant species and where they are found. The European Centre for Medium-range Weather Forecasting (ECMWF) has reconstructed the climate of the whole earth since 1900, allowing us to understand the environment in which each plant was discovered. Other researchers, who have constructed a supertree of over thirty thousand of these plant species, give us the opportunity to investigate the evolutionary history of climate preferences among related species. Drawing these datasets together is a huge computational challenge, one exacerbated by our interest in simulating the potential changes these species will undergo in the face of sustained climate change. +The Julia language has provided us with the opportunity to work with these huge datasets (JuliaDB.jl, GDAL.jl), and make spatial simulations based upon endangered plant species on a global scale, which would be intractable in languages commonly used in the life sciences, like R, Python etc. We have been building this platform for almost two years now, along with several other components that come with it (especially Diversity.jl, a package for the measurement and partitioning of biodiversity). +We will talk about the results we have generated in understanding the evolutionary relationships between species across the whole kingdom of flowering plants, how our simulations work to predict responses of plants species to climate change, and how well we are likely to be able to detect these changes using existing biodiversity metrics. +We have also attempted to base our work on Julia “ecosystems” like JuliaStats, JuliaArrays, EcoJulia, BioJulia, JuliaPlots and JuliaGeo, as well as many other individual packages (e.g. JuliaDB.jl, Unitful.jl), and we will discuss the advantages to and difficulties of using and integrating across such systems.
+ + ++
+ + ++ Tickets for JuliaCon have now sold out. There may be a few cancellations, in which case we will allocate tickets to those on the waitlist. +
+ Ticket sales will support the Julia Community through donations to NumFOCUS, a non-profit public charity promoting and supporting the ongoing research and development of open-source scientific data tools through educational, community and public channels. +
++
Refunds are available upto 30 days prior to the event. After that period, refunds will be considered within 24 hours of purchase, or on a discretionary basis if we are able to sell them on. Please contact us immediately if you change your mind. +
+We will be also be happy to transfer the registration if the original purchaser is unable to attend. Please email us with your request. +
+ +Please email juliacon@julialang.org with any questions, comments or suggestions. +
+ +Early bird ticket sales have ended. Full ticket prices are as follows.
+| Student, Talks | GBP 175 |
| Student, Talk + Workshops | GBP 250 |
| Talks | GBP 400 |
| Workshop | GBP 200 |
| Talk + Workshops | GBP 500 |
+
+ + + Stanford University and Julia Computing + +
+Are you new to Julia?! This beginners’ tutorial should be accessible to anyone with technical computing needs and some experience with another language. We will show you why Julia is special, demonstrate how easy Julia is to learn, and get you writing some Julia code. +
+
+
+ + + Fugro Roames + +
+Julia focuses on speed and user productivity, due in part to its metaprogramming capability. This workshop arms you with the knowledge to create fast, generic and easy-to-use APIs using techniques including multiple dispatch, recursion, traits, constant propagation, macros, and generated functions. +
+
+
+ + + Julia Computing, Koç University, and University College London + +
+Machine Learning has become one of the hottest research and industry areas over the last few years; we believe Julia is the strongest contender to become the language for Machine Learning and in this tutorial we will give a flying start to train/deploy models and use of the power that Julia brings. +
+
+
+ + + Imperial College, London + +
+This workshop brings together 4 speakers on different topics in numerical analysis, to demonstrate the strengths of Julia’s approach to scientific computing in atomistic simulations, function approximation, differential equations, fast transformations, validated numerics, and linear algebra. +
+
+
+ + + University of California, Berkeley + +
+This workshop will introduce the Queryverse family of packages, a unified data science stack on julia. It provides tools for file IO, data querying, visual data exploration and statistical plotting. It also integrates with a large number of other julia packages. +
+
+
+ + + UC Irvine and MIT + +
+Climate scientists solve fluid dynamics PDEs. Biologists solve reaction-diffusion PDEs. Economists solve optimal control PDEs. But solving PDEs is hard! Where do you start? This workshop gives a broad overview of the Julia package ecosystem and shows how to tie it together to solve these problems. +
+
+
+ + + MIT Sloan + +
+JuMP is an award-winning DSL for mathematical optimization that has quickly become the gold-standard for its simplicity, performance, and versatility. A major overhaul of JuMP will be finalized during the JuMP-dev workshop in June, so it is the perfect time for an updated tutorial and feature demo. +
+
+
+ + + Julia Computing + +
+A hands on workshop demonstrating the use of natural language processing tools in Julia. Working with textual data, we will discuss methods for data collection, parsing, pre-processing, embedding, classification and deep neural networks. +
+File not found
+ ++ The site configured at this address does not + contain the requested file. +
+ +
+ If this is your site, make sure that the filename case matches the URL.
+ For root URLs (like http://example.com/) you must provide an
+ index.html file.
+
+ Read the full documentation + for more information about using GitHub Pages. +
+ +
+
+
+
+
+
+ + JuliaCon is dedicated to providing a positive conference experience + for all attendees, regardless of gender, gender identity and expression, + sexual orientation, disability, physical appearance, body size, race, + age, religion, or national and ethnic origin. We encourage respectful + and considerate interactions between attendees and do not tolerate + harassment of conference participants in any form. For example, offensive + or sexual language and imagery is not appropriate for any conference + venue, including formal talks and networking between sessions. Conference + participants violating these standards may be sanctioned or expelled from + the conference (without a refund) at the discretion of the conference organizers. + + Harassment includes, but is not limited to: +
+ Participants asked to stop any harassing behavior are expected to + comply immediately. If a participant engages in harassing behavior, + event organizers retain the right to take any actions to keep the + event a welcoming environment for all participants. This includes + warning the offender or expulsion from the conference with no + refund. Event organizers may take action to redress anything designed + to, or with the clear impact of, disrupting the event or making the + environment hostile for any participants. We expect participants to + follow these rules at all event venues and event-related social + activities. We think people should follow these rules outside event + activities too! +
+ ++ If someone makes you or anyone else feel unsafe or unwelcome, please + report it as soon as possible. Harassment and other code of conduct + violations reduce the value of our event for everyone. We want you to + be happy at our event. People like you make our event a better + place. You can make a report either personally or anonymously. +
+ ++ If you would like to report a CoC violation or discuss any incident + that may have left you uncomfortable, please contact one of the + following individuals: + +
+ The JuliaCon committee is composed entirely of volunteer organizers + and can be reached at juliacon@julialang.org + with any questions or comments. +
+ ++ JuliaCon 2019 aims to be an inclusive event. In an effort to reduce the degree to which cost may deter community members from attending this event, we offer financial assistance to GSoC students, accepted speakers, and attendees who heighten the diversity of the Julia community. We welcome participation from people of all races, ethnicities, genders, ages, abilities, religions, sexual orientations, personal/professional backgrounds, and schools of thought. +
+ If financial assistance will impact your ability to attend JuliaCon 2019, please fill out this application. +
+ ++
+ JuliaCon is the biggest Julia conference of the year, bringing together speakers, developers, and enthusiasts from all over the world, for 5 days packed with keynotes, talks and workshops! +
+ +
+ + + Cornell University + +
+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, + one of the top tools in the Julia language for technical computing.
+ +
+ + + MIT + +
+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 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 and IJulia + (and Julia’s FFTW bindings, 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.
+ +
+ + + DOE Advanced Scientific Computing Research + +
+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 and workshop report + 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 Institutes) + for the projects: FASTMATH + - Frameworks, Algorithms and Scalable Technologies for Mathematics; and + QUEST + - 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).
+ +
+ + + Pfizer + +
+Dr. Cynthia J. (C.J.) Musante is Senior Scientific Director and Head of Quantitative + Systems Pharmacology (QSP) in Early Clinical Development at Pfizer in Cambridge, MA. She + received her Ph.D. in Applied Mathematics from North Carolina State University and has + over eighteen years of experience in QSP modeling. At Pfizer, her group is responsible + for developing and applying mechanistic models and disease platforms to enhance the + robustness and quality of decision-making at the program and therapeutic strategy-level. + Dr. Musante is an advocate for model-informed drug discovery and development approaches. + She currently serves as Treasurer and on the Board of Directors of the International Society + of Pharmacometrics (ISoP), as Co-Chair of the Innovation and + Quality (IQ) Consortium Clinical Pharmacology QSP Working + Group, on the Scientific Programming Committee for the American Society of Clinical + Pharmacology and Therapeutics, and + formerly served as the inaugural Chair of ISoP’s QSP Special Interest Group.
+ +
+ + + NVIDIA + +
+Arch D. Robison is a Principal Systems Software Engineer at NVIDIA, where he works + on 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. He’s used Julia to generate x86 assembly language for a Go + implementation of his video game Frequon Invaders. He also took 2nd place in AI Zimmermann’s contest + "Delacorte Numbers" using Julia exclusively. He has 21 patents and an Erdös number of 3.
+ +
+ + + Carnegie Mellon + +
+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, but + also co-founded and served as the Executive Director for the Scala Center, 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.
+ ++ All talks and workshops for JuliaCon 2019 were streamed live on Youtube. + Recordings of the talks can now be seen on the Youtube channel. +
++ The Julia Community Prize has been announced. Congratulations + to this years winners: Jane Herriman, Jacob Quinn and Mike Innes. +
+ The main conference talks will be held at the University of Maryland, Baltimore SMC Campus Center, 621 W Lombard St, Baltimore, MD 21201, USA: +
+ ++ The workshops will be held at the University of Maryland School of Pharmacy, 20 N Pine St, Baltimore, MD 21201, USA: +
+ + + To know more about the local area, including restaurants and places of interest, click here: http://bit.ly/knowbaltimore ++
+ JuliaCon is dedicated to providing a positive conference experience + for all attendees, regardless of gender, gender identity and expression, + sexual orientation, disability, physical appearance, body size, race, + age, religion, or national and ethnic origin. We encourage respectful + and considerate interactions between attendees and do not tolerate + harassment of conference participants in any form. For example, offensive + or sexual language and imagery is not appropriate for any conference + venue, including formal talks and networking between sessions. Conference + participants violating these standards may be sanctioned or expelled from + the conference (without a refund) at the discretion of the conference organizers. + Our anti-harassment policy and information about who to contact if you have + an issue you'd like to discuss can be found here. +
++ Our preferred conference hotel was the Marriott Inner Harbor at Camden Yard. We had attractive group rates negotiated at the + which you could book using this link: + https://book.passkey.com/e/49861330 . However, this block of rooms is now full, but you can contact the hotel for regular priced reservations. +
+ +Rooms are now available at the Hampton Inn Baltimore-Downtown-Convention Center, which is also very close to our venue. + Book Here. +
++ A few rooms are also available at the Days Inn Inner Harbor, which is just a few blocks away. + Please + click here to book. +
+ +We strongly advise you to book your accommodation in our recommended hotels - they are conveniently located, + reasonably priced, and best for interacting with your fellow attendees. +
+ JuliaCon is organized by a committee composed entirely of volunteers, + and can be reached at juliacon@julialang.org + with any questions or comments. +
+ +The Julia Community Prizes have been announced. A certificate of accomplishement and a cash prize of $1000.00 has been awarded to:
+For her teaching, outreach, and community stewardship
+For contributions to the data ecosystem and core language +
+For spearheading the machine learning ecosystem with Flux +
+ +Prizes were also awarded for best poster:
++ Our congratulations to the winners, and our thanks to the committee.
+ + +The members of the committee for 2019 continue to be Prof Alan Edelman, MIT; Prof Tim Holy, WU; and Mr Curtis Vogt, Invenia. +
++ JuliaCon is a community organized non-profit conference, and it would not be possible without the support of its amazing set of sponsors. We invite your organization to be a sponsor of JuliaCon 2019. +
+JuliaCon is the largest annual conference organized around Julia, the fastest high-performance open source computing language for machine learning, artificial intelligence, life sciences, robotics, algorithmic trading, real-time analytics and more. +
+JuliaCon 2019 will be held at University of Maryland Baltimore July 21-26. It promises to be the biggest and best JuliaCon yet, with more than 350 participants. +
+JuliaCon 2019 sponsorship comes with the following benefits: +
+ ++
+
+
+
+ Our university partners in diversity will financially support JuliaCon 2019 attendance for at least two students from backgrounds that are underrepresented in computing. + Female-identifying students, students with disabilities, students identifying as LGBTQ, students of Hispanic/Latino, African American, Native American, Native Hawaiian/Pacific Islander, biracial descent and possibly others qualify — just ask us! +
+ Your university will receive: +
+ Please talk to us at juliacon@julialang.org if you, or anyone you know, might be interested in sponsoring JuliaCon. +
+ ++ Ticket sales will support the Julia Community through donations to NumFOCUS, a non-profit public charity promoting and supporting the ongoing research and development of open-source scientific data tools through educational, community and public channels. +
+A 50% discount is provided for all students.
++
+ + +Payment via invoices and wire transfers are available for groups of five or more. Please contact us for details. +
+ +Refunds are available upto 30 days prior to the event. After that period, refunds will be considered within 24 hours of purchase, or on a discretionary basis if we are able to sell them on. Please contact us immediately if you change your mind. +
+We will be also be happy to transfer the registration if the original purchaser is unable to attend. Please email us with your request. +
+ +Please email juliacon@julialang.org with any questions, comments or suggestions. +
+ +Early bird tickets are no longer on sale. Current JuliaCon 2019 ticket pricing is as follows
+| Talks | USD 500 |
| Workshop | USD 350 |
| Talks + Workshop | USD 700 |
| 50% discount for students |
+ As a mentor +
+ + + + + ++ JuliaCon 2019 will match first-time JuliaCon speakers desiring guidance to + experienced speakers willing to mentor. We are expecting a time commitment + of maximally a few hours in which mentors will provide feedback on a novice + speaker's presentation. + +Please let us know if you would like to be mentored or if you are willing to mentor a first-time speaker for JuliaCon 2019! +
+ ++ JuliaCon will be offering proceedings for the first time this year, and we need + reviewers to assess submissions. Our review process will be similar to that of + the Journal of Open Source Software (JOSS). More details can be found here. +
++ Once the Call for Proposals closes, we expect to have order of 200 proposals to + review, each of which will require at least three pairs of eyes. Help us create a + fair and expedient review process by agreeing to read and score a set of talk + proposals, and then discuss your evaluation with other volunteers. +
++ We are currently looking for volunteers to review financial assistance applications, + publicized on our financial + assistance page. These applications are shorter in length, so we expect reviewers to + review all applications (about 60) and rate them according to a rubric we will provide. + If the need arises, we may need to have conference calls to discuss certain cases + individually. +
++ Our on-site volunteers help keep the conference running smoothly by helping with items + like registration and set-up at the venue. Help us put on a great event for our community! +
+ +JuliaCon is committed to providing an accessible and inclusive environment to every attendee. In light of our announcement to shift JuliaCon online, our accessibility plans for this year are likely to be very different from prior events.
+We will strive to ensure that the online platforms are compatible with screen readers, and we shall attempt to close caption all our talks.
+Please reach out to the organising committee at juliacon@julialang.org for any additional concerns.
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+