Got errata or suggestions? Email us at info@grox.io
The Julia programming language is one of the fastest growing languages in the world. It’s a multi-paradigm language with concepts from functional and imperative languages. As data science and machine learning become more popular, Julia’s blend of high performance and general purpose features have rapidly driven its adoption by such companies as Apple and Disney. With Groxio as a guide, you can explore with us and find out why.
Throughout the Julia language, you can see powerful features supporting productivity, performance, and friendly features for scientists. Advanced concurrency features allow a higher level of parallelism than most other technical languages support. A rich type system provides the extra performance, documentation, and protection when you want it. Multiple dispatch allows the high levels of reuse that object oriented languages promised but never seemed to deliver.
What really sets Julia apart is the libraries. With high-performance libraries available for everything from machine learning to data manipulation, the Julia language shines where many other functional languages fail. The science-friendly abstractions and language features in Julia make it easy to represent math problems with functions.
Until the last few years, technical computing has always embraced performance as an overriding concern. Data scientists liked the way Python worked, but it wasn’t fast enough. In 2009, Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and Alan Edelman started work on Julia to bridge the gap between productivity and performance in technical computing languages. While MIT was a great place to form the new language, a public university is not always the best steward.
In 2015, the founding team brought in a few more employees, and together founded Julia Computing. Under their careful stewardship, the company has cared for the language, adding a conference, several major clients, and a regular string of new language releases with new features. Julia is now the 28th most popular language in the world.
Julia is the language of scientists, and with MIT's support, it's been attracting a wide range of scientists from around the world. This video explores some tiny problems, showing the flavor of Julia. We look at arrays, matrices, and work some basic plots of both normal and random distributions.
The exercism platform is great for building up your initial vocabulary in a language. In this video, we walk through how it works for Julia, and work twp different problems. Our goal is not to show how problems are solved, but to show how the Exercism platform works for Julia.
The Julia programming language is ideal for building models. We're going to be working on the election polling data and modelling data from fivethirtyeight.com. We won't be going into the same detail. Instead, we'll just provide a naive implementation of a state assuming all states are independent (they aren't), and no other factors matter (they do).
Multiple dispatch is the defining feature of the Julia programming language. In this video, we talk about why we might delay typing decisions, and how to go about building implementations that differ based on the types of inbound arguments. The result is a stunning ability for Julia to adapt and reuse our implementations.
In this video, we explore how to set up your system for the development of Julia packages. We'll use the package manager to create a project, set up a startup file to activate the default project, and look at how we might use the package manager to install local dependencies for our project.
After some early exploration, we take our first step in our election model. The first step in the OSEMN data sciences method is to obtain the data we need. In this video, we get the initial CSVs that we're going to need, and walk through the interfaces we'll use to load and access them.
After we Obtain our data, we take the second step in the OSEMN data sciences method, Scrub. We discuss the "missing" element, and do some basic exploration to suppliment our initial feed with more data we want. We also do some quick poking around to augment our data with other info we need, electoral votes in our case.
In our election model, our strategy is to figure out how to count the votes for a single state. In this video, we do those vote counts one time. We'll need to use a few of Julia's tools to get us off the ground. We'll check our data against a random number, allocating the votes for that state or not depending on the results.
One of the most interesting pieces of the Julia language is how the language dispatches messages. In this section, we build a single function to simulate one state's election several times, and then broadcast the function to each state in the model. We'll use a query pipeline to group results by date.
We are finally to the point where we're ready to explore our election model. We've been working mostly with code so we've used a project in the context of the Julia REPL. Now, we're shifting to data, so we'll put aside the tools of a computer scientist and pick up the tools of a data scientist. We'll view tools in the Julia notebook.
As we explore our data, we're to the point where we want to see trends of multiple data sets at the same time. We need to plot results. To do so, we'll use the VegaLite library, a wrapper around a Python plotting library. We'll graph the trend line of the election by date.
In this video, we'll take a quick look at techniques you can use to refine your exploration. We'll look for potential election tipping points so we can refine our election exploration to look at only the states most likely to decide the election.
In this video, we build a tiny Genie web service. We create an application from scratch, and expose a web service to build a JSON grid of random numbers. We demonstrate how Genie works, and how you can use it to rapidly stand up tiny web services that wrap existing Julia code so it can be consumed elsewhere.
In this video, we look at some of Genie's code loading tools, and how they impact your code organization. We extract our service code from the web service we built in the previous video, and move it to a separate layer. We let Genie's code reloading take care of the rest with its auto reload capability.
In this video, we consume our Genie web service with our Elixir LiveView application. We make use of Elixir's rich integration of HTTP services, and LiveView's capability to rapidly stand up a user interface. We wire up a button to reload the service on demand.
In this short video Bruce Tate, author of Seven More Languages in Seven Weeks and Groxio founder, interviews Chris Rackauckas, builder of the scientific machine learning Flux library for the Julia Language.
In this short video Bruce Tate, author of Seven More Languages in Seven Weeks and Groxio founder, interviews Jeff Bezanson, one of the creators of the Julia Language about what makes Julia unique.
In this short video Bruce Tate, author of Seven More Languages in Seven Weeks and Groxio founder, interviews Huda Nassar. Huda and Bruce talk about graph theory, spending quality time with data and the Julia Language.
This JuliaCon talk from Stefan Karpinski shows why multiple dispatch is the defining feature of the Julia programming language. It's a wonderful exploration of the benefits Julia developers can expect.
These resources will get you on the path to learning with background information, tooling and exercises.
You decide how deep to go. These resources are exercises and projects to cement your learning.
These resources will help you put your new knowledge into context so you'll be better at your everyday job.