• general-purpose
• dynamic programming language - extending objects and definitions at runtime
• object-oriented
• functional - mostly, emphasis on function overloading.
• array - vectors and matrix operations
• procedural (imperative)
• structured - if, else
• reflective - ability of a process to examine, introspect, and modify its own structure and behavior
• meta programming - the ability to treat other programs as their data. a program can be designed to read, generate, analyze or transform other programs, and even modify itself while running
• multistaged - compilation is divided into a series of intermediate phases.
• multiple dispatch - choose overloaded or polymorhic function by multiple arguments. Multiple dispatch together with the flexible parametric type system give Julia its ability to abstractly express high-level algorithms decoupled from implementation details.
• concurrent computing - execution need not happen at the same instant, such as multiple clients accessing a server at the same time.
• composable parallel computing - execution occurs at the same physical instant (is impossible on a (one-core) single processor)
• distributed computing with or without using MPI or the built-in corresponding to "OpenMP-style" threads.
• direct calling of C and Fortran libraries without glue code.
• garbage-collected
• no automatic promotion - arguments of operators automatic conversion: 1 + 1.5 as the floating-point value 2.5
• eager evaluation - call by value
• efficient libraries for floating-point calculations, linear algebra, random number generation, and regular expression.
• Dynamic type system: types for documentation, optimization, and dispatch. Dynamic, nominative and parametric.
• Nominal type system: compatibility and equivalence of data types is determined by explicit declarations and/or the name of the types. Nominal type systems contrast with structural systems, where comparisons are based on the structure of the types in question and do not require explicit declarations.
• A built-in package manager
• Lisp-like macros and other metaprogramming facilities
• shell-like abilities to manage other processes
• Coroutines: lightweight green threading
• User-defined types are as compact as built-ins
• Automatic generation of code for different argument types
• Extensible conversions and promotions for numeric and other types
• Support for Unicode, including but not limited to UTF-8
• Call C functions directly (no wrappers or special APIs needed)

pros:

• designed for parallel computing at every level: instruction-level parallelism, multi-threading, GPU computing, and distributed computing. good support for CUDA and concurrent programming, parallel and distributed computing
• math oriented, Powerful n-dimensional arrays
• Julia language is written in itself to a much larger extent than most other languages
• Call external libraries: Fortran, C, or even Python, allowing data exchange between them.

cons:

• too much like Matlab.
• not popular
• work with arrays is not like standard pandas and numpy
• matrix creation is just crazy and documentation is lying

By default, Julia code depends on the Julia runtime to support all Julia features, e.g. threading, but some (non-idiomatic, to smaller or larger degree) Julia code can be compiled to small executables (with limited Julia capabilities). In both cases no source code needs to be distributed.

a just-in-time (JIT) compiler that is referred to as "just-ahead-of-time" (JAOT) in the Julia community, as Julia compiles all code (by default) to machine code before running it.

Julia is a compiled language that runs just-in-time (JIT) for execution, using the LLVM framework.

Python is an interpreted language, which means that the program goes through an interpreter that converts it into bytecode, to be then executed by a virtual machine. Julia is compiled at runtime through LLVM, which improves development and deployment speed.

By default, the Julia runtime must be pre-installed as user-provided source code is run. Alternatively, a standalone executable that needs no Julia source code can be built with e.g. PackageCompiler.jl

implemented using LLVM

Python

Code written in C, Python can be converted to Julia, while the opposite is not possible.

In Julia everything is an object.

Julia's type system is dynamic, but gains some of the advantages of static type systems by making it possible to indicate that certain values are of specific types. (Python is dynamic only) dynamic, nominative and parametric.

type system with parametric polymorphism

• generic functions and generic datatypes - basis of generic programming.
• generic datatypes: struct Point{T}
• generic functions: same_type(x::T, y::T) where {T} = true

ad hoc polymorphism - Operator overloading. polymorphic functions can be applied to arguments of different types

all concrete types are subtypes of abstract types, directly or indirectly subtypes of the Any type, which is the top of the type hierarchy.

type annotations serves three primary purposes:

• to take advantage of Julia's powerful multiple-dispatch mechanism
• to improve human readability
• to catch programmer errors.

Nominal type system: compatibility and equivalence of data types is determined by explicit declarations and/or the name of the types. Nominal type systems contrast with structural systems, where comparisons are based on the structure of the types in question and do not require explicit declarations.

Concrete types may not subtype each other: all concrete types are final and may only have abstract types as their supertypes.

There is no division between object and non-object values: all values in Julia are true objects having a type that belongs to a single, fully connected type graph, all nodes of which are equally first-class as types.

Both abstract and concrete types can be parameterized by other types.

pass-by-sharing - hybrid evaluation technique to pass parameters to a function. This technique uses both commonly used evaluation strategies, that is, pass by value for immutable objects and pass by reference for mutable objects. used in JavaScript, Java, Python, ROR, Julia.

all values are objects, but functions are not bundled with the objects they operate on. Types of all of a function's arguments are considered when selecting a method. It would be inappropriate for functions to "belong" to only their first argument.

Organizing methods into function objects rather than having named bags of methods "inside" each object ends up being a highly beneficial aspect of the language design.

• 2012 launch of pre-1.0 Julia
• 2018 Julia 0.7 and version 1.0
• 2019
  • 1.1 "exception stack" feature
  • 1.2 - built-in support for web browsers
• 1.3 composable multi-threaded parallelism and a binary artifacts system for Julia packages
• 1.4 syntax for generic array indexing to handle e.g. 0-based arrays
• 1.5 record and replay debugging support, for Mozilla's rr tool.changed the behavior in the REPL (soft scope) to the one used in Jupyter
• 1.6 - huge speed up, parallel precompilation and faster loading of packages
• 1.7 2021 - new faster random-number generator
• 1.7.3 2022 - fixing some issues, including at least one security update,
• 1.8 2022 - compiler speedup, in some cases by 25%,[64] and more controllable inlining (i.e. now also allowing applying @inline at the call site, not just on the function itself).

• Julia 1.9.0 2023

  • Caching of native code - solving the time-to-first-execution TTFX/TTFP problem, fast first usage(full precompilation),
  • Package extensions - automatically loads a module when a set of packages are loaded - loads the "weak

  dependency" and extend methods.

  • Heap snapshot - memory is being utilized in your Julia programs
  • Sorting performance - more adaptive sorting algorithm
  • better support for Float16 arithmetic

method of storing only one copy of string.

distinct values are stored in a string intern pool

intern - copy of each string

• types - class in Classes hierarchy
• keywords - not function, not allowed to be used as variable names.
• functions - a set of methods with same name and different parameter types.
• operator - special type of keyword and function.
• Macro - starts with @ - maps a sequence of argument expressions to a returned expression, and the resulting expression is substituted directly into the program at the point where the macro is invoked
• String interning - method of storing only one copy of string. distinct values are stored in a string intern pool. intern - copy of each string.
• dispatch - The choice of which method to execute when a function is applied.
• method - a function with precisely specified parameter types
• REPL - Read–eval–print loop
• type-stable - type of the output is predictable from the types of the inputs. In particular, it means that the type of the output cannot vary depending on the values of the inputs.
• Juxtaposition - compares two things to highlight their similarities and differences. In Julia it is 2x numerical literal coefficients or array without parentheses.

• pandas vs DataFrames.jl https://dataframes.juliadata.org/latest/man/comparisons/
• https://docs.julialang.org/en/v1/manual/noteworthy-differences/

• Base.Sys.STDLIB - A string containing the full path to the directory containing the stdlib packages.
• Base.Sys.isunix([os]) - Predicate for testing if the OS provides a Unix-like interface.
• Base.Sys.isbsd
• Base.Sys.isfreebsd
• Base.Sys.isopenbsd
• Base.Sys.isnetbsd
• Base.Sys.isdragonfly
• Base.Sys.iswindows
• Base.Sys.windows_version()
• Base.Sys.free_memory() - Get the total free memory in RAM in bytes.
• Base.Sys.total_memory() - Get the total memory in RAM

variables to be immediately preceded by a numeric literal, implying multiplication.

• -2x (-2) * x
• √2x (√2) * x
• 2^3x 2^(3x)
• 2x^3 2*(x^3)
• (x-1)x - multiplication
• (x-1)(x+1) and x(x+1) - MethodError: objects of type Int64 are not callable

precedence of numeric literal coefficients used for implicit multiplication is higher than other:

• 1 / 2im equals -0.5im
• 6 / 2(2 + 1) equals 1 / 1.

No whitespace may come between a numeric literal coefficient and the identifier or parenthesized expression which it multiplies.

x = 3
2x^2 - 3x + 1
# 10
1.5x^2 - .5x + 1
# 13.0
2^2x
# 64

conflicts:

• 0xff - 0 * xff
• 1e10 - 1 * e10, and similarly with the equivalent E form.
• 1.5f22 - 1.5 * f22

Solution:

• Expressions starting with 0x/0o/0b are always hexadecimal/octal/binary literals.
• Expressions starting with a numeric literal followed by e or E are always floating-point literals.
• Expressions starting with a numeric literal followed by f are always 32-bit floating-point literals.

1.5F22 is equal to 1.5 * F22.

zero(x) - Literal zero of type x or type of variable x

one(x) - Literal one of type x or type of variable x

• x \ y inverse divide equivalent to y / x
• x ^ y power raises x to the yth power
• x % y remainder equivalent to rem(x,y)

Boolean Operators

• !x negation
• x && y short-circuiting and
• x || y short-circuiting or

Bitwise Operators

• ~x bitwise not
• x & y bitwise and
• x | y bitwise or
• x ⊻ y bitwise xor (exclusive or)
• x ⊼ y bitwise nand (not and)
• x ⊽ y bitwise nor (not or)
• x >>> y logical shift right
• x >> y arithmetic shift right
• x << y logical/arithmetic shift left

"dot" operator .^ perform ^ element-by-element on arrays. a .^ b is parsed as the "dot" call (^).(a,b)

[1,2,3] .^ 3 # 3-element Vector{Int64}:  1   8  27
sin.(A) # will compute the sine of each element of an array A.

comparisons can be arbitrarily chained:

1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5 # true

= and ==

• x = y is true when two objects are programmatically indistinguishable

== Base.isequal(x, y) - somehow hash based.

Core.:===(x,y) -> Bool Core.≡(x,y) -> Bool - mutable objects are compared by address in memory and immutable objects (such as numbers) are compared by contents at the bit level

• Expression Calls
• [A B C …] hcat
• [A, B, C, …] vcat
• [A B; C D; …] hvcat
• A' ctranspose
• A.' transpose
• 1:n colon
• A[i] getindex
• A[i]=x setindex!

These functions are included in the Base.Operators module

const DEFAULT_VAL = 0

typeof(convert(UInt8, x)) # UInt8

MethodError is thrown indicating that convert doesn't know how to perform the requested conversion.

When is convert called?

• Assigning to an array converts to the array's element type.
• Assigning to a field of an object converts to the declared type of the field.
• Constructing an object with new converts to the object's declared field types.
• Assigning to a variable with a declared type (e.g. local x::T) converts to that type.
• A function with a declared return type converts its return value to that type.
• Passing a value to ccall converts it to the corresponding argument type.

Base.promote(xs…) - Convert all arguments to a common type, and return them all (as a tuple)

promote(2, 3//4) # (2//1, 3//4)

+(x::Number, y::Number) = +(promote(x,y)...)

x = 0x123456789abcdef, x = 0b10, x = 0o010

hexadecimal literals, binary and octal literals produce unsigned integer types. The size is the minimal needed size.

exceeding the maximum representable value of a given type results in a wraparound behavior:

x = typemax(Int64)
x + 1 # -9223372036854775808 == typemin(Int64)

The global constant im is bound to the complex number i.

1 + 2im # 1 + 2im
(-3 + 2im) - (5 - 1im) # -8 + 3im
1 + Inf*im # complex(1.0,Inf)
1 + NaN*im # complex(1.0,NaN)

not recommended:

complex(a,b) # 1 + 2im

2//3 	# 2//3
num(2//3)	# 2
den(2//3)	# 3
float(3//4)	# 0.75
isequal(float(a//b), a/b) # true
3//5 + 1 	# 8//5

Base.isbits(x) - Return true if x is an instance of type T is a "plain data" type, meaning it is immutable and contains no references to other values, only primitive types and other isbitstype types.

Base.ismutable(v) - Return true if and only if value v is mutable.

AbstractRange{T} - Supertype for ranges with elements of type T. UnitRange and other types are subtypes of this.

1:5 # 1:5 - range
typeof(1:5) # UnitRange{Int64}

is a concrete type whose data consists of plain old bits

Syntax

primitive type «name» «bits» end
primitive type «name» <: «supertype» «bits» end

Currently, only sizes that are multiples of 8 bits are supported (LLVM)

abstract type which includes as objects all instances of any of its argument types.

particularly useful case of a Union type is Union{T, Nothing}, where T can be any type and Nothing is the singleton type whose only instance is the object nothing

IntOrString = Union{Int,AbstractString} # Union{Int64, AbstractString}

1 :: IntOrString # 1

"Hello!" :: IntOrString # "Hello!"

 1.0 :: IntOrString # ERROR: TypeError: in typeassert, expected Union{Int64, AbstractString}, got a value of type Float64

Core.Tuple - immutable type, Tuples do not have field names; fields are only accessed by index.

Tuple{Types...}
typeof((1,"foo",2.5)) # Tuple{Int64, String, Float64}

Core.tuple(xs…)

tuple(1, 'b', pi) # (1, 'b', π)

Core.NTuple - compact way of representing the type for a tuple of length N where all elements are of type T.

NTuple{N, T}
typeof((1, 2, 3, 4, 5, 6)) # NTuple{6,Int64}

Base.ntuple(f::Function, n::Integer)

ntuple(i -> 2*i, 4) # (2, 4, 6, 8)

Core.NamedTuple

typeof((a=1,b="hello")) # NamedTuple{(:a, :b), Tuple{Int64, String}}

Base.@NamedTuple - more convenient struct-like syntax

@NamedTuple{a::Float32,b::String}((1,"")) # (a = 1.0f0, b = "")
@NamedTuple begin
    a::Int
    b::String
end # NamedTuple{(:a, :b), Tuple{Int64, String}}

Vararg

Core.AbstractArray Base.AbstractVector

x += y	# allocate memory, change reference
x = x .+ 1	# allocate memory.
x .+= y	# to update each element individually. do not allocate

missing object, which is the singleton instance of the type Missing - no value is available for a variable in an observation.

• math operation involving a missing value generally returns missing: missing + 1 => missing
• Standard equality and comparison operators: if any of the operands is missing, the result is missing: missing == 1 => missing

missing === missing # true isequal
missing === 1 # false
isless(1, missing) # true
isless(missing, Inf) # false
isless(missing, missing) # false
 true | missing # true
 false | missing # missing
 false & missing # false
 true & missing # missing
 true && missing # missing
false && missing # false
[1, missing] == [2, missing] # false
[1, missing] == [1, missing] # missing
[1, 2, missing] == [1, missing, 2] # missing
isequal([1, missing], [1, missing]) # true
all([true, missing]) # missing
all([false, missing]) # false
any([true, missing]) # true
any([false, missing]) # missing

Base.skipmissing(itr) - iterator over the elements in itr skipping missing values

https://docs.julialang.org/en/v1/base/collections/#Base.IteratorEltype AbstractRange UnitRange Tuple Number AbstractArray BitSet IdDict Dict WeakKeyDict EachLine AbstractString Set Pair NamedTuple

you can write C-style string code to process ASCII strings, and they will work as expected, both in terms of performance and semantics. If such code encounters non-ASCII text, it will gracefully fail with a clear error message, rather than silently introducing corrupt results.

• String is an abstraction type.
  • "", """ """ - both multiline.
• Char - first-class type representing a single character - a 32-bit integer with a special literal, , whose numeric value is interpreted as a Unicode code point..
• String is immutable
• keyword end can be used as a shorthand for the last index (computed by endof(str))
• endof(str) gives the maximal (byte) index that can be used to index into str.
• length(str) the number of characters in str.
• i = start(str) gives the first valid index at which a character can be found in str (typically 1).
• c, j = next(str,i) returns next character at or after the index i and the next valid character index following that. With start and endof, can be used to iterate through the characters in str.
• ind2chr(str,i) gives the number of characters in str up to and including any at index i.
• chr2ind(str,j) gives the index at which the jth character in str occurs.

nothing — a special value that does not print anything at the interactive prompt

concatentation

• string(a,b)
• * operator

Core.Symbol - used to represent identifiers in parsed julia code (ASTs). Also often used as a name or label to identify an entity (e.g. as a dictionary key). Unlike strings, Symbols are "atomic" or "scalar" entities that do not support iteration over characters. Symbols can be entered using the : quote operator:

:name # :name
typeof(:name) # Symbol

Base.view(A, inds…) - can be called on an AbstractString, returning a SubString.

is an object that maps a tuple of argument values to a return value

• Compound Expressions - alternative function definition
• apply(f,2,3) - alterinative way to call function
• pass-by-sharing -
• Unicode can also be used for function names
• return or last expression evaluated or Nothing instance
• functions is a first-class objects

• to define anonymous function or Closures.

  • f() do x ; body ; end - pass anonymous function with x argument as a first argument to f() call. x is

  optional

  • -> operator: x -> x + 1
• bar(a,b,x…) = (a,b,x) - Varargs Functions
• Optional Arguments: function parseint(num, base=10)
• Keyword Arguments: function plot(x, y; style="solid", width=1, color="black") - i dont get it.
  • function f(x; args…) - args is a dict.

Each function has its own type, which is a subtype of Function.

Types of functions defined at top-level are singletons.

Closures also have their own type, which is usually printed with names that end in #<number

typeof(x -> x + 1) # var"#9#10"

To find all functions for method:

• f - type method name in REPL
• Base.methods(f)

function name ending with a ! indicates that it will mutate or destroy the value of one or more of its arguments.

pass-by-sharing or call-by-sharing - hybrid evaluation technique to pass parameters to a function. This technique uses both commonly used evaluation strategies, that is, pass by value for immutable objects and pass by reference for mutable objects. used in JavaScript, Java, Python, ROR, Julia.

In Julia, all arguments to functions are passed by sharing (i.e. by pointers). ??? wtf

• b.+=1 - do not change reference
• b = b .+ 1 - change reference

https://web.eecs.umich.edu/~fessler/course/598/demo/pass-by-sharing.html

used to separate interface definitions from implementations

function emptyfunc end

f(x::A, y) = _fA(x, y)
f(x::B, y) = _fB(x, y)

Then the internal methods _fA and _fB can dispatch on y without concern about ambiguities with each other with respect to x.

major disadvantage: in many cases, it is not possible for users to further customize the behavior of f by defining further specializations of your exported function f

you should not define local methods conditionally or subject to control flow, use anonymous functions instead:

function f2(inc)
    if inc
        g(x) = x + 1
    else
        g(x) = x - 1
    end
end

function f3()
    function g end
    return g
    g() = 0
end

function f2(inc) g = if inc x -> x + 1 else x -> x - 1 end end

:: operator - attach type annotations to expressions and variables in programs

typeof(object) - get type

(1+2)::Int # check type

x::Int8 = 100
x = 3.5 # ERROR: InexactError: Int64(3.5)

function foo(y)::Float64 # return value
    global x = 15.8    # throws an error when foo is called
    local x::Int8  # in a local declaration
    return x + y
end

typeof(x) # get type

serve only as nodes in the type grap

• the default supertype is Any
• Any – a predefined abstract type that all objects are instances of and all types are subtypes of.
• Union{} - no object is an instance of Union{} and all types are supertypes of Union{}.
• Type - Type is simply an abstract type which has all type objects as its instances.
• Function

Syntax:

abstract type «name» end
abstract type «name» <: «supertype» end

is a collection of named fields, an instance of which can be treated as a single value.

• struct objects are immutable (by default) - cannot be modified after construction.
• object might contain mutable objects, such as arrays, as fields.
• If all the fields of an immutable structure are indistinguishable (=) then two immutable values containing those fields are also indistinguishable:

Two constructors are generated automatically (these are called default constructors)

• accepts any arguments and calls convert to convert them to the types of the fields
• accepts arguments that match the field types exactly

fieldnames(Foo) - get fileds of struct.

mutalbe struct - keyword

• interface between the fields and the user can be provided through Instance Properties https://docs.julialang.org/en/v1/manual/interfaces/#man-instance-properties
• generally allocated on the heap, and have stable memory addresses
• An object with an immutable type may be copied freely by the compiler since its immutability makes it impossible to programmatically distinguish between the original object and a copy.

struct Foo
    bar
    baz::Int
    qux::Float64
end

foo = Foo("Hello, world.", 23, 1.5) # Foo("Hello, world.", 23, 1.5)
typeof(foo) # Foo

mutable struct Bar
    baz
    qux::Float64
    const b::Float64 # required for optimization of code
end

Point{T}

• T parameter - may be any type of all (or a value of any bits type, actually, although here it's clearly used as a type)
• Point - itself is also a valid type object, containing all instances Point{Float64}, Point{AbstractString}, etc. as subtypes.

type parameters are invariant - an expression whose value doesn't change during program execution

problem: Point{Float64} is not a subtype of Point{Real}, the following can't be applied to arguments:

p::Point{Real}
sqrt(p.x^2 + p.y^2)

solution - all arrays whose element type is some kind of Real.:

• function norm(p::Point{<:Real})
• function norm(p::Point{T} where T<:Real)
• function norm(p::Point{T}) where T<:Real;

Parametric Primitive Types

primitive type Ptr{T} 32 end # 32-bit system:
primitive type Ptr{T} 64 end # 64-bit system:

Type{T} - whose only instance is the object T.

isa(Float64, Type{Float64}) # true

Type is simply an abstract type which has all type objects as its instances.

where - keyword, creates a type that is an iterated union of other types, over all values of some variable. Can be replaced with simple :< definition.

Vector{T} where T    # short for `where T<:Any`
Pair{T, S} where S<:Array{T} where T<:Number # equal to: Pair{T, S} where {T<:Number, S<:Array{T}}

Immutable composite types with no fields.

 struct NoFields ; end
NoFields() === NoFields() # true
Base.issingletontype(NoFields) # true

UInt is aliased to either UInt32 or UInt64 as is appropriate for the size of pointers on the system.

if Int === Int64
    const UInt = UInt64
else
    const UInt = UInt32
end

Base.promote(xs…) - Convert all arguments to a common type, and return them all (as a tuple)

It is possible to have two prints: displaying a single object in the REPL and other interactive environments.

struct Polar{T<:Real} <: Number
    r::T
    Θ::T
end

Base.show(io::IO, z::Polar) = print(io, z.r, " * exp(", z.Θ, "im)")

Some functions in Julia's standard library accept Val instances as arguments. can be used to pass the information between functions through the value c, which must be an isbits value or a Symbol.

The intent of this construct is to be able to dispatch on constants directly (at compile time) without having to test the value of the constant at run time.

struct Val{x} ; end

Val(x) = Val{x}() # constructor?

# usage:
firstlast(::Val{true}) = "First" # firstlast (generic function with 1 method)
firstlast(::Val{false}) = "Last" # firstlast (generic function with 2 methods)

firstlast(Val(true)) # "First"
firstlast(Val(false)) # "Last"

https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type

Outer Constructor - can be many. providing additional convenience methods for constructing objects.

Foo(x) = Foo(x,x)
Foo() = Foo(0)

Inner Constructor - only one. enforcing invariants, and allowing construction of self-referential objects

• declared inside the block of a type declaration, rather than outside of it like normal methods.
• can call new special function - creates objects of the block's type.

struct OrderedPair
    x::Real
    y::Real
    OrderedPair(x,y) = x > y ? error("out of order") : new(x,y)
end

function name ending with a ! indicates that it will mutate or destroy the value of one or more of its arguments.

do not indent code in module.

Use 4 spaces per indentation level.

function argument ordering:

• Function argument. Putting a function argument first permits the use of do blocks for passing multiline anonymous functions.
• I/O stream. Specifying the IO object first permits passing the function to functions such as sprint, e.g. sprint(show, x).
• Input being mutated. For example, in fill!(x, v), x is the object being mutated and it appears before the value to be inserted into x.
• Type. Passing a type typically means that the output will have the given type. In parse(Int, "1"), the type comes before the string to parse. There are many such examples where the type appears first, but it's useful to note that in read(io, String), the IO argument appears before the type, which is in keeping with the order outlined here.
• Input not being mutated. In fill!(x, v), v is not being mutated and it comes after x.
• Key. For associative collections, this is the key of the key-value pair(s). For other indexed collections, this is the index.
• Value. For associative collections, this is the value of the key-value pair(s). In cases like fill!(x, v), this is v.
• Everything else. Any other arguments.
• Varargs. This refers to arguments that can be listed indefinitely at the end of a function call. For example, in Matrix{T}(undef, dims), the dimensions can be given as a Tuple, e.g. Matrix{T}(undef, (1,2)), or as Varargs, e.g. Matrix{T}(undef, 1, 2).
• Keyword arguments. In Julia keyword arguments have to come last anyway in function definitions; they're listed here for the sake of completeness.

Don't overuse try-catch: It is better to avoid errors than to rely on catching them.

Julian design philosophy usually won't be defining a bunch of functions like test_pumpkin and test_pineapple, instead it will use dispatches on test for types Pumpkin and Pineapple. This allows for clean/understandable code. It will break tasks up into small type-stable functions which will allow for good performance. It likely will also be written very generically, allowing the user to use items that are subtypes of AbstractArray or Number, and using the power of dispatch to allow their software to work on numbers they've never even heard of.

UpperCamelCase for types and module names.

functions are lowercase (maximum, convert) and, when readable, with multiple words squashed together (isequal, haskey). When necessary, use underscores as word separators. Underscores are also used to indicate a combination of concepts (remotecall_fetch as a more efficient implementation of fetch(remotecall(…))) or as modifiers.

functions mutating at least one of their arguments end in !.

conciseness is valued, but avoid abbreviation (indexin rather than indxin) as it becomes difficult to remember whether and how particular words are abbreviated.

…Base - package names end. lightweight “base” package with the sole function of defining an interface.

Exception

• ArgumentError
• BoundsError
• DivideError
• DomainError
• EOFError
• ErrorException
• InexactError
• InterruptException
• KeyError
• LoadError
• MemoryError
• MethodError
• OverflowError
• ParseError
• SystemError
• TypeError
• UndefRefError

ErrorException

module NameOfModule … end - introducing a new global scope. may contain code for runtime initialization. One can have multiple files per module, and multiple modules per file.

• using .NiceStuff - making NiceStuff (the module name), DOG and nice available, which was exported. is the only form for which export lists matter at all.
  • import ModuleName: f - allow overload function f. using ModuleName: f - dont allow overload. or use full path.
• import .NiceStuff - brings only the module name into scope
• include("file1.jl") - the contents of the source file were evaluated in the global scope of the including module
• export - suggests that users should use and make available with using

The recommended style is not to indent the body of the module.

UpperCamelCase for module names.

parentmodule(UnitRange) - get module of type

This is called a qualified name, module path.

• Base.UnitRange - operator, requires inserting a colon,
• Base.:+. A
• Base.:(==) A small number of operators additionally require parentheses

Renaming

import CSV: read as rd
import BenchmarkTools as BT

baremodule NameOfModule … end - only have using Core

no Core, and code can be evaluated into it with @eval or Core.eval:

Module(:YourNameHere, false, false)

each module introduces its own scope

parentmodule(UnitRange) # Base

module NiceStuff
export nice, DOG
struct Dog end      # singleton type, not exported
const DOG = Dog()   # named instance, exported
nice(x) = "nice $x" # function, exported
end;

using .NiceStuff: nice, DOG # add only those
using .NiceStuff: nice, DOG, NiceStuff
using LinearAlgebra, Statistics

Modules automatically contain:

• using Core, using Base
• definitions of the eval and include functions

Standard modules:

• Core contains all functionality "built into" the language.
• Base contains basic functionality that is useful in almost all cases.
• Main is the top-level module and the current module, when Julia is started.

using Random

PRNGs (pseudorandom number generators) exported by the Random package are:

• TaskLocalRNG: a token that represents use of the currently active Task-local stream, deterministically seeded from the parent task, or by RandomDevice (with system randomness) at program start
• Xoshiro: generates a high-quality stream of random numbers with a small state vector and high performance using the Xoshiro256++ algorithm
• RandomDevice: for OS-provided entropy. This may be used for cryptographically secure random numbers (CS(P)RNG).
• MersenneTwister: an alternate high-quality PRNG which was the default in older versions of Julia, and is also quite fast, but requires much more space to store the state vector and generate a random sequence.

Base.rand([rng=default_rng()], [S], [dims…])

• S - Pick a random element or array
• Random floating point numbers are generated uniformly in [0,1)

rand(Int, 2) # 2-element Array{Int64,1}:  1339893410598768192  1575814717733606317
rand((2, 3)) # 3
rand(Float64, (2, 3)) # 2×3 Array{Float64,2}:

Base.randn([rng=default_rng()], [T=Float64], [dims…]) - Generate a normally-distributed random number of type T with mean 0 and standard deviation 1.

Random.bitrand([rng=default_rng()], [dims…]) - Generate a BitArray of random boolean values. 0 1 0 0 1

Random.randexp([rng=default_rng()], [T=Float64], [dims…]) - Generate a random number of type T according to the exponential distribution with scale 1

Random.default_rng() - Return the default global random number generator (RNG).

Random.seed!([rng=default_rng()], seed) -> rng or seed!([rng=default_rng()]) -> rng

Random.randsubseq([rng=default_rng(),] A, p) - Return a vector consisting of a random subsequence of the given array A.

Random.shuffle([rng=default_rng(),] v::AbstractArray) - Return a randomly permuted copy of v

https://github.com/JuliaStats/Statistics.jl/blob/master/src/Statistics.jl

• std(itr; corrected::Bool=true, mean=nothing[, dims])
• stdm(itr, mean; corrected::Bool=true[, dims])
• var(itr; corrected::Bool=true, mean=nothing[, dims])
• varm(itr, mean; dims, corrected::Bool=true)
• cor(x::AbstractVector)
• cov(x::AbstractVector; corrected::Bool=true)
• mean(itr) mean(f, A::AbstractArray; dims)
• median(itr) median(A::AbstractArray; dims)
• middle(x, y) middle(a::AbstractArray) - ((x + y) / 2) or (min + max)/2
• quantile(itr, p; sorted=false, alpha::Real=1.0, beta::Real=alpha)

using Statistics

quantile(0:20, 0.5) # 10.0
quantile(skipmissing([1, 10, missing]), 0.5) # 5.5

useful:

• Base.extrema(itr; [init]) -> (mn, mx)

Sparse matrix - a matrix in which most of the elements are zero

import Logging

ou don't need to import Logging to create log events; for this the standard logging macros such as @info are already exported by Base and available by default.

system generates some standard information for each event:

• The module in which the logging macro was expanded.
• The file and line where the logging macro occurs in the source code.
• A message id that is a unique, fixed identifier for the source code statement where the logging macro appears. This identifier is designed to be fairly stable even if the source code of the file changes, as long as the logging statement itself remains the same.
• A group for the event, which is set to the base name of the file by default, without extension. This can be used to group messages into categories more finely than the log level (for example, all deprecation warnings have group :depwarn), or into logical groupings across or within modules.

Principle of separating two different concerns

• Creating log events is the concern of the module author
• Processing of log events — that is, display, filtering, aggregation and recording — is the concern of the application author

https://docs.julialang.org/en/v1/base/base/#Standard-Modules

• up Foo will now try to only update Foo
• add will only auto update the registry once per day
• add can now try to only add already installed packages
  • add –preserve=tiered_installed Foo
  • add –preserve=installed Foo
• why to tell you why a package is in the manifest - output is all the different ways to reach the package through the dependency graph

julia> ] # ']' should be pressed
(@v1.9) pkg> add DataFrames

using Pkg ; Pkg.add("DataFrames")

run the tests bundled with package (If you want to make sure everything works as expected):

using Pkg ; Pkg.test("DataFrames")

two ways

• import Pkg; Pkg.offline(true)
• set the environment variable JULIA_PKG_OFFLINE to "true".

When the network connection to GitHub and AWS S3 is not stable.

Since Julia 1.5, https://pkg.julialang.org is used as the default pkg server

federated package management - multiple independent parties can maintain both public and private packages and registries of packages, and that projects can depend on a mix of public and private packages from different registries.

• cannot be a central authority for package naming.
• single project may end up depending on different packages that have the same name
• packages are identified by universally unique identifiers (UUIDs), which get assigned when each package is created.

The Pkg - package manager that ships with Julia lets you

• install
• manage your projects' dependencies
• assists in creating and manipulating project files

two kinds of environments-directories:

• project environment (explicit environment) - project file and an optional manifest file.

  • manifest - complete dependency graph, including all direct and indirect dependencies, exact versions of
  • reproducibility

  each dependency, and sufficient information to locate and load the correct version.

• package directory (implicit environment) - the source trees of a set of packages as subdirectories
  • convenience
• a stacked environment - intermix
  • adding

__init__() function in your module - run exactly once in the lifetime of the code. called after the module is loaded into a process, e.g., by import, using, or require.

Plotting recipes - are extensions to the Plots.jl framework.

Two fundamental recipe libraries are PlotRecipes.jl and StatsPlots.jl.

add

• New plot commands via user recipes.
• Default interpretations of Julia types as plotting data via type recipes.
• New functions for generating plots via plot recipes.
• New series types via series recipes.

StatsPlots.jl add:

• a type recipe for Distributions.
• a plot recipe for marginal histograms.
• a bunch of new statistical plot series.
• @df plotting directly from data tables.

• lw instead of linewidth
• ls instead of linestyle

https://docs.juliaplots.org/latest/generated/statsplots/ https://docs.juliaplots.org/

• observation - row
• feature - column

DataFrame(pairs::Pair…; makeunique::Bool=false, copycols::Bool=true)

DataFrame("customer age" => [15, 20, 25], "first name" => ["Rohit", "Rahul", "Akshat"])

DataFrame(pairs::AbstractVector{<:Pair}; makeunique::Bool=false, copycols::Bool=true)

DataFrame(["a"=>[1,2,3,3], "a"=>[1,2,3,3]], makeunique=true) # vector of Pairs
DataFrame([(x=1,y=2),(x=2,y=3)]) # vector of named typles
DataFrame((a=[1, 2], b=[3, 4])) # named typle - most common
DataFrame([1 0; 2 0], :auto) # matrix with x1,x2 columns
mat = [1 2 4 5; 15 58 69 41; 23 21 26 69] ; nms = ["a", "b", "c", "d"] ; DataFrame(mat, nms)

DataFrame(ds::AbstractDict; copycols::Bool=true)

DataFrame(Dict("a"=>[1,2,3,3], "b"=>[1,2,3,3]))
dict = Dict(:customer_age => [15, 20, 25], :first_name => ["Rohit", "Rahul", "Akshat"]) # faster!

DataFrame(; kwargs…, copycols::Bool=true)

DataFrame()
DataFrame(a=[1,2,3])
DataFrame(a=Int64[], b=Float64[]) # empty typed columns

DataFrame(table; copycols::Union{Bool, Nothing}=nothing)

DataFrame(table, names::AbstractVector; makeunique::Bool=false, copycols::Union{Bool, Nothing}=nothing)

DataFrame(columns::AbstractVecOrMat, names::AbstractVector; makeunique::Bool=false, copycols::Bool=true)

DataFrame(::DataFrameRow; copycols::Bool=true)

DataFrame(::GroupedDataFrame; copycols::Bool=true, keepkeys::Bool=true)

copycols : whether vectors passed as columns should be copied (default=true)

makeunique : false - add suffix _1 to columns with same name.

german.Sex === german[!, :Sex] # true - view
german.Sex === german[:, :Sex] # false - copy

using Pkg ; Pkg.add("CSV")

using CSV

german_ref = CSV.read(joinpath(dirname(pathof(DataFrames)),
                                      "..", "docs", "src", "assets", "german.csv"),
                             DataFrame)

CSV.read(source, sink::T; kwargs…) => T

DataFrame - type

• package https://juliapackages.com/p/dataframes https://juliahub.com/ui/Packages/DataFrames/AR9oZ/1.5.0?page=0
• web doc http://juliadata.github.io/DataFrames.jl/stable/ => https://dataframes.juliadata.org/stable/
• git https://github.com/JuliaData/DataFrames.jl
• Cheat Sheet https://www.ahsmart.com/pub/data-wrangling-with-data-frames-jl-cheat-sheet/
• examples https://github.com/bkamins/DataFrames-Showcase

Statistics

• StatsKit.jl: A convenience meta-package which loads a set of essential packages for statistics, including those mentioned below in this section and DataFrames.jl itself.
• Statistics: The Julia standard library comes with a wide range of statistics functionality, but to gain access to these functions you must call using Statistics.
• LinearAlgebra: Like Statistics, many linear algebra features (factorizations, inversions, etc.) live in a library you have to load to use.
• SparseArrays are also in the standard library but must be loaded to be used.
• FreqTables.jl: Create frequency tables / cross-tabulations. Tightly integrated with DataFrames.jl.
• HypothesisTests.jl: A range of hypothesis testing tools.
• GLM.jl: Tools for estimating linear and generalized linear models. Tightly integrated with DataFrames.jl.
• StatsModels.jl: For converting heterogeneous DataFrame into homogeneous matrices for use with linear algebra libraries or machine learning applications that don't directly support DataFrames. Will do things like convert categorical variables into indicators/one-hot-encodings, create interaction terms, etc.
• MultivariateStats.jl: linear regression, ridge regression, PCA, component analyses tools. Not well integrated with DataFrames.jl, but easily used in combination with StatsModels.

Machine Learning

• MLJ.jl: if you're more of an applied user, there is a single package the pulls from all these different libraries and provides a single, scikit-learn inspired API: MLJ.jl. MLJ.jl provides a common interface for a wide range of machine learning algorithms.
• ScikitLearn.jl: A Julia wrapper around the full Python scikit-learn machine learning library. Not well integrated with DataFrames.jl, but can be combined using StatsModels.jl.
• AutoMLPipeline: A package that makes it trivial to create complex ML pipeline structures using simple expressions. It leverages on the built-in macro programming features of Julia to symbolically process, manipulate pipeline expressions, and makes it easy to discover optimal structures for machine learning regression and classification.
• Deep learning: KNet.jl and Flux.jl.

Plotting

• Plots.jl: Powerful, modern plotting library with a syntax akin to that of matplotlib (in Python) or plot (in R). StatsPlots.jl provides Plots.jl with recipes for many standard statistical plots.
• Gadfly.jl: High-level plotting library with a "grammar of graphics" syntax akin to that of ggplot (in R).
• AlgebraOfGraphics.jl: A "grammar of graphics" library build upon Makie.jl.
• VegaLite.jl: High-level plotting library that uses a different "grammar of graphics" syntax and has an emphasis on interactive graphics.

Data Wrangling

• Impute.jl: various methods for handling missing data in vectors, matrices and tables.
• DataFramesMeta.jl: A range of convenience functions for DataFrames.jl that augment select and transform to provide a user experience similar to that provided by dplyr in R.
• DataFrameMacros.jl: Provides macro versions of the common DataFrames.jl functions similar to DataFramesMeta.jl, with convenient syntax for the manipulation of multiple columns at once.
• Query.jl: Query.jl provides a single framework for data wrangling that works with a range of libraries, including DataFrames.jl, other tabular data libraries (more on those below), and even non-tabular data. Provides many convenience functions analogous to those in dplyr in R or LINQ.
• You can find more information on these packages in the Data manipulation frameworks section of this manual.

And More!

• Graphs.jl: A pure-Julia, high performance network analysis library. Edgelists in DataFrames can be easily converted into graphs using the GraphDataFrameBridge.jl package.

IO:

• DataFrames.jl work well with a range of formats, including:
  • CSV files (using CSV.jl),
  • Apache Arrow (using Arrow.jl)
  • reading Stata, SAS and SPSS files (using ReadStatTables.jl; alternatively Queryverse users can choose StatFiles.jl),
  • Parquet files (using Parquet2.jl),
  • reading R data files (.rda, .RData) (using RData.jl).

Tabular Libraries like DataFrame

• TypedTables.jl: Type-stable heterogeneous tables. Useful for improved performance when the structure of your table is relatively stable and does not feature thousands of columns.
• JuliaDB.jl: For users working with data that is too large to fit in memory, we suggest JuliaDB.jl, which offers better performance for large datasets, and can handle out-of-core data manipulations (Python users can think of JuliaDB.jl as the Julia version of dask).