Julia Course

Itinerary

Why an itinerary?

The itinerary is a virtual guide. This optional list describes the highlights of each release to maximize your learning time.

Description

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.

History

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.

Videos

Public & Private

Why videos?

Groxio language modules have two kinds of videos. Our overview videos set the history and context of a language, or wrap up the work we've done, and are free to support language ecosystems. Our coding instruction videos, mostly starting with the second release, are paid content, and each one offers a live coding project.

Every learning level benefits from pair programming. Our videos are professional, but do not scrub away every tiny mistake. That way, you can see how experienced programmers deal with errors and changes in code organization.

1. Intro, functions, arrays, and plots

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.
Subscriber content

2. Exercism exercises in Julia

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.
Subscriber content

3. Election Introduction

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).

4. Multiple Dispatch

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.

5. Generate a Project

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.
Subscriber content

6. Data Science, Obtain

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.
Subscriber content

7. Data Science, Scrub

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.
Subscriber content

8. Simulate One

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.
Subscriber content

9. Broadcast Many

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.
Subscriber content

10. OSEMN: Explore in the Julia Notebook

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.
Subscriber content

11. OSEMN: Explore and VegaLite

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.
Subscriber content

12. OSEMN, Explore and Refine

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.
Subscriber content

13. Genie Web Service

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.

14. Code organization

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.
Subscriber content

15. Call the service in Julia.

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.

Julia, Flux, and AD - Chris Rackauckas

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.

Julia at Escape Velocity - Jeff Bezanson

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.

Speed, Graphs and Data: Huda Nassar Part 1

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.

The Unreasonable Effectiveness of Multiple Dispatch

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.

Community Resources

Cool quick trips for Julia

Why resource links?

Each new chapter has a set of links, separated into three categories. The categories reflect different competency levels and resources that match that stage of learning, for each Groxio release.

Learn It

These resources will get you on the path to learning with background information, tooling and exercises.

1

Do It

You decide how deep to go. These resources are exercises and projects to cement your learning.

1

Grok It

These resources will help you put your new knowledge into context so you'll be better at your everyday job.

1

Projects

Longer Excursions (chapters 3 and 4)

Why projects?

The Dreyfus model is originally instruction for pilots. A typical pilot course is based on reading material to understand context, and then flying a plane. Our videos and PDFs are important, but in the end, programmers need to program in order to learn. Our projects offer different levels of assistance, from "give me the answer" to "make this test pass".