Creating Julia, with Jeff Bezanson (JuliaHub) - S04E09

In this episode, we speak with Jeff Bezanson, one of the co-creators of the Julia programming language and the CTO of JuliaHub. We start with the history of Julia and why it took a while to take off, the key principles behind the language, how it provides the speed of C with the ease of Python, and what it's been like running such a large open-source project. He sheds light on the original motivation for Julia, the process of creating it, and its involvement in AI.

Hosted by David Mytton (Console) and Jean Yang (Akita Software).

Things mentioned:

ABOUT JEFF BEZANSON

Jeff Bezanson is one of the co-creators of the Julia programming language, along with Stefan Karpinski, Alan Edelman, and Viral B. Shah. He is also a co-founder of JuliaHub, a company that grew out of this project. He has a Ph.D. from MIT where he worked as a research scientist and he has authored a number of academic papers on the Julia language. The intention behind the creation of Julia was to establish a language that was both high-level and fast. His work on it has earned Jeff the J. H. Wilkinson Prize for Numerical Software.

Highlights:

[Jeff Bezanson]: You had to give up performance. That was just a law of the universe that they all learned. Then if you wanted performance, you had to use C or Fortran or something. This was just the way it was. I got introduced to that world of thinking in college and I thought it was really surprising because I knew that high-level languages could be fast. I knew there were good Lisp implementations, you had the ML family languages, there were really good high-level languages that had really, really good compilers and could be fast. And nobody seemed to be using them, which I just thought was amazing. I made it this mission to “Can we get all these people to realize that high-level languages can be fast, and they should be using a high-level language that's fast?” So [Julia] is my attempt to do that.

— [0:02:59 - 0:03:44]

[Jeff Bezanson]: People have been trying to speed up dynamic languages of various kinds for a long time. That's been one of the long-running research threads in computer sciences, starting with a language like Smalltalk, for instance. How do you make it run fast? There's a whole zoo of both dynamic and static techniques. There are some really cool stuff people have invented to take these languages that you can't necessarily statically analyze using standard compiler techniques, and yet, nevertheless, generate fast code from them. It’s a fun game to play is how do we compile these languages that are not cooperative? So that makes it a challenge, which makes it a good research problem. But to me, it's kind of annoying because why do you always have to fight the language design? So instead, I approached it from the opposite direction and said, “All right. What are all the techniques that are known and available for doing this? Then how would you design a language to make those techniques work well?”

— [0:13:18 - 0:14:12]

Let us know what you think on Twitter:

https://twitter.com/consoledotdev

https://twitter.com/davidmytton

Or by email: [email protected]

About Console

Console is the place developers go to find the best tools. Our weekly newsletter picks out the most interesting tools and new releases. We keep track of everything - dev tools, devops, cloud, and APIs - so you don’t have to. 

Sign up for free at: https://console.dev