 This is, you know, I usually give my regular Julia talk, but this is actually slightly different and the talk that I've not done so much of before. This is about building, you know, an open source community and our experience is doing that. So I'm hoping as part of this talk, you know, you'll hear something that's different. I do have a little eclipse related thing as well. So it won't be a completely unrelated talk, but I'm going to introduce, you know, a little bit about what Julia is and you know, why we started building it and how we got to where we have and where we're planning to go from here. I would suggest strongly that you interrupt me with questions as I'm speaking so that we can make this a little interactive rather than me just giving this monologue. All right, so how many people here have heard of Julia before narration introduced it? Okay, fantastic. This is, you know, at least the proportion of hands going up is increasing with every conference now. That's a good thing, right? So, you know, we started this project back in 2009 and it was Jeff Bizansen, Stefan Karpinski and myself who are the three original authors of the All the Julia Code and then Professor Allen Adelman at MIT who's research group anchored the project. It always started from day one as a real open source project under the MIT license. Although of course, just like many other open source projects no one ever knew about its existence until, you know, it kind of got a couple of, you know, it kind of went around on some blogs and stuff. So actually, I think I should show you that blog post just for fun. And here we outlined why we started, why we created Julia, you know, it was, there was one very easy answer, it's because we are greedy. And, you know, what does greed translate into for a programming language? So what we were thinking was, you know, we want the power of MATLAB, we want all the flexibility of LISP. Let me pick up some choice phrases here. So, you know, the dynamism of Ruby, is this readable? Maybe I should make it a little bigger. Yeah, okay. You know, so we had the dynamism of Ruby, macros like LISP, you know, stats like R, gender programming like Python, string processing like Perl, linear algebra like MATLAB. So at first glance, when someone tells you something like, oh, we're creating this new language. And by the way, it's gonna have all these new features which are the best of all these things. It sounds like you're just taking a whole bunch of things and putting it in a mixer and just making a good milkshake out of it or something. And that would have been the case for us as well, but luckily by the time this blog post came out, we had been working on Julia for three years. And there was actually, you know, you could download the repo, compile Julia and decide for yourself if Julia was on the path to meeting some of these goals or not. And even in 2012, when it started getting some real traction, the language had taken shape and it was beginning to meet some of these promises. What happened with this blog post was it was a little funny and tongue-in-cheek and it's not very long, actually. I'd urge you to read it if you're curious about Julia. I think we got everything right except, you know, it's time for a 1.0 release. That's what we thought we were close to in 2012. Here we are in 2016, not yet having released 1.0. In fact, we are releasing 0.5 in the next couple of weeks. We do expect that 1.0 will be next year at the next JuliaCon. And then this blog post got carried all over the places on Reddit, Hacker News, Lambda, The Ultimate, you know, all these, you know, blogs and the aggregators that are wildly read. So it went from being a project with three contributors to a project with almost 30 contributors overnight. And in the first month, I think we had quite a mass of people who were contributing. And some of those early contributors that we attracted actually continue to be some of our core contributors even today. And, you know, just to give you a little bit of background on the kind of the community we were attracted, I think that Julia's been one of a kind when it comes to this, you know, to a numerical scientific community. We've had people come in from various different domains. We've had people come in from computer science who are compiler people. We've had people who've come in from the numerical side who are like professors in universities, teaching, you know, writing all kinds of mathematical software. A good example is, you know, is Professor Steven Johnson from MIT who's the author of the FFTW library that if you're a scientific computing person you might have heard of. Or Professor Tim Holi who's the author of a lot of our area processing and who's actually not a traditional computer scientist. He's a neuroscientist. A lot of our contributions have come from the brain and cognitive sciences people at MIT or embedded computing people at Berkeley or mechanical engineers. So we've had this, you know, while Julia's the language and it's, you know, it's great for a number of reasons that I think are important. I think what makes it a lot more interesting than its language design or the packages or the ecosystem or is its community that it's a platform where all these different people who've otherwise not come together before have now come together and are shaping up something that's, you know, that's new and innovative and different. The very first time, you know, before I started work on Julia, if you told me that I can have a language that's got two major features, is highly productive so that I can write, you know, almost, I can use it almost like a scripting language and it's also very high performance like, you know, C or Fortran or Java. So can I have something that's the speed of C, Fortran, Java with the productivity of, you know, Python or MATLAB? And we were all programmed, you know, when we went to school, college, or wherever we learned programming or, you know, the prevailing wisdom was that this is impossible. You've got to pick either a scripting language and enjoy writing programs or you've got to pick, you know, a systems language and enjoy running programs but you can't do both in the same package. And Julia, I think, was one of the first that broke away from that mold and here's, you know, I'm gonna talk a little bit about how I did that and why. So here's our standard benchmarks. I won't, you know, the purpose is not to try and convince you that Julia's the fastest language. You can convince yourself by downloading it and trying it out but, you know, this is a log scale graph with the ratio of the programming language on the X axis with C. So if a particular implementation in a particular language was as fast as C, you know, that dot would be right here on 10 to the power zero. So right, this is the line where the ratio is one. And the benchmarks are really, really simple. Mandelbrot said parsing a string into an integer, computing the sum of pi, quicksword, some random matrix stuff. And the point is not to write the fastest program using that particular language. So the idea is not to write a vectorized implementation in MATLAB or a numpy implementation in Python but to actually, you know, stress test the compiler or the interpreter to stress test the language. And that's how these codes have been written. A lot has been talked about these things online but if you look at it, Julia's the one with all of these things bunched up as close to, you know, this X axis line that corresponds to the ratio being as fast as C. Fortran, even Fortran doesn't do well because of, you know, it's not that good at string processing, right? And then Go was designed for a different purpose does well but there's, you know, on matrix arithmetic it's not doing well. Java's doing pretty good in this particular one. It's the complex numbers benchmark that is not doing well on the Mandelbrot set. And even the Python, this is the arithmetic one. JavaScript impressive that the, you know the compilers are so good now. So this is one, right? This is a factor of 10 right here. So within a factor of 10. And that's 10,000. So you got Octave. The parsing a string into an integer in Octave is 10,000 times slower than C. So this is what sort of, you know this community has been able to put together and you know, and this is what I find fascinating about this story personally myself. If you want to learn a little bit more about Julia, you know, go to the Julia lang website, julialang.org and you know, we need a better website. Let me say that this is not the best introduction that one can imagine. But these are some of the language features that we have. I'm gonna just point out a few of them. So multiple dispatch is, is everyone familiar with multiple dispatch? Maybe in this audience people are, I see some yeses and some no's. Okay, very quickly multiple dispatch is, I like to think of it as some kind of an extension to object-oriented programming where instead of dispatching on the type of the object, you dispatch on all the types of all the input arguments to a function. And I'm not going to delve into that right now, but apart from that, it's got a great dynamic type system, list-like macros, you can call C, Java, C++, Python, MATLAB, just about any language you want from Julia. It's got coroutines, lightweight threading. It's got distributed processing built into the language. Amazing specialization, that's an outcome of multiple dispatch and a bunch of other stuff. It's open source, it's MIT licensed, and oh yeah, good support for Unicode. I gotta show you this Unicode stuff. It makes for great demos. So I'm just, this is how, this is the easiest way to start using Julia is just fire up a REPL prompt and type away in it. So you got that and then this is the Unicode support. So if I type slash alpha just as in latex and hit tab, I get alpha and then I can assign it a value and then I can do stuff like. So mathematical notation, people love it because you can translate your code from the papers directly into Julia. So all these features actually came about, you know, over time, right? So the Unicode support, yeah, Unicode was always there but you know, the command line completion, the latex like strings, all that stuff came together as more and more scientific computing people started joining the Julia community and then there was a long discussion on GitHub and it all came about. In fact, this was, the thing that made Julia a lot, you know, if I look back at it, right, the three of us who started out the Julia project, Jeff Stefan and myself and the four of us including Professor Edelman, we all span different disciplines, right? So we had pure and applied mathematics all the way to compiler design to, you know, people who did scientific computing such as myself. So we had all these different and Stefan represented a bit of the systems. So all of these people came together and started, you know, this project and as the project has grown, each of these kinds of people, each of these different kinds of domains have got representation and that leads to things like, you know, what I showed you, like the Unicode symbols in the editors or in the repel. So yeah, it's great, it's got good performance. You know, we have this thing called Julia Box which runs online and let me actually just show a code right here. So this is a, you know, if you wanted to load a simple data set, this is the New York housing data set, it's a CSV file, you can look at it, you can make plots out of it, you can make different kinds of plots with different kinds of colors for different data points, histograms. This is all running on a server on Google Cloud right now and I'm just running it inside my browser. So this is, you know, this is yet another kind of tooling that has come on top of Julia. There's nothing Julia specific, but it's Julia Box integrates Julia and all its packages and does a great job of running it online. But what other applications, you know, what are the motivating uses of Julia, right? That's what you might figure, like how did this all come together? Here's, you know, so this is a very data sciencey kind of thing, you know, you can imagine running regressions on this thing and machine learning and figuring out who lives there and so on and so forth. Here's, let me see, right? So this is the Berkeley Autonomous Race Car. This was, this is running Julia on this little car. So the car's like about this big, actually. It's an open source, open project of some kind. I don't know what you call open hardware projects. Do you call them open source still or you call them open hardware? I'd say this is an open hardware project. So it's running a little onboard on that car itself which is running Julia and doing real-time optimization to do path planning. So, you know, it needs to know exactly when to slam the brakes so that it can slide into that parallel parking spot right there. So I'm gonna just run it once more and shut it off. So this is a, you know, completely different use case from the data science use case that I showed, right? So this was optimization in real-time. Here's another use case that, you know, motivates a lot of things in Julia. This is a project called Celeste. It's actually a project from UC Berkeley and the Lawrence Berkeley National Labs and what it's doing is it's using the Sloan Digital Sky Survey which is hundreds of terabytes of astronomical scans and it is using machine learning to label every object in the, every object that's visible in these telescopic scans. It's expected that it'll take one of the biggest machines on the planet, one of the biggest supercomputers several days to process this whole thing and that's what's going to happen sometime next year. This project is waiting for Intel's next generation night's landing processor to be installed in the supercomputer at Lawrence Berkeley National Labs and then to get enough time scheduled so that it can run on the whole thing. But in the meantime, we are trying to make Julia work, you know, in multi-threading and scale it up and all kinds of performance issues that wouldn't have come up unless someone was pushing it at this scale. So I think you're, you know, you might see a pattern, right? Like the housing data stat, the housing data set showed, you know, the standard kind of statistical modeling that you might want to do as you slice and, you know, slice and dice data. You had, I had an embedded use case where you're Julia running on that self-driving car or, you know, you have this thing like Celeste, which is, you know, which is sort of, you know, mapping the sky. And there are, you know, there are tons and tons of different applications like this, we have applications in genetics, people doing amazing stuff, people doing amazing stuff in mathematical modeling for drug interactions. Do you name it? That kind of research is probably already happening in Julia. And each of these domains has come out, you know, has happened over time, right? So embedded computing only happened because, you know, some of us got together and started porting Julia to ARM a couple of years ago. And then we started putting out some of the first binaries and then others saw those things and were like, oh wow, this is the best way to do optimization. I don't wanna go and write all this code using GLPK or IP opt or all these other solvers which have pretty horrific interfaces, programming interfaces, but the Julia interface is great. All right, it exists. Let's take it, put it on and then the feedback loop starts as you would know in any other software, right? That once users start using it, you learn what needs to be done and you start putting it together. How much more time do I have? Okay. So these were the different kinds of use cases that got different communities together who would not otherwise have been in the same community. I think you see this a lot in Python where the scientific community, it's the scientific community and the numerical community in Python interact through projects like NumPy or Pandas, but not with the core Python language. And that's something that I think in Julia we've been able to do better than most other languages is we've been able to get all the computer science people and the domain people on the same platform and that's the message I kind of keep repeating. All our development is on GitHub and we've had 500 contributors so far and it's a pretty active project. If I just go and look at my notifications for Julia, there have been eight more issues updated in the last hour or so, issues, pull requests, all kinds of stuff. I think folks from the Eclipse Foundation out here, you guys, I was talking to Mike over the break and it's like 50,000, 100,000, something like that, doesn't even matter anymore. Yeah, it's a couple orders of magnitude different but for us managing a programming language with 500 contributors already is kind of stressing us to the point that we keep having to invent newer processes. So we never used to have documentation before 2012, we never had test cases, contributions started coming in, continuous integration came in, test frameworks got written, documentation systems got written and rewritten and rewritten at least a couple of times by now. So I think these kinds of are the growing pangs of growth for a new language. Something like JUnit that you might take for granted in Java needs to be reimagined in Julia from scratch. And I think only in the next release of Julia 0.6 are we gonna be ready with what is going to be our next generation test framework which is gonna be the second one now. So that's on our development processes, it's a lot's going on there, a lot of people have now taken on testing and documentation as ownership within the community and they're just focusing on that which is a great outcome. Over and above that we actually wrote a package manager which is completely based on Git so you could have a Git repository anywhere and register the URL in our metadata and then that gets your registered Julia package. And we are at 1,091 registered packages as of today this happened over the last three years and I'd just like to show this. So this is the last three years of our package growth from 300 packages to 1,000. You can see that as new releases come support for old things kind of drops off and new things, new packages only support the latest version of Julia as you'd expect. And these are all the new packages that came out in the last couple of weeks. So a lot of active development while it's focused on numerical and scientific things there's all kinds of things that you'll see in here. All right so to end with this the last thing on the community side is Julia Kahn. We, one of the things that started happening was that in 2014 couple of guys in Chicago came together and said hey we think there should be enough demand to have a little Julia Kahn and let's get everyone together and that's how the first Julia Kahn happened in Chicago at the University of Chicago campus and then we've done it twice since then once in Bangalore and twice at MIT and it's now up to 250 people and all the videos are online. We actually had a Nobel Laureate. This was the poster that we had. So we had a Nobel Laureate, Thomas Sargent who came and gave the keynote speech in Julia and he's actually a Julia user himself and he's actually started, he actually codes in Julia and he learned it at his age which is really amazing and he was actually telling me that I met this 25 year old who was telling me oh I only know Python and I'd never learned Julia and he said if I could learn this at 70 why can't you learn it at 25? And so that was very exciting for us to hear. By the way that's another domain macroeconomics that's taking on to Julia in a big way. The New York Fed is using it for building models of the US economy. Some researchers at the Bank of England are using it. Folks at various banks and insurance companies are using it to model risk. So these are all various kinds of use cases that would not have been possible or this is a poster. So we had Guy Steele come and talk to us about the Fortress design. So there's a lot of fun of the last Julia Con and we think it's gonna keep scaling and keep getting better. The next one is likely to be on the west coast of the US. So either one of the universities maybe Berkeley or Stanford, wherever we can find cheap space. I guess that's the driver of all these things. So yeah, that's, I think I'm gonna stop right here and maybe take a couple of questions. I don't know, yeah. Do download it and try it out. It's a single download, no hassle. Oh, sorry. One more thing I forgot to get to the last point here are the eclipse connection. So Julia DT is our developer toolkit for eclipse. And this is an open source project. It's out there and this provides Julia support in eclipse. It does all the basic syntax highlighting and stuff and it also integrates the Julia REPL. If you have it, it will find it on your computer or you can point it there. It will load it up and then you can highlight code in the eclipse window and sort of execute it in the REPL and play around with it interactively. If there are questions, I'll take them or I'll just try to see if I can get a couple of screenshots of this stuff. A lot of our ideas come up on the mail. They used to be on the Julia Dev mailing list but nowadays it's mainly on GitHub issues. So what we do is when someone comes up with an idea, we call this thing as Julep, which is kind of like PEP in some sense, like the Python stuff. And the idea is to write these up formally and put them in a single place. We haven't done a great job with it yet but starting with the next release, we are going to put the first Julep in its own repository and start making a little bit more of an RFC process. So we are going to do that with our package manager revision now and that's gonna kickstart. We've kind of stuck with the loose time bound being about nine to 12 months so far. We'd like to get to six months like the LLBM project. A lot of people in the community have been asking for time bound but it's very difficult, has been very difficult so far because of our dependencies on LLBM and a number of other projects. The interactions are quite complex and sometimes issues just take far too long to resolve. I do hope we'll get to like a six month release cycle after 1.0. We have a user manual which is quite comprehensive but we do not have, for example, a formal definition of the grammar of the language. Most of these languages, this comes as a shock to most tool developers that we do not have this and the person who wrote the Eclipse plugin had to struggle quite a bit to even get basic things to work in Eclipse which otherwise would be straightforward to get working. The challenge here is that for a mathematically oriented language, there is a lot of burden on the syntax. You don't have enough kinds of brackets, for example, to represent everything. You don't get enough kinds of operators, enough characters. So if you look at Julia's operators, I don't know how to get the whole list. We actually provide the user, not just the usual operators that are in the ASCII set but probably several dozens of unicode characters. So you can have the set union or the set intersection or the big cup or the small cup or everything you can imagine. So this places a lot of stress on the tooling and the grammar, for example, of the language. So it's not been able, we've not put in effort to put it out there. Even our parsers actually is a little scheme program which very tightly interprets the Julia grammar and wide space ends up meaning too many different things than I would personally like, but that's just, by the way, this problem is not just in Julia. It's common across all languages of this kind. And that's just how it is. I think we need to try and just come up with better tooling on our side. Right, absolutely. And many people have brought this up but it's just open source community and driving it and there's too many demands. So over time, the language becomes the spec instead of the other way around, unfortunately. That said, the compiler is actually small enough that it fits within 10,000 lines of C. And the base library is probably 30,000 lines of Julia but that includes the whole mathematical library, right? So matrices, arrays, decompositions, all that stuff. Any other questions? Sorry, Eclipse. No, I haven't heard of it, but I've been speaking with, yeah. Oh, the Eclipse science, sorry. I thought Eclipse science, so I wasn't, yeah. Okay. Yeah, Julia is part of the numfocus foundation at the moment, which houses a number of other numerical software and yes, that's how we got started, no other reason. I met Mike, narration introduced me to Mike only I think last year and we were already in the numfocus foundation by then. But we would like to collaborate very closely with the science working group. All right, thank you.