Julia (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.
Julia
Official Julia logo
Paradigma multiparadigma
Surgido em 2012
Última versão 1.6.1 (23 de abril de 2021; há 7 meses[1])
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[2]. 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[3]. 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[4].

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[5].

História[editar | editar código-fonte]

Jeff Bezanson, um dos criadores do projeto Julia, apresentando na JuliaCon 2014.
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.[6] 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." [7] Jeff Bezanson disse que escolheu o nome por sugestão de um amigo. [8]

Desde o lançamento em 2012, a comunidade Julia cresceu e foi baixada por programadores em mais de 10.000 empresas, [9] 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. [10] [11] [12] As imagens oficiais de Julia Docker, no Docker Hub, tiveram mais de 4.000.000 de downloads em janeiro de 2019. [13] [14] 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,[15] e em Junho de 2017 a versão 0.6. [16] 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 [17] ). 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; [18] 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). [19] 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. [20]

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. [21] O modelo de memória também foi alterado. [22] Versão secundária 1.4.2 corrigida, por exemplo, um problema de Zlib, dobrando a velocidade de descompressão. [23]

Julia 1.5 adiciona suporte de depuração de gravação e reprodução, [24] 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", [25] 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). [26] 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. [27] Além disso, as versões JVM desde o Java 11 não apresentam esse problema. [28] Julia 1.6 tem vencimento 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. [29]

Características da Linguagem.[editar | editar código-fonte]

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[editar | editar código-fonte]

Julia inclui um shell com sessão interativa chamado REPL (read–eval–print loop). [30][31] 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[editar | editar código-fonte]

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[32]

Programa Olá Mundo[editar | editar código-fonte]

println("Olá, mundo!")

Algoritmo de Trabb Pardo-Knuth[editar | editar código-fonte]

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[editar | editar código-fonte]

String[editar | editar código-fonte]

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[editar | editar código-fonte]

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[editar | editar código-fonte]

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[editar | editar código-fonte]

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[editar | editar código-fonte]

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[editar | editar código-fonte]

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.[33] 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.[34]

Tutoriais[editar | editar código-fonte]

Português:

Referências

  1. «Download Julia». Consultado em 13 de junho de 2021 
  2. Avi Bryant (15 de outubro de 2012). «MATLAB, R, and Julia: Languages for data analysis». Oreilly. Consultado em 13 de fevereiro de 2014. Arquivado do original em 24 de maio de 2013 
  3. «The State of Developer Ecosystem in 2020 Infographic». JetBrains: Developer Tools for Professionals and Teams (em inglês). Consultado em 5 de março de 2021 
  4. «Newsletter January 2021 - Julia Computing». juliacomputing.com. Consultado em 13 de junho de 2021 
  5. al, Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman, et. «Julia Micro-Benchmarks». julialang.org (em inglês). Consultado em 13 de junho de 2021 
  6. Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman. «Why We Created Julia». JuliaLang.org. Consultado em 5 de junho de 2017 
  7. Karpinski, Stefan (18 de abril de 2012). «New Julia language seeks to be the C for scientists». InfoWorld 
  8. Torre, Charles. «Stefan Karpinski and Jeff Bezanson on Julia». Channel 9. MSDN. Consultado em 4 de dezembro de 2018 
  9. «Newsletter August 2020». juliacomputing.com. 14 de agosto de 2020. Consultado em 7 de setembro de 2020 
  10. «Julia Computing». juliacomputing.com. Consultado em 12 de agosto de 2020 
  11. «Newsletter November 2019». juliacomputing.com. 7 de novembro de 2019. Consultado em 29 de novembro de 2019 
  12. «Julia Computing Newsletter, Growth Metrics». juliacomputing.com. Consultado em 11 de fevereiro de 2019 
  13. «Newsletter January 2019». juliacomputing.com. 4 de janeiro de 2019. Consultado em 20 de agosto de 2019 
  14. «julia - Docker Hub» 
  15. «The Julia Blog» 
  16. «Julia 0.6 Release Announcement» 
  17. «What is Julia 0.7? How does it relate to 1.0?». JuliaLang (em inglês). Consultado em 17 de outubro de 2018 
  18. Davies, Eric. «Writing Iterators in Julia 0.7». julialang.org. Consultado em 5 de agosto de 2018 
  19. «Sys.isjsvm([os])». The Julia Language. 20 de agosto de 2019. Consultado em 20 de agosto de 2019. Predicate for testing if Julia is running in a JavaScript VM (JSVM), including e.g. a WebAssembly JavaScript embedding in a web browser. 
  20. Bezanson, Jeff; Karpinski, Stefan; Shah, Viral; Edelman, Alan. «The Julia Language». julialang.org. Consultado em 13 de dezembro de 2019 
  21. «support a[begin] for a[firstindex(a)] by stevengj · Pull Request #33946 · JuliaLang/julia». GitHub (em inglês). Consultado em 7 de abril de 2020 
  22. quinnj. «For structs with all isbits or isbitsunion fields, allow them to be stored inline in arrays · Pull Request #32448 · JuliaLang/julia». GitHub (em inglês). Consultado em 7 de abril de 2020. I still keep running into problems that this causes internally because it was a breaking change that changes assumptions made by some users and inference/codegen. 
  23. «Bump Zlib BB release to 'v1.2.11+10' which enables '-O3' optimisation by giordano · Pull Request #35979 · JuliaLang/julia». GitHub (em inglês). Consultado em 25 de maio de 2020 
  24. Fischer, Keno (2 de maio de 2020). «Coming in Julia 1.5: Time Traveling (Linux) Bug Reporting». julialang.org (em inglês). Consultado em 5 de maio de 2020. Overhead for recording of single threaded processes is generally below 2x, most often between 2% and 50% (lower for purely numerical calculations, higher for workloads that interact with the OS). Recording multiple threads or processes that share memory (as opposed to using kernel-based message passing) is harder. [..] As expected, the threads test is the worst offender with about 600% overhead. 
  25. Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman et al. «The Julia Language». julialang.org (em inglês). Consultado em 14 de agosto de 2020. There are some size-based limits to which structs can be stack allocated, but they are unlikely to be exceeded in practice. 
  26. «Fix for C stack checking issues on 1.1 by simonbyrne · Pull Request #293 · JuliaInterop/RCall.jl». GitHub (em inglês). Consultado em 10 de agosto de 2019 
  27. «JVM fails to load in 1.1 (JavaCall.jl) · Issue #31104 · JuliaLang/julia». GitHub (em inglês). Consultado em 18 de agosto de 2019. JeffBezanson modified the milestones: 1.3, 1.4 
  28. «StackOverflowError in 'JavaCall.init' for Julia 1.1.0 · Issue #96 · JuliaInterop/JavaCall.jl». GitHub (em inglês). Consultado em 21 de outubro de 2019 
  29. «Milestones - JuliaLang/julia». The Julia Language. Consultado em 13 de dezembro de 2019 
  30. «Introducing Julia/The REPL». en.wikibooks.org (em inglês). Consultado em 3 de março de 2021 
  31. Passey, D. J. (2 de agosto de 2020). «9 Cool Julia Tricks In 4 Minutes». Medium (em inglês). Consultado em 3 de março de 2021 
  32. «Julia Documentation · The Julia Language». docs.julialang.org. Consultado em 3 de março de 2021 
  33. Bezanson, Jeff; Stefan (23 de setembro de 2012). «Julia: A Fast Dynamic Language for Technical Computing». arXiv:1209.5145 [cs] 
  34. microsoft/AzureClusterlessHPC.jl, Microsoft, 12 de junho de 2021, consultado em 13 de junho de 2021 

Ligações externas[editar | editar código-fonte]