Newsletter January 2020

As of Jan 1, 2020, Julia has been downloaded more than 12.95 million
times – an increase of 77% in just one year. Julia use and popularity
grew by double digits last year on every one of the 30+ metrics we
track, including those listed below.

Cumulative Julia Growth Statistics Total as of Jan 1, 2019 Total as of Jan 1, 2020 Growth
Number of News Articles Mentioning Julia or Julia Computing 253 468 +85%
Discourse Views (Julia Forums) 12,656,734 22,920,570 +81%
Julia Downloads (JuliaLang.org + Docker Hub + JuliaPro) 7,305,737 12,950,630 +77%
Published Citations of Julia: A Fast Dynamic Language for Technical Computing (2012) + Julia: A Fresh Approach to Numerical Computing (2017) 1,048 1,680 +60%
YouTube Julia Language Channel Views 1,013,276 1,562,223 +54%

Julia Computing Pharmacometrics Webinar Featuring PumasAI and
Pumas.jl: Julia Computing is hosting a free one hour Webinar on Friday
Jan 24 from 12-1 pm EST (US) to discuss pharmacology modeling using
Pumas.jl. The Webinar is led by Vijay Ivaturi,
Professor of Pharmacology at the University of Maryland School of
Pharmacy who initiated and leads the Pumas
project. Please click
here
to register.

Alan Edelman’s Sidney Fernbach Award Presentation on the ‘Power of
Language’ Now Available on YouTube: Alan Edelman accepted the Sidney
Fernbach Award at SC19 with a presentation on the ‘Power of
Language’. This
presentation is now available on
YouTube. Alan is
co-creator of Julia, co-founder and Chief Scientist at Julia Computing,
director of the Julia Lab at MIT and Professor of Applied Mathematics at
MIT. He was awarded the Sidney Fernbach Award for “outstanding
breakthroughs in high-performance computing, linear algebra, and
computational science and for contributions to the Julia programming
language.”

JuliaCon 2020 Deadlines: JuliaCon
2020 will take place July 27-31 at ISCTE –
Instituto Universitário de Lisboa (ISCTE-IUL) in Lisbon, Portugal.

  1. JuliaCon 2020 Call for
    Proposals    : JuliaCon 2020
    proposals are due March 7, 2020. Proposal types include talks,
    lightning talks, minisymposia, workshops, posters and ‘Birds of a
    Feather’ breakout sessions. Please review submission guidelines,
    prepare and submit your
    proposal     no later than March
    7, 2020. Mentorship is also available for new presenters.

  2. Financial Assistance to Attend JuliaCon
    2020    :
    If financial assistance will impact your ability to attend JuliaCon
    2020, please
    apply
    no later than March 7, 2020.

  3. Early Bird Ticket Discount:
    Early Bird Tickets are available for purchase now through April
    20, 2020    . Please purchase
    your tickets early to take advantage of discounted pricing.

  4. JuliaCon 2020 Call for
    Volunteers    : JuliaCon runs on
    volunteers! Please consider signing up to
    volunteer    . JuliaCon
    volunteer opportunities include:

    • Mentors for new speakers
    • Proceedings reviewers
    • Talk submission reviewers
    • Financial assistance application reviewers
    • Local/onsite volunteers
  5. JuliaCon 2020 Sponsors:
    JuliaCon relies on the support of sponsors. Click
    here for more information
    about becoming a JuliaCon sponsor.

Julia #1 Most Exciting New Language for Bioinformatics:
Bioinformatics scientist Albert Vilella conducted a
survey
and identified Julia as the #1 most exciting new language for
bioinformatics.

Parallel Computing and Scientific Machine Learning: MIT instructor
Chris Rackauckas has published his lecture
notes on parallel computing and
scientific machine learning. Lectures include introductions to Julia,
scientific machine learning, code optimization, high performance
computing, parallelism, ordinary differential equations, automatic
differentiation, differentiable programming, GPU computing, neural
networks and more.

Julia for High Schoolers: Julia Computing co-founder and CTO (Tools)
Keno Fischer participated in a Skype a
Scientist session with students at
Athens High School in Athens, Alabama. Keno discussed programming
languages, supercomputers, and how to get started on programming as a
high school student.

Julia On the March: James Warner
asks
“Is Julia Set to Take Over Python the Same Way Python Took Over Java?”
Click
here
to read more.

Getting to Know Julia at 36th Chaos Communication Congress (36C3):
Michael Herbst
presented Getting to Know
Julia at the 36th
Chaos Communication Congress
(36C3)
in Leipzig. Click
here to read more
about the workshop and access workshop materials.

Julia Computing Enterprise Solutions: Contact Julia
Computing for more information about
putting Julia to work for your organization, deploying Julia more
efficiently, effectively and at scale.

  • JuliaSure:
    JuliaSure
    provides enterprise support and indemnity for organizations
    using Julia.

  • JuliaTeam:
    JuliaTeam
    provides enterprise governance including private and package
    development, deployment, management, security, support
    and indemnity.

  • JuliaRun:
    JuliaRun allows
    you to scale Julia deployment from a single machine to dozens or
    hundreds of nodes in a public or private cloud environment,
    including AWS, Azure or Google Cloud.

JuliaBox 30 Day Free Trial: JuliaBox
is now available with a 30 day free trial. JuliaBox is the fastest and
easiest way to start using Julia right away with no download required.
Register today to start your 30 day free
trial.

JuliaBox Academic Discount: Hundreds of students and faculty at
universities around the world use
JuliaBox for classroom instruction and
learning. Use free and open source
materials to design your own course
using Julia. JuliaBox starts at just $7 per month including a 50%
academic discount. Sign up online or
contact Julia Computing to take
advantage of the academic discount or for more information.

Julia and Julia Computing in the News

  • InsideHPC:
    Julia Computing and GPU Acceleration

  • HPCWire:
    Julia Computing to Use Machine Learning and Differentiable
    Programming for Energy Applications

  • InsideHPC:
    Joe Landman on How the Cloud is Changing HPC

  • Economic
    Times    :
    Code Decode – Newer Challenges for Professional Coders

  • Analytics
    Insight    :
    Top 10 Data Science Programming Languages for 2020

  • Robots:
    Top 10 Artificial Intelligence Programming Languages You Must Learn
    In 2020

  • Go Abekawa’s Go
    Global    :
    Interview with Tanmay Bakshi

  • TechBeacon:
    14 Data Scientists You Should Follow on Twitter

Julia Blog Posts

Upcoming Julia Events

Recent Julia Events

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, 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
    JuliaSure, JuliaTeam, or JuliaRun

  • 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 effort. Julia has been downloaded more than
12.95 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 and the 2019 Sidney Fernbach Award. 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.

BYO-Closures For Performance

By: Jacob Quinn

Re-posted from: https://quinnj.home.blog/2019/12/31/byo-closures-for-performance/

Some may be familiar with the idea of closures, which, in short, are local functions that capture state from enclosing context. Closures are obviously supported in Julia, which often just look like anonymous functions; in those docs, it mentions that “Functions in Julia are first-class objects“, which means you can think about them as being defined in the language itself. Indeed, we could take the example of the exponent method for IEEFloats in Base, which is defined (slightly abbreviated) as:

function exponent(x::T) where T<:IEEEFloat
    xs = reinterpret(Unsigned, x) & ~sign_mask(T)
    k = Int(xs >> significand_bits(T))
    if k == 0 # x is subnormal
        m = leading_zeros(xs) - exponent_bits(T)
        k = 1 - m
    end
    return k - exponent_bias(T)
end

And think of this method definition being “lowered” to:

struct exponentFunction <: Function
end

function (f::exponentFunction)(x::T) where T<:IEEEFloat
 xs = reinterpret(Unsigned, x) & ~sign_mask(T)
    k = Int(xs >> significand_bits(T))
    if k == 0 # x is subnormal
        m = leading_zeros(xs) - exponent_bits(T)
        k = 1 - m
    end
    return k - exponent_bias(T)
end

const exponent = exponentFunction()

So here we’re defining a struct exponentFunction, which is a subtype of Function, that all function types inherit from (you can check this yourself by querying supertype(typeof(Base.exponent))). Then we’re defining a method with some unusual syntax to make instances of exponentFunction callable, like exponentFunction()(3.14), which is accomplished with the syntax function (f::exponentFunction)(x::T). Finally, we declare our const exponent to just be an instance of our exponentFunction, which is often known as a “functor”. (Functors are covered in more detail in the Julia manual).

Ok, so why start off a blog post going over a bunch of stuff in the JuliaLang docs manual? Well, in a recent refactoring, I ran into a decently well-known performance issue with closures, which suggested a few different solutions, but none which quite fit my use-case. Now, I have to admit to not fully understanding the fundamental language issue causing the performance hit here; what I do understand from my own code factorings/use is that when you try to use a variable that gets captured as closure state after the closure definition/use, it ends up creating a Core.Box object to put the variable’s value into (which massively affects performance because the variable’s inferred type is essentially Any and then relies on runtime/dynamic dispatch at every use).

Part of my aforementioned refactoring involved moving some common code into higher-order functions that applied functor arguments to each field of a struct, for example, which meant my code was now relying on closures passed to the higher-order functions. Luckily, I tend to use my favorite JuliaLang feature, its code-inspection tools (see @code_typed, for example) to just see what core functions are getting inferred/lowered to, and noticed a bunch of red-flags in the form of Core.Box for key variables. Digging a little further, it became clear that I was a victim of issue #15276 and would need to figure out a solution. One solution suggested in the issue thread was to use let blocks, declaring closure-capture state variables to make it explicit which variables will be captured. In my case, however, I needed the variables to be updated within the closure and then needed those updated values afterwards to pass along (so my parsing functions passed current parsing state down into the closures and need to then pass it along to parse the next object).

So my solution? Well, an extremely unique feature of the Julia language is how much of the language is written in itself, and how many major constructs are true, first-class citizens of the language. So I decided to write my own closure object!

mutable struct StructClosure{T, KW}
    buf::T
    pos::Int
    len::Int
    kw::KW
end

@inline function (f::StructClosure)(i, nm, TT)
    pos_i, x_i = readvalue(f.buf, f.pos, f.len, TT; f.kw...)
    f.pos = pos_i
    return x_i
end

So similar to our exponent example before, we define a StructClosure functor object, which this time has a few fields, which represent the closure-captured state variables that we need access to inside our actual function code. Also note that we made our functor mutable struct because in our function, we actually want to update our position variable after we’ve read a value (f.pos = pos_i).

We end up using our home-grown closure like:

@inline function read(::Struct, buf, pos, len, b, ::Type{T}; kw...) where {T}
    if b != UInt8('{')
        error = ExpectedOpeningObjectChar
        @goto invalid
    end
    pos += 1
    @eof
    b = getbyte(buf, pos)
    @wh
    if b == UInt8('}')
        pos += 1
        return pos, T()
    elseif b != UInt8('"')
        error = ExpectedOpeningQuoteChar
        @goto invalid
    end
    pos += 1
    @eof
    c = StructClosure(buf, pos, len, kw)
    x = StructTypes.construct(c, T)
    return c.pos, x

@label invalid
    invalid(error, buf, pos, T)
end

So we first create an instance of our closure c = StructClosure(buf, pos, len, kw), and then pass it to the higher-order function like x = StructTypes.construct(c, T). Finally, you’ll notice how we return our closure variable at the end with return c.pos, x. How’s the performance? Back in-line with our fully-unrolled, pre-higher-order function code. Ultimately, this actually felt like a pretty simple, even clever solution in order to cleanup my code and use some common, well-tested higher-order functions to do some fancier code unrolling.

As always, hit me up on twitter with any comments or questions and I’m happy to discuss further.