Newsletter August 2019

JuliaCon 2019: JuliaCon 2019, held July 22-26 at the University of Maryland, Baltimore, was the biggest and best JuliaCon to date.

The Unreasonable Effectiveness of Multiple Dispatch: Stefan Karpinski’s JuliaCon presentation on The Unreasonable Effectiveness of Multiple Dispatch is available on YouTube.

Julia Computing JuliaCon Product Presentation: Stefan Karpinski delivered the Julia Computing JuliaCon sponsor presentation describing Julia Computing’s products: JuliaSure, JuliaTeam, JuliaRun, JuliaPro and JuliaAcademy.

Composable Multi-Threaded Parallelism in Julia: Jeff Bezanson and Jameson Nash (Julia Computing) presented composable multi-threaded parallelism in Julia at JuliaCon. More information is available in this blog post in English and Chinese.

Julia User and Developer Survey Presentation: Viral Shah presented the results of the first annual Julia User and Developer Survey at JuliaCon. The results are also available on the JuliaLang blog.

All of the JuliaCon 2019 presentations are available on YouTube including:

Upcoming Julia Computing Events

Julia Computing will be participating in a number of upcoming conferences. Please contact us if you would like to meet with us at any of these events.

  1. New York: Strata Data Conference Sept 23-26 with Viral Shah, Stefan Karpinski, Jon Shepherd and Jerry Amaral (Julia Computing)
  2. Orlando: American Conference on Pharmacometrics (ACoP10) with Viral Shah, Jon Shepherd and Andreas Noack (Julia Computing) Oct 20-23
  3. London: Open Data Science Conference (ODSC) with Avik Sengupta (Julia Computing) Nov 19-22

Live Online Instructor-Led Julia Training

Sign up now for live instructor-led online courses taught by Julia Computing instructors. Each course is 4 hours per day for two days, for a total of 8 hours of instruction per course.

Course Schedule Cost for 8 hours of live online instruction from Julia Computing instructors
Introduction to Julia Day 1: Wed Sept 4 from 11 am – 3 pm ET Day 2: Thurs Sept 5 from 11 am – 3 pm ET $250
Introduction to Machine Learning and Artificial Intelligence Using Julia Day 1: Wed Sept 11 from 11 am – 3 pm ET Day 2: Thurs Sept 12 from 11 am – 3 pm ET $500
Parallel Computing in Julia Day 1: Wed Sept 18 from 11 am – 3 pm ET Day 2: Thurs Sept 19 from 11 am – 3 pm ET $500
Register & Pay

Technology Partnerz – Julia Wins Monte Carlo Benchmarking Evaluation: Technology Partnerz is a management consulting and technology firm specializing in predictive analytics. They benchmarked Julia, R, Excel, Oracle Crystal Ball and @Risk and declared Julia the overwhelming winner:

“And the winner is…. Julia! Julia is the fastest on all dimensions (including development time for coded solutions), period! … Julia is more than 2x faster than R and between 750 to 1500x faster than Excel simulation… Notwithstanding how much faster it may be to derive a one-off answer in Excel, if your goal is to develop a fast, reusable model in a clear and easy to use programming language, than the outcome is pretty much set in Julia’s favor… Julia handles both vector math and looped structures with ease, making it a more forgiving and intuitive to learn. As for Julia, even though I started picking it up for this study, I have been looking at code snippets for years and each time it left me with the feeling ‘Hey. I can do this also!’ That feeling was well founded because within a few weeks in my off-time I was completely productive in Julia.”

Pumas-AI Launches Pumas Software to Advance Drug Development and Patient Care: Pumas-AI is a new company established by University of Maryland School of Pharmacy faculty members Vijay Ivaturi and Joga Gobburu to advance drug development and patient care. Pumas-AI announced the release of Pumas (Pharmaceutical Modeling and Simulation), its first cutting-edge software platform for pharmaceutical researchers, developed together with Chris Rackauckas (MIT, Julia Computing) and Joakim Nyberg (Uppsala). More information is available here and from Technical.ly.

Julia – Come for the Syntax, Stay for the Speed: Nature published an excellent summary article about some of the latest highlights, developments and applications of Julia.

Julia Enters Twitter Controversy via New York Daily News: Alan Edelman (Julia Computing, MIT) discussed Julia, mathematics and addressed the Twitter controversy over the mathematical order of operations in the New York Daily News.

Zygote – A Differentiable Programming System to Bridge Machine Learning and Scientific Computing: Julia Computing’s Mike Innes, Alan Edelman, Keno Fischer, Chris Rackauckas, Elliot Saba and Viral Shah and Will Tebbutt (University of Cambridge) published a paper about differentiable programming using Julia’s Zygote. More information is available in Synced. The Hacker News comments are available here.

Mozilla Is Funding Development to Bring Julia to Firefox: Mozilla is providing funding to Valentin Churavy and the Julia Lab at MIT to bring Julia to Firefox. More information is available here in English, German, Polish, French, Chinese and Swedish.

Julia Computing Products – JuliaSure, JuliaTeam, JuliaRun, JuliaPro and JuliaAcademy: Are you facing challenges getting Julia to work for your organization? Contact the Julia Computing sales team to learn more about our solutions. There is no question related to Julia that our team can’t answer.

JuliaSure: JuliaSure features support and indemnification for your enterprise. Contact Julia Computing for more information and pricing.

JuliaTeam: JuliaTeam from Julia Computing enables enterprise governance, making it easy and safe to install Julia packages within your firewall, help administrators keep track of what packages and versions are in use and ensure that all your external dependencies are secure and up-to-date.

JuliaTeam enables you to:

  • Read and search docs for all internal and external packages in a single place
  • Create and manage private package registries
  • Publish and test private packages as easily as public ones, making sure new versions work seamlessly with all the other versions of packages that your teams are using
  • Benchmark your code to make sure it runs as efficiently as possible and stays fast
  • Download a summary of licenses of all the software you depend on

For more information, contact Julia Computing.

JuliaAcademy: Julia Computing’s training offerings continue to expand. JuliaAcademy is the Julia Computing training platform for 3 types of learning: self-directed, online instructor-led and in-person onsite training.

JuliaAcademy courses include: Intro to Julia, Machine Learning and Artificial Intelligence in Julia, Parallel Computing in Julia, Deep Learning with Flux, Optimization with JuMP and Machine Learning with Knet.

JuliaAcademy provides:

  1. Self-directed training – all online, learn at your own pace
  2. Instructor-led online training – live two-day courses taught by Julia Computing instructors
  3. In-person training – contact us at [email protected] to schedule customized in-person training for your organization

Julia and Julia Computing in the News

  • JAXenter: Julia Takes a Page from Go, Adds Composable Multi-Threading Feature
  • PacktPub: Julia Announces the Preview of Multi-Threaded Task Parallelism in Alpha Release v1.3.0
  • PacktPub: Mozilla Is Funding a Project for Bringing Julia to Firefox and the General Browser Environment
  • Technical.ly: JuliaCon is the Stage for a Week of Programming Talks — and a New Baltimore Company
  • Synced: Julia Computing & MIT Introduce Differentiable Programming System Bridging AI and Science
  • Nature: Julia – Come for the Syntax, Stay for the Speed
  • Technology Partnerz: The Need for Speed 2019 – Comparing Simulation Performance for Crystal Ball, R, Julia and @Risk
  • New York Daily News: Poorly Constructed Math Equation Prompts Twitter Debate – Can You Solve It?
  • ZDNet: Mozilla Is Funding a Way to Support Julia in Firefox
  • Heise: Programmiersprachen: Mozilla Fördert Integration von Julia in den Browser
  • Techworld: Mozilla Firefox Får Stöd För Språket Julia
  • IT Magazine: Firefox Integriert Programmiersprache Julia
  • Nvidia: Spotting Clouds on the Horizon: AI Resolves Uncertainties in Climate Projections
  • PC World: Mozilla Chce Wprowadzić Język Julia Do Firefoxa
  • Developpez: Mozilla Finance un Portage de Julia en WebAssembly
  • CoderCTO: IT资讯 继 Python 解释器移植到 Firefox 后，Mozilla 现在想支持 Julia 和 R
  • Sclate: Programming Languages – Mozilla Promotes the Integration of Julia into the Browser

  • HPCWire: Pumas-AI Launches Pumas Software to Advance Drug Development, Patient Care

  • CNBeta: Mozilla 资助将 Julia 语言带到 Firefox 上
  • CNBeta: Julia Computing 和 MIT 引入可微编程系统 连接人工智能和科学计算
  • TechCentral: Julia vs Python: Which Is Best for Data Science?
  • InfoWorld: Julia vs Python: Which Is Best for Data Science?
  • TechRepublic: JavaScript Borrows Clean Code Feature from F# and Julia Programming Languages in New Babel Release
  • University of Maryland: Researchers’ Company Launches Drug Development Software
  • Inside Big Data: Pumas-AI Launches Julia Language-Based Software to Advance Drug Development, Patient Care
  • Quartz: What R’s Most Popular Tools Say About the State of Data Science
  • DevClass: Mozilla Research Grants
  • Express Computer: New Programming System Developed For AI Applications
  • CIO: 3 Cursos Online para Aprender a Linguagem de Programação Julia
  • CIO: Julia vs. Python: Qual é a Melhor para a Ciência de Dados?
  • HPCWire: Spotting Clouds on the Horizon – AI Resolves Uncertainties in Climate Projections
  • OmniSci: Announcing OmniSci.jl – A Julia Client for OmniSci
  • Mozilla: Mozilla’s Latest Research Grants
  • Big Data Insider: Was Ist XGBoost?
  • Baltimore Business Journal: Faculty at University of Maryland School of Pharmacy Launch Software for Drug Development, Patient Care

Julia Blog Posts

Upcoming Julia Events

Recent Julia Events

Julia Meetup Groups: There are 36 Julia Meetup groups worldwide with 8,326 members. If there’s a Julia Meetup group in your area, we hope you will consider joining, participating and helping to organize events. If there isn’t, we hope you will consider starting one.

Julia Jobs, Fellowships and Internships

Do you work at or know of an organization looking to hire Julia programmers as staff, research fellows or interns? Would your employer be interested in hiring interns to work on open source packages that are useful to their business? Help us connect members of our community to great opportunities by sending us an email, and we’ll get the word out.

There are more than 300 Julia jobs currently listed on Indeed.com, including jobs at Accenture, Airbus, Amazon, AstraZeneca, AT&T, Barnes & Noble, BlackRock, Capital One, CBRE, Charles River Analytics, Citigroup, Comcast, Conde Nast, Cooper Tire & Rubber, Disney, Dow Jones, Facebook, Gallup, Genentech, General Electric, Google, Huawei, Ipsos, Johnson & Johnson, KPMG, Lockheed Martin, Match, Mathematica, McKinsey, NBCUniversal, Netflix, Nielsen, Novartis, OKCupid, Opendoor, Oracle, Pandora, Peapod, Pfizer, Raytheon, Spectrum, Wells Fargo, Zillow, Brown, BYU, Caltech, Dartmouth, Emory, Harvard, Johns Hopkins, Louisiana State University, Massachusetts General Hospital, MIT, Penn State, Princeton, UC Davis, University of Chicago, University of Delaware, University of Kentucky, UNC-Chapel Hill, USC, University of Virginia, Argonne National Laboratory, Federal Reserve Bank, Lawrence Berkeley National Laboratory, Los Alamos National Laboratory, National Renewable Energy Laboratory, Oak Ridge National Laboratory, Pacific Northwest National Laboratory, State of Wisconsin and many more.

Contact Us: Please contact us if you wish to:

  • Purchase or obtain license information for Julia products such as JuliaAcademy, JuliaTeam, or JuliaPro
  • Obtain pricing for Julia consulting projects for your organization
  • Schedule Julia training for your organization
  • Share information about exciting new Julia case studies or use cases
  • Spread the word about an upcoming conference, workshop, training, hackathon, meetup, talk or presentation involving Julia
  • Partner with Julia Computing to organize a Julia meetup, conference, workshop, training, hackathon, talk or presentation involving Julia
  • Submit a Julia internship, fellowship or job posting

About Julia and Julia Computing

Julia is the fastest high performance open source computing language for data, analytics, algorithmic trading, machine learning, artificial intelligence, and other scientific and numeric computing applications. Julia solves the two language problem by combining the ease of use of Python and R with the speed of C++. Julia provides parallel computing capabilities out of the box and unlimited scalability with minimal eff i8ort. Julia has been downloaded more than 9 million times and is used at more than 1,500 universities. Julia co-creators are the winners of the 2019 James H. Wilkinson Prize for Numerical Software. Julia has run at petascale on 650,000 cores with 1.3 million threads to analyze over 56 terabytes of data using Cori, one of the ten largest and most powerful supercomputers in the world.

Julia Computing was founded in 2015 by all the creators of Julia to develop products and provide professional services to businesses and researchers using Julia.

JuliaCon 2019

By:

Re-posted from: https://invenia.github.io/blog/2019/08/09/juliacon/

Some of us at Invenia recently attended JuliaCon 2019, which was held at the University of Maryland, Baltimore, on July 21-26.

It was the biggest JuliaCon yet, with more than 370 participants, but still had a welcoming atmosphere as in previous years. There were plenty of opportunities to catch up with people that you work with regularly but almost never actually have a face-to-face conversation with.

We sent 16 developers and researchers from our Winnipeg and Cambridge offices. As far as we know, this was the largest contingent of attendees after Julia Computing! We had a lot of fun and thought it would be nice to share some of our favourite parts.

Julia is more than scientific computing

For someone who is relatively new to Julia, it may be difficult to know what to expect from a JuliaCon. Consider someone who has used Julia before in a few ways, but who has yet to fully grasp the power of the language.

One of the first things to notice is just how diverse the language is. It may initially seem as a very special tool for the scientific community, but the more one learns about it, the more evident it becomes that it could be used to tackle all sorts of problems.

Workshops were tailored for individuals with a range of Julia knowledge. Beginners had the opportunity to play around with Julia in basic workshops, and more advanced workshops covered topics from differential equations to parallel computing. There was something for everyone and no reason to feel intimidated.

The Intermediate Julia for Scientific Computing workshop highlighted Julia’s multiple dispatch and meta-programming capabilities. Both are very useful and interesting tools. As one learns more about Julia and sees the growth of the community, it becomes easier to understand the reasons why some love the language so much. It has the scientific usage without compromising on speed, readability, or usefulness.

Julia is welcoming!

The various workshops and talks that encouraged diverse groups to utilize and contribute to the language were also great to see. It is uplifting to witness such a strong initiative to make everyone feel welcome.

The Diversity and Inclusion BOF provided a space for anyone to voice opinions, concerns and suggestions on how to improve the Julia experience for everyone. The Diversity and Inclusion session showcased how to foster the community’s growth. The speakers were educators who shared their experiences using Julia as a tool to enhance education for women, minorities, and students with lower socioeconomic backgrounds. The inspirational work done by these individuals – and everyone at JuliaCon – prove that anyone can use Julia and succeed with the community’s support.

The community has a big role to play

Heather Miller’s keynote on Scala’s experience as an open source project was another highlight. It is staggering to see what the adoption of open source software in industry looks like, as well as learning about the issues that come up with growth, and the importance of the community. Although Heather’s snap polls at the end seemed broadly positive about the state of Julia’s community, they suggested that the level to which we’re mentoring newer members of the community is lower than ideal.

Birds of a Feather Sessions

This year Birds of a Feather (BoF) sessions were a big thing. In previous JuliaCons, there were only one or two, but this year we had twelve. Each session was unique and interesting, and in almost every case people wished they could continue after the hour was up. The BoFs were an excellent chance to discuss and explore topics that are difficult to do in a formal talk. In many ways this is the best reason to go to a conference: to connect with people, make plans, and learn deeply. Normally this happens in cramped corridors or during coffee breaks, which certainly did happen this year still, but the BoFs gave the whole process just a little bit more structure, and also tables.

Each BoF was different and good in its own ways, and none would have been half as good without getting everyone in the same room. We mentioned the Diversity BoF earlier. The Parallelism BoF ended with everyone breaking into four groups, each of which produced notes on future directions for parallelism in Julia. Our own head of development, Curtis Vogt, ran the “Julia In Production” BoF which showed that both new and established companies are adopting Julia, and led to some useful discussion about better support for Julia in Cloud computing environments.

The Cassette BoF was particularly good. It had everyone talking about what they were using Cassette for. Our own Lyndon White presented his new Cassette-like project, Arborist, and some of the challenges it faces, including understanding of why the compiler behaves the way it does. We also learned that neither Jarret Revels (the creator of Cassette), nor Valentin Churavy (its current maintainer) know exactly what Tagging in Cassette does.

Support tools are becoming well established

With the advent of Julia 1.0 at JuliaCon 2018 we saw the release of a new Pkg.jl; a far more robust and user-friendly package manager. However, many core tools to support the maturing package ecosystem were yet to emerge until JuliaCon 2019. This year we saw the introduction of a new debugger, a formatter, and an impressive documentation generator.

For the past year, the absence of a debugger that equalled the pleasure of using Pkg.jl remained an open question. An answer was unveiled in Debugger.jl, by the venerable Tim Holy, Sebastian Pfitzner, and Kristoffer Carlsson. They discussed the ease with which Debugger.jl can be used to declare break points, enter functions, traverse lines of code, and modify environment variables, all from within a new debugger REPL mode! This is a very welcome addition to the Julia toolbox.

Style guides are easy to understand but it’s all too easy to misstep in writing code. Dominique Luna gave a simple walkthrough of his JuliaFormatter.jl package, which formats the line width of source code according to specified parameters. The formatter spruces up and nests lines of code to present more aesthetically pleasing text. Only recently registered as a package, and not a comprehensive linter, it is still a good step in the right direction, and one that will save countless hours of code review for such a simple package.

Code is only as useful as its documentation and Documenter.jl is the canonical tool for generating package documentation. Morten Piibeleht gave an excellent overview of the API including docstring generation, example code evaluation, and using custom CSS for online manuals. A great feature is the inclusion of doc testing as part of a unit testing set up to ensure that examples match function outputs. While Documenter has had doctests for a long time, they are now much easier to trigger: just add using Documenter, MyPackage; doctest(MyPackage) to your runtests.jl file. Coupled with Invenia’s own PkgTemplates.jl, creating a maintainable package framework has never been easier.

Probabilistic Programming: Julia sure does do a lot of it

Another highlight was the somewhat unexpected probabilistic programming track on Thursday afternoon. There were 5 presentations, each on a different framework and take on what probabilistic programming in Julia can look like. These included a talk on Stheno.jl from our own Will Tebbutt, which also contained a great introduction to Gaussian Processes.

Particularly interesting was the Gen for data cleaning talk by Alex Law. This puts the problem of data cleaning – correcting miss-entered, or incomplete data – into a probabilistic programming setting. Normally this is done via deterministic heuristics, for example by correcting spelling by using the Damerau–Levenshtein distance to the nearest word in a dictionary. However, such approaches can have issues, for instance, when correcting town names, the nearest by spelling may be a tiny town with very small population, which is probably wrong. More complicated heuristics can be written to handle such cases, but they can quickly become unwieldy. An alternative to heuristics is to write statements about the data in a probabilistic programming language. For example, there is a chance of one typo, and a smaller chance of two typos, and further that towns with higher population are more likely to occur. Inference can then be run in the probabilistic model for the most likely cleaned field values. This is a neat idea based on a few recent publications. We’re very excited about all of this work, and look forward to further discussions with the authors of the various frameworks.

Composable Parallelism

A particularly exciting announcement was composable multi-threaded parallelism for Julia v1.3.0-alpha.

Safe and efficient thread parallelism has been on the horizon for a while now. Previously, multi-thread parallelism was in an experimental form and generally very limited (see the Base.Threads.@threads macro). This involved dividing the work into blocks that execute independently and then joined into Julia’s main thread. Limitations included not being able to use I/O or to do task switching inside the threaded for-loop of parallel work.

All that is changing in Julia v1.3. One of the most exciting changes is that all system-level I/O operations are now thread-safe. Functions like print can be used during a @spawn or @threads macro for-loop call. Additionally, the @spawn construct (which is like @async, but parallel) was introduced; this has a threaded meaning, moving towards parallelism rather than the pre-existing Distributed standard library export.

Taking advantage of hardware parallel computing capacities can lead to very large speedups for certain workflows, and now it will be much easier to get started with threads. The usual multithreading pitfalls of race conditions and potential deadlocks still exist, but these can generally be worked around with locks and atomic operations where needed. There are many other features and improvements to look forward to.

Neural differential equations: machine learning and physics join forces

We were excited to see DiffEqFlux.jl presented at JuliaCon this year. This combines the excellent DifferentialEquations.jl and Flux.jl packages to implement Neural ODEs, SDEs, PDEs, DDEs, etc. All using state-of-the-art time-integration methods.

The Neural Ordinary Differential Equations paper caused a stir at NeurIPS 2018 for its successful combination of two seemingly-distinct techniques: differential equations and neural networks. More generally there has been a recent resurgence of interest in combining modern machine learning with traditional scientific modelling techniques (see Hidden Physics Models, among others). There are many possible applications for these methods: they have potential for both enriching black-box machine learning models with physical insights, and conversely using data to learn unknown terms in structured physical models. For example, it is possible to use a differential equations solver as a layer embedded within a neural network, and train the resulting model end-to-end. In the latter case, it is possible to replace a term in a differential equation by a neural network. Both these use-cases, and many others, are now possible in DiffEqFlux.jl with just a few lines of code. The generic programming capabilities of Julia really shine through in the flexibility and composability of these tools, and we’re excited to see where this field will go next.

The compiler has come a long way!

The Julia compiler and standard library has come a long way in the last two years. An interesting case came up while Eric Davies was working on IndexedDims.jl at the hackathon.

Take for example the highly-optimized code from base/multidimensional.jl:
​

@generated function _unsafe_getindex!(dest::AbstractArray, src::AbstractArray, I::Vararg{Union{Real, AbstractArray}, N}) where N
   quote
       Base.@_inline_meta
       D = eachindex(dest)
       Dy = iterate(D)
       @inbounds Base.Cartesian.@nloops $N j d->I[d] begin
           # This condition is never hit, but at the moment
           # the optimizer is not clever enough to split the union without it
           Dy === nothing && return dest
           (idx, state) = Dy
           dest[idx] = Base.Cartesian.@ncall $N getindex src j
           Dy = iterate(D, state)
       end
       return dest
   end
end

It is interesting that this now has speed within a factor of two of the following simplified version:

function _unsafe_getindex_modern!(dest::AbstractArray, src::AbstractArray, I::Vararg{Union{Real, AbstractArray}, N}) where N
   @inbounds for (i, j) in zip(eachindex(dest), Iterators.product(I...))
       dest[i] = src[j...]
   end
   return dest
end

In Julia 0.6, this was five times slower than the highly-optimized version above!

It turns out that the type parameter N matters a lot. Removing this explicit type parameter causes performance to degrade by an order of magnitude. While Julia generally specializes on the types of the arguments passed to a method, there are a few cases in which Julia will avoid that specialization unless an explicit type parameter is added: the three main cases are Function, Type, and as in the example above, Vararg arguments.

Some of our other favourite talks

Here are some of our other favourite talks not discussed above:

  1. Heterogeneous Agent DSGE Models
  2. Solving Cryptic Crosswords
  3. Differentiate All The Things!
  4. Building a Debugger with Cassette
  5. FilePaths
  6. Ultimate Datetime
  7. Smart House with JuliaBerry
  8. Why writing C interfaces in Julia is so easy
  9. Open Source Power System Modeling
  10. What’s Bad About Julia
  11. The Unreasonable Effectiveness of Multiple Dispatch

It is always impressive how much is covered every JuliaCon, considering its size. It serves to show both how fast the community is growing and how versatile the language is. We look forward for another one in 2020, even bigger and broader.