Not only for technical computing: changing the narrative around the usecase for Julia

Hi. I’m a relatively new member of the community, and I really only started to dig into Julia in the past few months. I had poked at it a few years ago because I found the initial announcement so intriguing. Here’s a list of things I like in programming:

  • Lisp and metaprogramming
  • Haskell and awesome type systems
  • The write- and readability of Python (and that ecosystem, of course)
  • String processing in Perl
  • Interfaces for working with process calls (I’ve written a couple myself)
  • Making stuff go fast with C
  • Unix-style programming

Sound familiar? So, as you might imagine, the initial announcement hit all the right points for me. I messed with it a little, found some things that were weird to me but I couldn’t be bothered to figure them out, plus, Julia was really just a language for technical computing, and I’m a professional string mangler, so what’s the point, right?

At some point last year, I sort of started to look into it again because I was fairly fascinated by how well thought-out the command literals in the language are, and I thought it might be a more elegant way to replace Bash scripts than doing Python rewrites. (it was, by far)

My experiences inspired me to begin working on a tutorial for administrative scripting with Julia, based loosely on a similar one I wrote for Python.

Since then, I’ve also used it for small string processing and parsing jobs at work, where the thing I needed to do was very simple, but I needed to do it about 800,000,000 times. I’ve used it to solve Advent of Code puzzles (very helpful for getting a feel for the language) and I’m working on using Julia to wrap Raptor, an RDF parser in C.

The thing I notably have NOT used Julia for at all is numeric computing, because that isn’t really in my field of interest or work. (I use some statistics for the string stuff I do, but it’s the kind of thing that can be done in AWK as well as any other language. It’s not fancy.)

I’m consistently amazed that Julia is not only good at general programming tasks, but that it frequently is better for general problems than most of the other languages I like. I mentioned that I’m interested in Unix programming, and Julia is so perfect for that stuff. Standard streams and command-line arguments are in the default namespace, file read functions default to stdin, newlines are omitted by default when iterating over lines (why are Julia and Bash the only languages that get this?). It also has filesystem functions in the default namespace, and those delicious regex and command literals. If you didn’t know anything else about Julia, you’d think it was a language designed to compete directly with Perl.

Then you go to the macros. Macros for days. With the absolute power they give you to manipulate semanitics and define DSL’s, you’d wouldn’t blink if someone told you Julia was designed as a Racket competitor.

Eventually, you hit the point where you want to optimize something and you want speed and concurrency. You can allocate all your buffers and mess around with pointers and flipping bits if it helps. Plus, amazing multiprocessing, fantastic green threads, and pretty OK-ish OS threads (haven’t used them much). You might think it was meant to compete with Go on networking and scalability.

Is Julia great for technical computing? I personally don’t know, but I’m lead to believe it is. However, it is also great for all kinds of other jobs.

I really want to get this message out that Julia isn’t only for scientists and economists, but that it’s also amazing for “normal programmers” like me! The more programmers get into Julia, the better the ecosystem shall be for all of us.

What are some things we might do as a community to promote Julia as a general-purpose language which is great in many domains including but not limited to technical computing?