O que é…?

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 tem um compilador JIT A compilação Just-In-Time ocorre em tempo de execução, em vez de antes da execução, o que significa que a mesma apresente a velocidade de código compilado e flexibilidade de código interpretado. O compilador analisa o código e deduz tipos, depois disso, o código LLVM é gerado, o qual é compilado para código nativo. baseado em LLVM Low-Level Virtual Machine (LLVM) é uma infraestrutura de compilador para compilar código de máquina binário e/ou intermediário. que a permite chegar a performance de linguagens como C e FORTRAN sem as dificuldades de código de baixo nível. Como o código é compilado na hora, você pode executar (pequenos) códigos em uma shell ou em um REPL Read-Eval-Print-Loop , que é parte do workflow recomendado.

Julia é tipada dinamicamente, o que permite o Dispatch MúltiploComo os tipos dos argumentos de funções são determindados em tempo de execução, o compilador pode escolher a implementação que é otimizada para a arquitetura de processador e aos argumentos providos, e é feita para paralelismo e computação distrubuida.

Julia tem um gerenciador de pacotes nativo.

Julia tem várias funções matemáticas, incluindo funções especiais (ex: Gamma), e suporta números complexos nativamente

Julia te permite gerar código automagicamente por causa dos macros inspirados por Lisp

Julia nasceu em 2012

O Básico


Atribuição	`answer = 42` `x, y, z = 1, [1:10; ], "Uma string"` `x, y = y, x # troca x e y`
Declaração de constante	`const DATA_DE_NASCIMENTO = 2012`
Comentário de final de linha	`i = 1 # Isso é um comentário`
Comentário deliminitado	`#= Isso é outro comentário =#`
Encadeamento	`x = y = z = 1 # direita-para-esquerda` `0 < x < 3 # true` `5 < x != y < 5 # false`
Definição de Função	`function adicionar_um(i)` `return i + 1` `end`
Definição de Função (Forma por atribuição)	`adicionar_um(i) = i + 1`
Inserir simbolos LaTex	`\delta` + [Tab]

Operadores


Aritmética Básica	`+`, `-`,`*`,`/`
Exponencial	`2^3 == 8`
Divisão	`3/12 == 0.25`
Divisao Inversa	`7\3 == 3/7`
Resto da Divisão	`x % y` ou `rem(x,y)`
Negação	`!true == false`
Igualdade	`a == b`
Igualdade ((estrutura) O operador padrão de comparação somente compara endereço de memória para esse tipo de estrutura.)	`is(a, b) # feito no nível do bit`
Desigualdade	`a != b` ou `a ≠ b`
Menor e Maior	`<` e `>`
Menor ou igual	`<=` ou `≤`
Maior ou igual	`>=` ou `≥`
Operações elemento a elemento	`[1, 2, 3] .+ [1, 2, 3] == [2, 4, 6]` `[1, 2, 3] .* [1, 2, 3] == [1, 4, 9]`
Não é um número(Not a Number)	`isnan(NaN)` not(!) `NaN == NaN`
Operador Ternário	`a == b ? "Equal" : "Not equal"`
Operadores de Curto-Circuito(E e OU)	`a && b` e `a \|\| b`
Equivalência de Objetos	`a === b`

A shell, também conhecida como, o REPL


Reutilizar o último resultado	`ans`
Interromper a execução	[Ctrl] + [C]
Limpar tela	[Ctrl] + [L]
Executar programa	`include("filename.jl")`
Encontrar ajuda relacionada a uma função	`?func`
Ver todos os locais onde uma função está definida	`apropos("func")`
Modo de linha de comandos	`;`
Modo de gerenciador de pacotes	]
Modo de ajuda	?
Sair do modo especial / Voltar à REPL	[Backspace] numa linha vazia
Sair da REPL	`exit()` ou [Ctrl] + [D]

Bibliotecas Padrão

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.


`Random`	`rand`, `randn`, `randsubseq`
`Statistics`	`mean`, `std`, `cor`, `median`, `quantile`
`LinearAlgebra`	`I`, `eigvals`, `eigvecs`, `det`, `cholesky`
`SparseArrays`	`sparse`, `SparseVector`, `SparseMatrixCSC`
`Distributed`	`@distributed`, `pmap`, `addprocs`
`Dates`	`DateTime`, `Date`

Gerenciamento de Pacotes

Pacotes devem ser registrados antes de serem visíveis ao gerenciador de pacotes. Em Julia 1.0, existem duas formas de utilizar o gerenciador de pacotes: Ou com using Pkg e usando funções Pkg, ou digitando ] no REPL para entrar no modo Gerenciamento de Pacotes Interativo. (Para voltar para o REPL normal, pressione BACKSPACE em uma linha vazia no modo de gerenciamento de pacotes). Note que novas ferramentas chegam no modo interativo primeiro, e depois se tornam disponíveis em sessões Julia normais por meio do módulo Pkg

Usando `Pkg` em uma sessão Julia


Listar pacotes instalados (Legivel para humanos)	`Pkg.status()`
Atualizar todos os pacotes	`Pkg.update()`
Instalar `NomedoPacote`	`Pkg.add("NomedoPacote")`
Reconstruir `NomedoPacote`	`Pkg.build("NomedoPacote")`
Usar `NomedoPacote` (depois de instalação)	`using NomedoPacote`
Remover `NomedoPacote`	`Pkg.rm("NomedoPacote")`

No modo de Gerenciamento de Pacotes Interativo


Adicionar `NomedoPacote`	`add NomedoPacote`
Remover `NomedoPacote`	`rm NomedoPacote`
Atualizar `NomedoPacote`	`update NomedoPacote`
Usar versão de desenvolvimento	`dev NomedoPacote` or `dev URLdoRepositórioGit`
Parar de usar versão de desenvolvimento e reverter para versão pública	`free NomedoPacote`

Caracteres e Strings


Charactere	`chr = 'C'`
String	`str = "Uma string"`
Código do caractere	`Int('J') == 74`
Caractere atrelado ao código	`Char(74) == 'J'`
Qualquer caractere UTF	`chr = '\uXXXX' # HEX de 4 digitos` `chr = '\UXXXXXXXX' # HEX de 8 digitos`
Ciclar entre caractéres	`for c in str` `println(c)` `end`
Concatenação	`str = "Aprenda" * " " * "Julia"`
Interpolação de Strings	`a = b = 2` `println("a * b = $(a*b)")`
Primeiro caractere ou expressão regular encontrada	`findfirst(isequal('i'), "Julia") == 4`
Substituir substring ou expressão regular	`replace("Julia", "a" => "us") == "Julius"`
Ultimo índice (de uma coleção)	`lastindex("Hello") == 5`
Numero de caracteres	`length("Hello") == 5`
Expressão regular (REGEX)	`pattern = r"l[aeiou]"`
Subexpressões	`str = "+1 234 567 890"` `pat = r"\+([0-9]) ([0-9]+)"` `m = match(pat, str)` `m.captures == ["1", "234"]`
Todas ocorrências	`[m.match for m = eachmatch(pat, str)]`
Todas ocorrências (como iterador)	`eachmatch(pat, str)`

Cuidado com codificações Unicode com varios bytes em UTF-8: 10 == lastindex("Ångström") != length("Ångström") == 8 Strings são imutáveis.

Números


Tipo inteiro	`IntN` e `UIntN`, com `N ∈ {8, 16, 32, 64, 128}`, `BigInt`
Tipos de ponto flutuante	`FloatN` com `N ∈ {16, 32, 64}` `BigFloat`
Valores mínimo e máximo por tipo	`typemin(Int8)` `typemax(Int64)`
Tipo complexo	`Complex{T}`
Unidade imaginária	`im`
Precisão da máquina	`eps() # o mesmo que eps(Float64)`
Arredondamento	`round() # ponto flutuante` `round(Int, x) # inteiro`
Conversão de tipo	`convert(TypeName, val) # tentativa/erro` `typename(val) # chama conversor`
Constantes Globais	`pi # 3.1415...` `π # 3.1415...` `im # real(im * im) == -1`
Outras constantes	`using Base.MathConstants`

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

Números Aleatórios

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


Definir semente	`seed!(seed)`
Números aleatórios	`rand() # uniforme [0,1)` `randn() # normal (-Inf, Inf)`
Aleatório de outras distribuições	`using Distributions` `minha_dist = Bernoulli(0.2) # Por exemplo` `rand(minha_dist)`
Subamostra aleatória de elementos de A com probabilidade p de inclusão	`randsubseq(A, p)`
Permutação aleatória de elementos de A	`shuffle(A)`

Arrays


Declaração	`arr = Float64[]`
Pre-alocação	`sizehint!(arr, 10^4)`
Acesso e atribuição	`arr = Any[1,2]` `arr[1] = "Some text"`
Comparação	`a = [1:10;]` `b = a # b points to a` `a[1] = -99` `a == b # true`
Copiar elementos (não endereços)	`b = copy(a)` `b = deepcopy(a)`
Selecionar a subarray de m para n	`arr[m:n]`
n-elemento array com 0.0s	`zeros(n)`
n-elemento array com 1.0s	`ones(n)`
n-elemento array com #undefs	`Vector{Type}(undef,n)`
n números igualmente espaçados do início ao fim	`range(start,stop=stop,length=n)`
Array com n elementos aleatórios Int8	`rand(Int8, n)`
Preencher array com val	`fill!(arr, val)`
Mostrar ultimo elemento	`pop!(arr)`
Mostrar primeiro elemento	`popfirst!(a)`
Enviar val como último elemento	`push!(arr, val)`
Enviar val como primeiro elemento	`pushfirst!(arr, val)`
Remover elemento em index idx	`deleteat!(arr, idx)`
Ordenar	`sort!(arr)`
Acrescentar a com b	`append!(a,b)`
Verificar se val é um elemento	`in(val, arr) or val in arr`
Produto Escalar	`dot(a, b) == sum(a .* b)`
Alterar dimensões (se possível)	`reshape(1:6, 3, 2)' == [1 2 3; 4 5 6]`
Para String (com delimitador del entre elementos)	`join(arr, del)`

Álgebra Linear

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


Matriz Identidade	`I # use somente a variável I. Será automaticamente ajustada conforme as dimensões requeridas.`
Definir Matriz	`M = [1 0; 0 1]`
Dimensão da Matriz	`size(M)`
Selecionar `i`-ésima linha	`M[i, :]`
Selecionar `i`-ésima coluna	`M[:, i]`
Concatenar horizontalmente	`M = [a b]` ou `M = hcat(a, b)`
Concatenar verticalmente	`M = [a ; b]` ou `M = vcat(a, b)`
Matriz Transposta	`transpose(M)`
Matriz Transposta Conjugada	`M'` ou `adjoint(M)`
Traço da Matriz	`tr(M)`
Determinante	`det(M)`
Posto da Matriz	`rank(M)`
Autovalores	`eigvals(M)`
Autovetores	`eigvecs(M)`
Matriz Inversa	`inv(M)`
Resolver `M*x == v`	`M\v` é melhor Numericamente mais estável e tipicamente mais rápido. que `inv(M)*v`
Pseudo-inversa de Moore-Penrose	`pinv(M)`

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.

Estruturas de decisão e repetição


Condicional	`if-elseif-else-end`
Ciclo `for` simples	`for i in 1:10` `println(i)` `end`
Ciclo `for` aninhado	`for i in 1:10, j = 1:5` `println(i*j)` `end`
Enumeração	`for (idx, val) in enumerate(arr)` `println("o $idx-ésimo elemento é $val")` `end`
Ciclo `while`	`while expressão_booleana` `# comandos` `end`
Sair do ciclo	`break`
Sair da iteração	`continue`

Funções

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

Funções com ! mudam pelo menos um argumento, tipicamente o primeiro: sort!(argumento).

Argumentos requiridos são separados por uma vírgula e usam a notação posicional

Argumentos opcionais precisam de um valor padrão na signatura, definido por =.

Argumentos de palavra-chave (keyword) usam a notação nomeada e são listados na signatura depois da vírgula:

function func(req1, req2; key1=dflt1, key2=dflt2)
    # faça algo!
end

A vírgula não é necessária na chamada de uma função que aceita argumentos de palavra-chave (keyword)

O comando return é opcional, mas fortemente recomendado.

Multiplas estruturas de dados podem ser retornadas como uma tupla em um único comando return.

Argumentos de linha de comando julia script.jl arg1 arg2... podem ser processados pela constante global ARGS:

for arg in ARGS
    println(arg)
end

Funções anônimas podem ser melhor utilizadas em coleções de funções ou list comprehensions: x -> x^2.

Funções podem aceitar uma quantidade variável de argumentos:

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

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

Funções podem ser aninhadas:

function funcaoexterna()
    # faça coisas externas
    function funcaointerna()
        # faça coisas internas
        # pode acessar funções externas anteriores a ela
    end
    # faça mais coisas externas
end

Funções podem ter tipos de retorno explícitos

# pegue qualquer subtipo de número e retorne ele como uma String
function stringifynumber(num::T)::String where T <: Number
    return "$num"
end

Funções podem ser vetorizadas usando a Sintaxe de Ponto (Dot Syntax)

# aqui nós transmitimos a subtração de cada valor
# usando o operador (.)
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 gera versões especializadas 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. em funções baseadas em tipos de dados. Quando uma função é executada com o mesmo argumento novamente, Julia pode procurar o código de máquina nativo e pular o processo de compilação.

Desde Julia 0.5 a existência de potenciais ambiguidades ainda é aceitável, mas executar um método ambíguo é um erro imediato

Transbordo de pilha (Stack overflow) é possível quando funções recursivas aninham a varios níveis de profundidade. Trampolining pode ser utilizado para a otimização chamadas recursivas, já que Julia não faz isso automaticamente ainda.

Alternativamente, você pode reescrever a recursão como uma iteração.

Dicionários


Dicionário	`d = Dict(key1 => val1, key2 => val2, ...)` `d = Dict(:key1 => val1, :key2 => val2, ...)`
Todas as chaves (iterador)	`keys(d)`
Todos os valores (iterador)	`values(d)`
Laços pelos pares de chave-valor	`for (k,v) in d` `println("chave: $k, valor: $v")` `end`
Verifica existência de chave `:k`	`haskey(d, :k)`
Copiar chaves (ou valores) para um vetor	`arr = collect(keys(d))` `arr = [k for (k,v) in d]`

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

Conjuntos


Declaração	`s = Set([1, 2, 3, "Algum texto"])`
União `s1 ∪ s2`	`union(s1, s2)`
Intersecção `s1 ∩ s2`	`intersect(s1, s2)`
Diferença `s1 \\ s2`	`setdiff(s1, s2)`
Diferença `s1 △ s2`	`symdiff(s1, s2)`
Subconjunto `s1 ⊆ s2`	`issubset(s1, s2)`

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

Funções de Coleção


Aplicar `f` para todos os elementos da coleção `coll`	`map(f, coll)` or `map(coll) do elem` `# faça algo com elem` `# must contain return` `end`
Filtrar `coll` por valores verdadeiros de `f`	`filter(f, coll)`
list comprehension	`arr = [f(elem) for elem in coll]`

Tipos

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.


Anotação de tipo	`var::NomeDoTipo`
Declaração de tipo	`struct Programador` `nome::String` `ano_de_nascimento::UInt16` `linguagem_favorita::AbstractString` `end`
Declaração de tipo mutável	substituir `struct` por `mutable struct`
Pseudônimo de tipo	`const Nerd = Programador`
Construtores de tipo	`methods(NomeDoTipo)`
Instanciação de tipo	`me = Programador("Ian", 1984, "Julia")` `me = Nerd("Ian", 1984, "Julia")`
Declaração de subtipo	`abstract type Programador` `nome::AbstractString` `ano_de_nascimento::UInt16` `linguagem_favorita::AbstractString` `end`
Tipo paramétrico	`struct Ponto{T <: Real}` `x::T` `y::T` `end` `p =Ponto{Float64}(1,2)`
Tipos `Union`	`Union{Int, String}`
Hierarquia de tipo transversal	`supertype(NomeDoTipo)` e `subtypes(NomeDoTipo)`
Supertipo padrão	`Any`
Todos os campos	`fieldnames(NomeDoTipo)`
Todos os tipos de campo	`NomeDoTipo.types`

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.

Faltando e Nada


Null do programador	`nothing`
Dados `missing`	`missing`
`Não é um Número` em float	`NaN`
Filtrar `missing`	`skipmissing([1, 2, missing]) == [1,2]`
Substituir `missing`	`collect((df[:col], 1))`
Checkar se variável tem valor de `missing`	`ismissing(x) not x == missing`

Excepções


Lançar AlgumaExcecao	`throw(AlgumaExcecao())`
Relançar exceção atual	`rethrow()`
Definir NovaExcecao	`struct NovaExcecao <: Exception` `v::String` `end` `Base.showerror(io::IO, e::NovaExcecao) = print(io, "Um problema com $(e.v)!")` `throw(NovaExcecao("x"))`
Lançar erro com mensagem	`error(mensagem)`
Tratamento	`try` `# faca algo potencialmente duvidoso` `catch ex` `if isa(ex, AlgumaExcecao)` `# tratar AlgumaExcecao` `elseif isa(ex, UmaOutraExcecao)` `# tratar UmaOutraExcecao` `else` `# tratar os restantes` `end` `finally` `# faça isso em qualquer caso` `end`

Módulos

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


Definição	`module NomeDoPacote` `# adicionar definições de módulo` `# usar export para tornar as definições acessíveis` `end`
Incluir `nome_do_arquivo.jl`	`include("nome_do_arquivo.jl")`
Carregar	`using NomeDoModulo # todos os nomes exportados` `using NomeDoModulo: x, y # apenas x, y` `using NomeDoModulo.x, NomeDoModulo.y: # apenas x, y` `import NomeDoModulo # apenas NomeDoModulo` `import NomeDoModulo: x, y # apenas x, y` `import NomeDoModulo.x, NomeDoModulo.y # apenas x, y`
Exportações	`# Obter uma lista de nomes exportados pelo Módulo` `names(NomeDoModulo)` `# incluir nomes não exportados, depreciados` `# e gerados pelo compilador` `names(NomeDoModulo, all::Bool)` `# também mostra nomes explicitamente importados de outros módulos` `names(NomeDoModulo, all::Bool, imported::Bool)`

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

Expressões

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

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


Definição	`macro nome_do_macro(expr)` `# comandos` `end`
Uso	`nome_do_macro(ex1, ex2, ...)` or `@nome_do_macro ex1, ex2, ...`
Macros Embutídas	`@test # igual (exato)` `@test_approx_eq # igual (a menos de erros numéricos)` `@test x ≈ y # isapprox(x, y)` `@assert # garante afirmação (teste unitário)` `@which # tipos usados` `@time # estatísticas de tempo e memória` `@elapsed # tempo decorrido` `@allocated # memória alocada` `@profile # perfil` `@spawn # executar em algum worker` `@spawnat #executar num worker específico` `@async # tarefa assíncrona` `@distributed # laço for paralelo` `@everywhere # disponibilizar aos workers`

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

Computação Paralela

Ferramentas de computação paralela estão disponíveis na biblioteca padrão Distributed


Iniciar RELP com N `workers`	`julia -p N`
Número de `workers` disponíveis	`nprocs()`
Adicionar N `workers`	`addprocs(N)`
Mostrar os IDs de todos os `workers`	`for pid in` workers`()` `println(pid)` `end`
Mostrar os IDs dos `workers` em execução	`myid()`
Remover `worker`	`rmprocs(pid)`
Executar f com argumentos args no PID	`r = remotecall(f, pid, args...)` `# or:` `r = @spawnat pid f(args)` `...` `fetch(r)`
Executar f com argumentos no PID (mais eficiente)	`remotecall_fetch(f, pid, args...)`
Executar f com argumentos args em qualquer `worker`	`r = @spawn f(args) ... fetch(r)`
Executar f com argumentos args em todos os `workers`	`r = [@spawnat w f(args) for w in` workers`()] ... fetch(r)`
Fazer expr disponível para todos os `workers`	`@everywhere expr`
Ciclo paralelo com a função red, que é uma reducerUma função reducer combina os resultados de diferentes (e independentes) workers.	`sum = @distributed (red) for i in 1:10^6` `# faça coisas paralelas` `end`
Aplicar f para todos os elementos da coleção coll	`pmap(f, coll)`

workers também são conhecidos como processos paralelos ou concorrentes.

Modulos com capacidades de computação paralela são melhor divididos em um arquivo de funções que contém todas as funções e variáveis necessárias para todos workers, e um arquivo principal que trata do processamento de dados. O arquivo principal obviamente precisa importar o arquivo de funções.

Um exemplo não trivial de uma função reducer é provido por Adam DeConinck.

I/O


Ler fluxo de dado	`stream = stdin` `for line in eachline(stream)` `# faça alguma coisa` `end`
Ler arquivo	`open(filename) do file` `for line in eachline(file)` `# faça alguma coisa` `end` `end`
Ler arquivo CSV	`using CSV` `CSV.read(filename)`
Salvar objeto do Julia	`using JLD` `save(filename, "object_key", object, ...)`
Carregar objeto do Julia	`using JLD` `d = load(filename) # Retorna um dicionario de objetos`
Salvar HDF5	`using HDF5` `h5write(filename, "key", object)`
Carregar HDF5	`using HDF5` `h5read(filename, "key")`

DataFrames

Para ferramentas parecidas com dplyr, veja DataFramesMeta.jl.


Ler CSV	`using CSV` `CSV.read(nomedoarquivo)`
Escrever CSV	`using CSV` `CSV.write(nomedoarquivo)`
Ler Stata, SPSS, etc.	Pacote `StatFiles`
DescreverSimilar a `summary(df)` em R. data frame	`describe(df)`
Faça vetor da coluna `col`	`v = df[:col]`
Ordenar da `col`	`sort!(df, [:col])`
CategoricalSimilar a `df$col = as.factor(df$col)` em R. `col`	`categorical!(df, [:col])`
Listar os níveis de `col`	`levels(df[:col])`
Todas observações onde `col==val`	`df[df[:col] .== val, :]`
Mudar o formato de wide para long	`stack(df, [1:n; ])` `stack(df, [:col1, :col2, ...])` `melt(df, [:col1, :col2])`
Mudar o formato de long para wide	`unstack(df, :id, :val)`
Faça `Nullable`	`allowmissing!(df)` or `allowmissing!(df, :col)`
Ciclar as Linhas	`for r in eachrow(df)` `# Faça algo.` `# r é o Struct com campos de col nomes
`<br>`end`
Ciclar as Colunas	`for c in eachcol(df)` `# Faça algo.` `# c é a tupla com nome, e então, vetor
`<br>`end`
Aplicar func para grupos	`by(df, :group_col, func)`
Query	`using Query` `query = @from r in df begin` `@where r.col1 > 40` `@select {new_name=r.col1, r.col2}` `@collect DataFrame #Padrão: iterador` `end`

Introspecção e Reflexão


Tipo de `nome`	`typeof(nome)`
Checkar tipo	`isa(nome, NomedoTipo)`
Subtipos de lista	`subtypes(nome)`
Supertipo de lista	`super(NomedoTipo)`
Métodos de função	`methods(func)`
bytecode JIT	`code_llvm(expr)`
código de Assembly	`code_native(expr)`

Pacotes e Projetos dignos de menção

Vários pacotes principais são gerenciados por comunidades com nome de forma: Julia[Tópico].


Estatísticas	JuliaStats
Diferenciação automática	JuliaDiff
Otimização numérica	JuliaOpt
Plotagem (criação de gráficos)	JuliaPlots
Análise de (gráficos de) rede	JuliaGraphs
Web	JuliaWeb
Geo-Espacial	JuliaGeo
Machine Learning	JuliaML

Machine Learning científica	SciML (formerly DifferentialEquations.jl)

Pacotes muito usados	`DataFrames # regressão logistica/linear` `Distributions # distribuições estatísticas` `Flux # Machine learning` `Gadfly # plotagem parecida com ggplot2` `Graphs # Análise de rede` `TextAnalysis # PNL`

Convenções de nomenclatura

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.

Dicas para desempenho

Escreva código de tipo estável
Além disso, utilize tipos imutáveis quando possível
Use sizehint para grande arrays.
Libere memória de grande arrays usando arr = nothing
Acesse arrays com base em suas colunas, pois arrays multi-dimensionais (Matrizes) são armazenadas em ordem de coluna
Pré-aloque estruturas de dados resultantes.
Desabilite o garbage collector em aplicações em tempo-real com: disable_gc().
Evite a utilização do operador (...) para argumentos de palavra-chave.
Use APIs mutantes (funções com ! para evitar a cópia de estruturas de dados)
Use operações de cada elemento de arrays em vez de list comprehensions
Evite try catches em loops (computacionalmente intensivos)
Evite Any em coleções
Evite tipos abstratros em coleções
Evite interpolação de strings em I/O.
Vetorização não melhora performance (diferente de R, MATLAB ou Python)
Evite eval em tempo de execução (tempo real)

IDEs, Editores e Plug-ins

Juno (editor)
Jupyter (online IJulia notebook)
Emacs Julia mode (editor)
Pluto.jl (online IJulia notebook)
vim Julia mode (editor)
VS Code extension (editor)

Recursos

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)

A via rápida para

Uma visão geral ágil e simples para

1.0

O que é…?

O Básico

Operadores

A shell, também conhecida como, o REPL

Bibliotecas Padrão

Gerenciamento de Pacotes

Usando `Pkg` em uma sessão Julia

No modo de Gerenciamento de Pacotes Interativo

Caracteres e Strings

Números

Números Aleatórios

Arrays

Álgebra Linear

Estruturas de decisão e repetição

Funções

Dicionários

Conjuntos

Funções de Coleção

Tipos

Faltando e Nada

Excepções

Módulos

Expressões

Macros

Computação Paralela

I/O

DataFrames

Introspecção e Reflexão

Pacotes e Projetos dignos de menção

Convenções de nomenclatura

Dicas para desempenho

IDEs, Editores e Plug-ins

Recursos

Videos

A via rápida para

Uma visão geral ágil e simples para

1.0

O que é…?

O Básico

Operadores

A shell, também conhecida como, o REPL

Bibliotecas Padrão

Gerenciamento de Pacotes

Usando Pkg em uma sessão Julia

No modo de Gerenciamento de Pacotes Interativo

Caracteres e Strings

Números

Números Aleatórios

Arrays

Álgebra Linear

Estruturas de decisão e repetição

Funções

Dicionários

Conjuntos

Funções de Coleção

Tipos

Faltando e Nada

Excepções

Módulos

Expressões

Macros

Computação Paralela

I/O

DataFrames

Introspecção e Reflexão

Pacotes e Projetos dignos de menção

Convenções de nomenclatura

Dicas para desempenho

IDEs, Editores e Plug-ins

Recursos

Videos

Usando `Pkg` em uma sessão Julia