Julia é uma linguagem de programação de código aberto, multi-plataforma, de alto nível e alta performance para computação técnica.

Julia has an LLVM Low-Level Virtual Machine (LLVM) is a compiler infrastructure to build intermediate and/or binary machine code. -based JIT Just-In-Time compilation occurs at run-time rather than prior to execution, which means it offers both the speed of compiled code and the flexibility of interpretation. The compiler parses the code and infers types, after which the LLVM code is generated, which in turn is compiled into native code. compiler that allows it to match the performance of languages such as C and FORTRAN without the hassle of low-level code. Because the code is compiled on the fly you can run (bits of) code in a shell or REPL Read-Eval-Print-Loop , which is part of the recommended workflow .

Julia is dynamically typed, provides multiple dispatch Because function argument types are determined at run-time, the compiler can choose the implementation that is optimized for the provided arguments and the processor architecture. , and is designed for parallelism and distributed computation.

Julia has a built-in package manager.

Julia has many built-in mathematical functions, including special functions (e.g. Gamma), and supports complex numbers right out of the box.

Julia allows you to generate code automagically thanks to Lisp-inspired macros.

Julia was born in 2012.

Para ajudar Julia a carregar rapidamente, muitas das funcionalidades principais existem nas bibliotecas padrão que vem junto com Julia. Para fazer as funções disponíveis, use using PackageName. Aqui estão algumas Bibliotecas Padrão e funções comuns.

Packages must be registered before they are visible to the package manager. In Julia 1.0, there are two ways to work with the package manager: either with using Pkg and using Pkg functions, or by typing ] in the REPL to enter the special interactive package management mode. (To return to regular REPL, just hit BACKSPACE on an empty line in package management mode). Note that new tools arrive in interactive mode first, then usually also become available in regular Julia sessions through Pkg module.

Using Pkg in Julia session

In Interactive Package Mode

Beware of multi-byte Unicode encodings in UTF-8: 10 == lastindex("Ångström") != length("Ångström") == 8 Strings are immutable.

O Julia não checa automaticamente o overflow numérico. Use o pacote SaferIntegers para inteiros com verificação de overflow.

Muitas funções de números aleatórios requerem using Random.

Para a maioria das ferramentas de Álgebra Linear, use using LinearAlgebra.

Julia tem suporte nativo a decomposições matriciais.

Julia tenta inferir se as matrizes são de tipos especiais (Simétricas, Hermitianas, etc.), mas as vezes falha. Para ajudar Julia a despachar algoritmos ótimos, matrizes especiais podem ser declaradas para ter uma estrutura com funções como Symmetric , Hermitian , UpperTriangular, LowerTriangular, Diagonal, e mais.

Todos os argumentos das funções são passadas por referências.

Functions with ! appended change at least one argument, typically the first: sort!(arr).

Required arguments are separated with a comma and use the positional notation.

Optional arguments need a default value in the signature, defined with =.

Keyword arguments use the named notation and are listed in the function’s signature after the semicolon:

function func(req1, req2; key1=dflt1, key2=dflt2)
    # do stuff
end

The semicolon is not required in the call to a function that accepts keyword arguments.

The return statement is optional but highly recommended.

Multiple data structures can be returned as a tuple in a single return statement.

Command line arguments julia script.jl arg1 arg2... can be processed from global constant ARGS:

for arg in ARGS
    println(arg)
end

Anonymous functions can best be used in collection functions or list comprehensions: x -> x^2.

Functions can accept a variable number of arguments:

function func(a...)
    println(a)
end

func(1, 2, [3:5]) # tuple: (1, 2, UnitRange{Int64}[3:5])

Functions can be nested:

function outerfunction()
    # do some outer stuff
    function innerfunction()
        # do inner stuff
        # can access prior outer definitions
    end
    # do more outer stuff
end

Functions can have explicit return types

# take any Number subtype and return it as a String
function stringifynumber(num::T)::String where T <: Number
    return "$num"
end

Functions can be vectorized by using the Dot Syntax

# here we broadcast the subtraction of each mean value
# by using the dot operator
julia> using Statistics
julia> A = rand(3, 4);
julia> B = A .- mean(A, dims=1)
3×4 Array{Float64,2}:
  0.0387438     0.112224  -0.0541478   0.455245
  0.000773337   0.250006   0.0140011  -0.289532
 -0.0395171    -0.36223    0.0401467  -0.165713
julia> mean(B, dims=1)
1×4 Array{Float64,2}:
 -7.40149e-17  7.40149e-17  1.85037e-17  3.70074e-17

Julia generates specialized versions Multiple dispatch a type of polymorphism that dynamically determines which version of a function to call. In this context, dynamic means that it is resolved at run-time, whereas method overloading is resolved at compile time. Julia manages multiple dispatch completely in the background. Of course, you can provide custom function overloadings with type annotations. of functions based on data types. When a function is called with the same argument types again, Julia can look up the native machine code and skip the compilation process.

Since Julia 0.5 the existence of potential ambiguities is still acceptable, but actually calling an ambiguous method is an immediate error.

Stack overflow is possible when recursive functions nest many levels deep. Trampolining can be used to do tail-call optimization, as Julia does not do that automatically yet. Alternatively, you can rewrite the tail recursion as an iteration.

Dicionários são mutáveis; quando símbolos são usados como chaves, as chaves são imutáveis.

Verificação se um elemento está contido em um conjunto é feita em O(1).

Julia não tem classes e, portanto, não há métodos específicos de classe.

Tipos são como classes sem métodos.

Os tipos abstratos podem ser subtipados, mas não instanciados.

Tipos concretos não podem ser subtipados.

Por padrão, struct s são imutáveis.

Os tipos imutáveis melhoram o desempenho e são seguros para threads, já que podem ser compartilhada entre threads sem a necessidade de sincronização.

Objetos que podem ser de um conjunto de tipos são chamados de tipos Union.

Quando um tipo é definido com um construtor interno, os construtores padrões externos não estão disponíveis e devem ser definidos manualmente, se necessário. Um construtor interno é melhor usado para verificar se os parâmetros estão em conformidade com certas condições (invariância). Obviamente, essas invariantes podem ser violadas acessando e modificando os campos diretamente, a menos que o tipo seja definido como imutável. A palavra-reservada new pode ser usada para criar um objeto do mesmo tipo.

Os parâmetros de tipo são invariantes, que significa que Ponto{Float64} <: Ponto{Real} é falso, embora Float64 <: Real. Tipos de tupla, por outro lado, são covariantes: Tuple{Float64} <: Tuple{Real}.

A forma inferida de tipo da representação interna de Julia’s pode ser encontrada com code_typed(). Isso é útil para identificar onde é gerado o código nativo Any e não o tipo específico.

Módulos são espaços de trabalho de variáveis globais separados que agrupam funcionalidades semelhantes.

Existe apenas uma diferença entre using e import : com using você precisa dizer function Foo.bar(.. para disponibilizar a função bar do módulo Foo’s por meio de um novo método, mas com import Foo.bar, você só precisa dizer function bar(... e ele automaticamente disponibiliza a função bar do módulo Foo’s.

Julia é homoicônico: Programas são representados como estruturas de dados da própria linguaguem. De fato, tudo é uma expressão Expr.

Símbolos são sequências de caracteres internas Apenas uma cópia de cada cadeia de caracteres (imutável) distinta é armazenada. prefixadas com dois pontos. Símbolos são mais eficientes e são tipicamente utilizados como identificadores, chaves (em dicionários), ou colunas em data frames. Símbolos não podem ser concatenados.

Citação :( ... ) ou quote ... end cria uma expressão, como parse(str) Essa forma é provavelmente a mais familiar às pessoas com conhecimentos em SQL dinâmico. A função parse é similiar à declaração EXECUTE IMMEDIATE da Oracle e da PostgreSQL ou do procedimento sp_executesql() do SQL server· e Expr(:call, ...).

x = 1
line = "1 + $x"      # algum código
expr = parse(line)   # Cria um objeto de expressão (Expr)
typeof(expr) == Expr # Verdadeiro
dump(expr)           # Gera uma árvore de sintaxes abstratas
eval(expr) == 2      # Avalia um objeto Expr se é verdadeiro

Macros permite que códigos gerados (i.e. expressões) sejam incluídos em um programa.

Regras para criar macros higiênicos:

• Declare variáveis dentro do macro com local .
• Não faça eval dentro do macro.
• Escape expressões interpoladas para evitar expansão: $(esc(expr))

Parallel computing tools are available in the Distributed standard library.

Workers are also known as concurrent/parallel processes.

Modules with parallel processing capabilities are best split into a functions file that contains all the functions and variables needed by all workers, and a driver file that handles the processing of data. The driver file obviously has to import the functions file.

A non-trivial (word count) example of a reducer function is provided by Adam DeConinck.

For dplyr-like tools, see DataFramesMeta.jl.

Many core packages are managed by communities with names of the form Julia[Topic].

A principal convenção em Julia é evitar sublinhados (_), a menos que seja requirido por legibilidade.

Nomes de variáveis são minúsculas: algumavariavel.

Constantes em maiúsculo: ALGUMACONSTANTE.

Funções em minúsculo: algumafuncao.

Macros em minúsculos: @algumamacro.

Nomes de tipo são da forma: AlgumTipo.

Arquivos em Julia possuem uma extensão jl.

Para mais informações de estilo de código do Julia, visite o manual: guia de estilos.

• Write type-stable code.
• In fact, use immutable types where possible.
• Use sizehint for large arrays.
• Free up memory for large arrays with arr = nothing.
• Access arrays along columns, because multi-dimensional arrays are stored in column-major order.
• Pre-allocate resultant data structures.
• Disable the garbage collector in real-time applications: disable_gc().
• Avoid the splat (...) operator for keyword arguments.
• Use mutating APIs (i.e. functions with ! to avoid copying data structures.
• Use array (element-wise) operations instead of list comprehensions.
• Avoid try-catch in (computation-intensive) loops.
• Avoid Any in collections.
• Avoid abstract types in collections.
• Avoid string interpolation in I/O.
• Vectorizing does not improve speed (unlike R, MATLAB or Python).
• Avoid eval at run-time.

• Juno (editor)
• JuliaBox (online IJulia notebook)
• Jupyter (online IJulia notebook)
• Emacs Julia mode (editor)
• vim Julia mode (editor)
• VS Code extension (editor)
• Sublime Text Julia plug-in (editor)
• Sublime Text IJulia plug-in (editor)

• Official documentation .
• Learning Julia page.
• Month of Julia
• Community standards .
• Julia: A fresh approach to numerical computing (pdf)
• Julia: A Fast Dynamic Language for Technical Computing (pdf)

• The 5th annual JuliaCon 2018
• The 4th annual JuliaCon 2017 (Berkeley)
• The 3rd annual JuliaCon 2016
• Getting Started with Julia by Leah Hanson
• Intro to Julia by Huda Nassar
• Introduction to Julia for Pythonistas by John Pearson