This video provides an overview of the entire course.

Go to Julia webpage and download version.

• Install on computer

• Make symbolic links

Get Julia Syntax Highlight.

• Explore navigation

Introduce the Read Eval program loop interface.

• Function and string completion

As a numerical language, numbers are central to Julia’s appeal. This video will be an introduction to numbers, but we will not go into the full depth, as that will require a complete understanding of the Julia type system.

• Explore different ways to create or express numbers

• Deal with integers and gotchas; bit sizes, division, and remainders

• Perform common operations with numbers

In this video, we’ll cover how to use strings in the Julia programming language.

• Explore different ways to create and format strings

• Understand the different ways of accessing one or more characters in a string

• Explain how UTF8 encoding affects the way strings are used

Arrays are a big topic in Julia, but this video will cover only the ways that are common to use arrays in mainstream languages. In Julia, we can do quite a lot more with arrays.

• Create arrays in many different ways

• Access one or more elements in an array in different ways

• Perform common operations such as adding and removing elements

Control flow statements in Julia are quite similar to other mainstream languages. They are used to alter the sequence of evaluated expressions.

• If statements and while loops should be familiar, except they are expressions

• Look at all the ways we can iterate with a for loop

• Create arrays from comprehensions

Functions are central to Julia, as there are no classes with methods. So all code is located in functions. This will just be an introduction to the different ways which we define functions in Julia.

• Define simple one line functions

• Understand anonymous functions

• View an example of creating functions consisting of multiple source code lines

Variables in Julia are handled in similar ways to other dynamic languages. However, there are some unique differences in how types are handled.

• Get to know naming rules, for example, characters you can use in an identifier

• Understand type annotations, associating type information with a variable

• Understand scoping rules, visibility of variables in different scopes

A dictionary is a versatile datatype with many uses. It is also known as a map in some other programming languages. It allows us to access values using keys, which would typically be strings or numbers.

• Know the different ways of creating a dictionary

• Understand the common dictionary operations

• Loop over individual elements in the dictionary

We’ll solve some practical problems within the field of computational biology to get some practical experience building your own functions.

• Understand the different ways of creating a dictionary

• Know the common dictionary operations

• Loop over individual elements in the dictionary

To learn more about types we need to develop some methods to inspect types and learn more about them. How are they related and what fields do they contain?

• Learn how to find super types and subtypes of a particular type

• Print out a type hierarchy

• Inspect internals of a type such as byte size and contained fields

We will do a study of type hierarchies and the relationship between functions and types in Julia.

• Introduce the concept of methods and their relationship to functions and types

• Experiment with methods having different typed arguments

• Experiment with methods having different number of arguments

This video is about conversion and promotion, concepts closely related to how programming languages deal with numbers of different types.

• Learn about when conversion happens behind the scenes

• We will build our own conversion function to learn how conversion works

• Understand how promotion is implemented and how you can create your own promotion functionality

Learn how to create your own Julia types by building types and functions to handle some of the common operations in a 2D drawing package.

• Create a concrete type to represent a circle

• Create more types with a shared abstract type

• Look at how abstract types can be leveraged when creating functions

To learn more about types we need to develop some methods to inspect types and learn more about them. How are they related and what fields do they contain?

• Learn how to find super types and subtypes of a particular type

• Print out a type hierarchy

• Inspect internals of a type such as byte size and contained fields

This video will cover networking in Julia. It will be similar to file IO, using many of the same functions and abstract types. The major difference is the need to deal with latency.

• Learn simple Unix tools to simulate simple clients and servers

• Connect as a client to a server in Julia

• Create a simple server in Julia by running code asynchronously

This video will cover how you read and write files storing tables of data, where the elements are delimited by tabs, comma, colon, and so on.

• Read a tab delimited file containing strings and different number types

• Read and write files with homogenous data, for example, only integers

• Deal with descriptive headers for each data column in a CSV file

How do you manage a program made up of hundreds of functions and types so their names don’t collide and you don’t lose track of what is what?

• You split the program into files which can be loaded individually

• Organize the collections of files into separate modules to avoid naming conflicts

• Import and use your modules in your main program

This video will cover networking in Julia. It will be similar to file IO, using many of the same functions and abstract types. The major difference is the need to deal with latency.

• Learn simple Unix tools to simulate simple clients and servers

• Connect as a client to a server in Julia

• Create a simple server in Julia by running code asynchronously

This video will cover how you read and write files storing tables of data, where the elements are delimited by tabs, comma, colon, and so on.

• Read a tab delimited file containing strings and different number types

• Read and write files with homogenous data, for example, only integers

• Deal with descriptive headers for each data column in a CSV file

Learn how to design common interfaces for multiple types in Julia, and use these interfaces to implement as well-known object-oriented design pattern.

• Introduce expressions and expression trees

• Design an interface to represent expressions

• Contrast explicit Java style interfaces with implicit interfaces as in Julia

You will learn interfaces and object-oriented design further by building a maze using the object-oriented design pattern, builder.

• Discuss interfaces for representing the components of a maze

• Combine parts to build a maze without using the builder pattern

• Show the advantages of using the builder pattern

We'll look at ways of implementing the state pattern by looking at an example of a graphics editor with tools for adding different geometric shapes.

• Represent tool and shape objects

• Switch between tools using the state pattern

• Forward mouse and keyboard events to the right tool

In OOP, many problems are best solved with implementation inheritance. We'll continue our graphics editor example to explore alternatives in Julia to inheritance.

• Discuss how many tools will have the much shared functionality

• Avoid code duplication using implementation inheritance

• Remove code duplication without using inheritance

Higher Order Functions, which are functions taking functions as arguments, is a central concept in Functional Programming.

• Learn how we define our own higher order functions

• Explore usefulness of higher order functions for collections

• Understand Higher Order Functions, creating and returning functions

We'll look at an interesting and important property of all higher order functions operating on collections. They can almost always be abstracted to:

• Mapping or transformation of each value in the collection

• Reduction of all values in a collection to one

• Filtering, to create a subset of a collection

How do we approach design patterns with a functional approach? We'll look at some classic OOP design patterns and implement them by focusing on functions rather than objects.

• Make cars with the factory pattern

• Implement calculator with the undo functionality using the patterncommand

• Switch between different encryption algorithms using the strategy pattern

Putting it all together in a more elaborate example of combining functions to implement a classic OOP design pattern – Interpreter.

• Represent expressions as functions

• Use functions to make functions

• Nest at any level, and make functions, making functions

Implement a linked list to explore common traits of all Julia collections.

• Understand the iteration interface

• Requirements to support common collection functionality

• Give a collection a text representation

Collections fall into different categories depending on what you can do with them.

• Know collections you can iterate over

• Understand Associative Collections,random access by some kind of key

• Also, understand Dequeues, adding and removing elements at the beginning and end

Arrays with multiple dimensions such as matrices.

• Access elements in a multidimensional array

• Get to know various ways of creating multidimensional arrays

• Understand operations which can be performed on them

A collection type which only allows inclusion of unique elements and which can quickly check for the existence of an element.

• Understand different ways of creating a set

• Know the set operations, such as union and intersection

• Useunicode to write set operations in an elegant way

We'll look at a way of combining types into a type, which can be a placeholder for several types, these type combinations are called type unions.

• Know how to define a type union

• Use them in type annotations and assertions

Type unions are interesting, but what can they be used for. What is the benefit for practical programming problems? Here are some of the practical applications we'll look at.

• Understand the smart usage of types to catch bugs early

• Reduce code duplication when dealing with similar looking types

Parametric types are types which can take a parameter as an argument to create a concrete type. This is common in languages such as Java and C++ but unusual in dynamically typed languages like Julia.

• We’ll look at the motivation behind having them in Julia

• A definition and explanation of what parametric types are

• How they can be used

We'll go through two practical examples showing how parametric types can be used for creating generic collections.

• A linked list which can contain any element type

• An array of fixed size and the length is part of its type

Assumptions about types especially in relation to subtypes can easily prove wrong when working with parametric types.

• What are the assumptions to look out for

• Problems with functions taking type parameters

Julia doesn't have nil or null pointers, to get around this limitation Julia has the parametric type Nullable.

• Create Nullable objects

• Check if an object is null

• Where and when it is useful to use Nullable objects

You got a bug in your program, how would you go about finding out how the programs behaves and what is wrong? We'll explore different ways of debugging a Julia program.

• Simple printfor logging-based debugging

• Utilize the Julia REPL to identify badly behaving code

• Get a short intro to using debuggers

Get used to writing code, so that it is easy to catch mistakes or test it.

• Write testable functions

• Make it easy to inspect data and find problems

We'll expand on our binary search tree example and add tests of new functionality.

• Get to know test sets

• Create test data

• Compare floating point values

We'll look at how Julia represents program code internally as this is necessary to understand how code can be made or manipulated at runtime.

• Understand how code is parsed

• Quote code to be able to store and manipulate it

• Expressions and symbols the basic building blocks of code

Macros provide a mechanism for including generated code in your program. Will look at different topics.

• How we can control code generation with macro arguments

• How macros are invoked and used

• Practical issues when creating macros

Julia allows us to generate code at runtime, so we can avoid boilerplate code. We'll look at how this is done with some examples.

• Generate multiple kinds of expression objects in the interpreter pattern to avoid code duplication

• Generate similar looking functions for similar geometry types such as points, 2D vectors, and unit vectors

Do understand how to optimize Julia code, it is useful to know how Julia compiles to machine code. We'll look at the different steps involved.

• Turning high level Julia code to a simpler code through a process called lowering.

• The Abstract Syntax Tree representing parsed Julia code.

• Create a sort of abstract and typed assembly code called LLVMbitcode, before creating the final machine specific assembly.

Correct usage of abstract and concrete types have significant influence on performance.

• Understand Boxing, a way of wrapping up values when the concrete types isn't known

• Know memory layout for different types and performance implications

• View different examples,for example, sorting concrete and abstract numbers, and comparing performance

Type stability is a term coined in the Julia community, and it is the core concept to understand to write high performance Julia code.

• Understand how lack of type stability affects machine code generation.

• Know the causes of type instability

• Understand the approaches to diagnose and avoid type instability