Julia (linguagem de programação)

Julia
Paradigma	multiparadigma
Surgido em	2012
Última versão	1.10.0 (25 de dezembro de 2023)
Criado por	Jeff Bezanson, Stefan Karpinski, Viral B. Shah, Alan Edelman
Estilo de tipagem	Dinâmica
Influenciada por	C Dylan Lisp Lua MATLAB Perl Python R Ruby Scheme
Licença	MIT
Extensão do arquivo	.jl
Página oficial	julialang.org

Julia é uma linguagem de programação dinâmica de alto nível projetada para atender os requisitos da computação de alto desempenho numérico e científico, sendo também eficaz para a programação de propósito geral. Em 2020, um estudo com 20.000 pessoas feita pela empresa tchéca JetBrains apontou que apenas 1% dos entrevistados usava Julia em seu ecossistema. No entanto, o número de usuários tem crescido de forma expressiva, assim como pacotes desenvolvidos em Julia, de tal forma que, entre janeiro de 2020 e janeiro de 2021, a linguagem saiu da posição 47 para a posição 23 no ranking do Índice TIOBE.

Julia usa um compilador Just-in-time (JIT) chamado Just-Ahead-Of-Time (JAOT), que possibilita seu melhor desempenho em relação a outras linguagens de alto nível.

História

Jeff Bezanson, um dos criadores do projeto Julia, na JuliaCon 2014.

O projeto Julia iniciou em 2009, foi desenvolvida por Jeff Bezanson, Stefan Karpinski, Viral B. Shah e Alan Edelman, que se propuseram a criar uma linguagem livre de alto nível e rápida. Em 14 de Fevereiro de 2012, a equipe lançou um site e fizeram uma postagem explicando a missão do projeto. Em entrevista à InfoWorld, em abril de 2012, Karpinski explicou por que do nome "Julia": "Na verdade não há uma boa razão, parecia um nome bonito." Jeff Bezanson disse que escolheu o nome por sugestão de um amigo.

Desde o lançamento em 2012, a comunidade Julia cresceu e foi baixada por programadores em mais de 10.000 empresas, chegando a mais de 20.000.000 de downloads em Setembro de 2020, superando os 9 milhões do ano anterior. Julia está é utilizada em mais de 1.500 universidades. As imagens oficiais de Julia Docker, no Docker Hub, tiveram mais de 4.000.000 de downloads em janeiro de 2019. A conferência acadêmica, JuliaCon, para usuários e desenvolvedores é realizada anualmente desde 2014.

Em Agosto de 2014, foi lançada a versão 0.3, em Outubro de 2015 a versão 0.4, em Outubro de 2016 a versão 0.5, e em Junho de 2017 a versão 0.6. As versões do Julia 0.7 e 1.0 foram lançadas em Agosto de 2018 ( a versão 0.7 é útil para testar pacotes e para saber como atualizá-los para 1.0 ). Trabalhar no Julia 0.7 foi um "grande empreendimento" devido ao "otimizador inteiramente novo" e algumas mudanças que foram feitas na semântica, por exemplo, a interface de iteração foi simplificada; além disso, a sintaxe mudou um pouco (com a sintaxe agora estável, e o mesmo para 1.xe 0.7).

Em 7 de Agosto de 2018 foi feito o comunicado de lançamento para Julia 1.0 (Julia 1.0.0-rc1), e um dia depois a versão final. Agora, as versões 1.0.x são as versões mais antigas que ainda podem contar com suporte de longo prazo; por pelo menos um ano. Julia 1.1 foi lançada em janeiro de 2019 e disponibilizou o recurso de linguagem de "pilha de exceções". Atualizações com correções de bugs são frequentes, quase mensalmente, das versões 1.4.xe, 1.0.xe e 1.0.1 até 1.0.5 seguiram esse cronograma de correções. Julia 1.2 foi lançado em Agosto de 2019, e tem, por exemplo, algum suporte embutido para navegadores web (para testar deve ser rodando em JavaScript VM). Com o lançamento do Julia 1.5, em agosto de 2020, as versões 1.4.x, 1.3.x, 1.2.x e 1.1.x não são mais mantidas. Julia 1.3 adicionou pacotes para paralelismo multi-thread combinável e um sistema de artefatos binários.

Julia 1.4 permitiu uma melhor sintaxe para lidar com indexação de array, por exemplo, arrays com propriedades numéricas, como A[begin+1] para o segundo elemento do array A. O modelo de memória também foi alterado. Versão secundária 1.4.2 corrigida, por exemplo, um problema de Zlib, dobrando a velocidade de descompressão.

Julia 1.5 adiciona suporte de depuração de gravação e reprodução, para a ferramenta rr do Mozilla. É um grande lançamento, com comportamento alterado no REPL (escopo soft), o mesmo utilizado no Jupyter, e totalmente compatível para código não REPL. A maior parte da API de thread foi marcada como estável, e com esta versão "objetos imutáveis arbitrários - independentemente de terem campos que fazem referência a objetos mutáveis ou não - agora podem ser alocados na pilha", reduzindo as alocações de heap, por exemplo, as views não mais alocação.

Pacotes que funcionam em Julia 1.0.x devem funcionar nas versões 1.1.x ou mais recentes, habilitado pela garantia compatibilidade de sintaxe nas versões futuras. Uma exceção notável foram as bibliotecas de interface de linguagem como JavaCall.jl (para linguagens JVM com Java ou Scala ) e Rcall.jl ( linguagem R ) devido a algumas mudanças relacionadas ao threading (em um momento em que toda a funcionalidade de threading em Julia era experimentalmente marcado). O problema era especialmente complicado para a JVM do Java, pois havia algumas expectativas especiais sobre como o espaço de endereço da pilha era usado. Uma solução alternativa chamada JULIA_ALWAYS_COPY_STACKS foi disponibilizada para Julia 1.3.0, enquanto uma correção completa para Java está em desenvolvimento sem data prevista de lançamento. Além disso, as versões JVM desde o Java 11 não apresentam esse problema. Julia 1.6 foi lançado em 30 de setembro de 2020. Os marcos do Julia 2.0 (e posteriores, por exemplo, 3.0) atualmente não têm datas de lançamento definidas.

Características da Linguagem.

De acordo com o site oficial da linguagem Julia, as principais características da linguagem são:

• Despacho múltiplo (multiple dispatch): provê capacidade de definir o comportamento da função através de muitas combinações de tipos de argumento.
• Tipagem dinâmica: tipos de documentação, otimização e despacho.
• Boa performance, que se aproxima de linguagens com tipagem estática, exemplo a linguagem C.
• Possui um gerenciador de pacotes prático e simples de usar.
• Possui macros como Lisp e outros pacotes de meta programação.
• Fornece chamada para funções da linguagem Python: para isso utiliza-se o pacote PyCall
• Possui APIs especiais para chamada de funções em C diretamente.
• Projetado para paralelismo e computação distribuída.
• Detém uma geração eficiente de código, especializado para diferentes tipos de argumentos.
• Apresenta uma forma elegante e extensivo para tipos numéricos.
• Inclui suporte eficiente para Unicode, incluindo UTF-8
• Licença pela MIT, livre e open source.

O conceito de despacho múltiplo ou também conhecido como multi-métodos em Lisp é uma generalização do polimorfismo usado em linguagens orientadas a objetos que na qual utilizam herança. Em Julia todos os tipos são declarados como concreto que também são subtipos de tipos abstratos. Tipos concretos não pode ser subtipos, mas sua composição é usada sobre herança, que é usado por linguagens tradicionais orientadas a objetos.

REPL

Julia inclui um shell com sessão interativa chamado REPL (read–eval–print loop). Abaixo um exemplo de REPL na versão 1.5.3

   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.5.3 (2020-11-09)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> for x in 1:3, y in 1:3
           @show (sin(x)*y)
       end
sin(x) * y = 0.8414709848078965
sin(x) * y = 1.682941969615793
sin(x) * y = 2.5244129544236893
sin(x) * y = 0.9092974268256817
sin(x) * y = 1.8185948536513634
sin(x) * y = 2.727892280477045
sin(x) * y = 0.1411200080598672
sin(x) * y = 0.2822400161197344
sin(x) * y = 0.4233600241796016

Julia também funciona através de scripts com formato .jl na qual pode ser interpretado na seguinte forma:

$ julia script.jl

Sintaxe e Comandos

Além da Sintaxe, alguns comandos em Julia são iguais ou parecidos com os das linguagens Python e JavaScript, como os blocos if, else, function e for, os operadores ?, and e in, entre outros. Abaixo estão as respectivas versões do Programa Olá Mundo e do Algoritmo de Trabb Pardo-Knuth escritos com base na documentação oficial do Julia 1.5

Programa Olá Mundo

println("Olá, mundo!")

Algoritmo de Trabb Pardo-Knuth

f(x) = abs(x)^.5 + 5x^3
for i in map(x->parse(Int, x), reverse(split(readline())[1:11]))
    v = f(i)
    println("$i: ", v > 400 ? "TOO LARGE" : v)
end

Tipos importantes

String

Classe de Texto simples, pode ser definida com Aspas duplas ".

No REPL:

julia> string="foo"
"foo"

julia> string2="$(string)2"
"foo2"

Classes Inteiras

Tipe	Número de bits	Menor valor	Maior valor
Int8	8	-2^7	2^7 - 1
UInt8	8	0	2^8 - 1
Int16	16	-2^15	2^15 - 1
UInt16	16	0	2^16 - 1
Int32	32	-2^31	2^31 - 1
UInt32	32	0	2^32 - 1
Int64	64	-2^63	2^63 - 1
UInt64	64	0	2^64 - 1
Int128	128	-2^127	2^127 - 1
UInt128	128	0	2^128 - 1

Inteiros

Conjunto de classes Inteiras, tendo como tipo de menor abrangência UInt8/Int8 e de maior abrangência UInt128/Int128. Quando uma variável Inteira é definida, o padrão é ser classificada como Int64.

No REPL:

julia> int8=Int8(10)
10

julia> uint8=UInt8(10)
0x0a

julia> int16=Int16(10)
10

julia> uint16=UInt16(10)
0x000a

julia> int32=Int32(10)
10

julia> uint32=UInt32(10)
0x0000000a

julia> int64=10 # Ou Int64(10)
10

julia> uint64=UInt64(10)
0x000000000000000a

julia> int128=Int128(10)
10

julia> uint128=UInt128(10)
0x0000000000000000000000000000000a

Classes Flutuantes

Tipo	Precisão	Número de bits
Float16	meia	16
Float32	única	32
Float64	dupla	64

Números de ponto flutuante

Conjunto de classes Flutuantes, tendo como tipo de menor abrangência Float16 e de maior abrangência Float64, que também é o valor padrão. Em tabela:

No REPL:

julia> meia=Float16(9.5)
Float16(9.5)

julia> unica=Float32(9.5)
9.5f0

julia> dupla=9.5 # Ou Float64(9.5)
9.5

Boolean

Classe Binária, onde o valor falso é representado por Bool(0)/false e o verdadeiro por Bool(1)/true.

julia> verdadeiro=true
true

julia> falso=Bool(0)
false

Arranjos, Vetores e Matrizes

Em Julia existem Arranjos (Matrizes Multidimensionais), Vetores (Matrizes Unidimensionais) e Matrizes (Bidimensionais), sendo o primeiro o único que pode ser definido por um símbolo (Colchete).

No REPL:

julia> arranjo=[false, "1", 2] # Ou Array(false, "1", 2)
3-element Array{Any,1}:
 false
      "1"
     2

julia> vetor=Vector(arranjo)
3-element Array{Any,1}:
 false
      "1"
     2

julia> matriz=Matrix([1 2 3; 4 5 6])
2×3 Array{Int64,2}:
 1  2  3
 4  5  6

Paralelismo

A execução paralela presente em Julia é realizada através de um sistema de multiprocessamento baseado em mensagens, implementado através da biblioteca padrão da linguagem. O projeto da linguagem suporta a implementação de bibliotecas através de sub-rotinas simétricas, que também podem ser compreendidas como threads cooperativamente programadas. Este recurso permite uma comunicação assíncrona escondida em cada biblioteca, sem que seja necessário ao usuário configurar os callbacks manualmente. Julia não suporta atualmente threads nativas, o que é uma limitação, mas se encontra em vantagem ao evitar as complexidades do uso sincronizado de memória compartilhada. Um exemplo de uso de computação paralela em Julia é o pacote AzureClusterlessHPC.jl, desenvolvido e mantido pela Microsoft Research for Industries, para uso na nuvem Microsoft Azure.

Tutoriais

• ThinkJulia
• A Deep Introduction to Julia for Data Science and Scientific Computing, Chris Rackauckas
• The Julia Express (featuring Julia 1.0), Bogumił Kamiński
• Programming in Julia (Quantitative Economics) - Thomas J. Sargent and John Stachurski. Along with being a complete textbook with Julia code for macroeconomics, this also is a very good introduction to Julia.
• Introducing Julia wikibook
• A Comprehensive Tutorial to Learn Data Science with Julia from Scratch, Mohd Sanad Zaki Rizvi

Português:

• Nota de Aula, Abel Siqueira, UFPR
• Linguagem Julia, Alexandre Gomiero
• Pizza de dados
• Tutorial JulialangPT, João Marcello, IFC, Luzerna-SC

Ligações externas

• Sítio oficial