Julia (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.
Saltar para a navegação Saltar para a pesquisa
Julia
Official Julia logo
Paradigma multiparadigma
Surgido em 2012
Última versão 1.5.1 (25 de agosto de 2020; há 2 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].

Julia é escrito em C, C++, e Scheme, usando a estrutura do compilador LLVM, enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia[3].

O desenvolvimento de Julia começou em 2009 e uma versão de código aberto foi divulgado em fevereiro de 2012. Alguns aspectos incomuns do projeto Julia incluem ter um sistema sofisticado, com tipos paramétricos dependentes de uma linguagem de programação totalmente dinâmico e adotando expedição múltipla como seu paradigma de programação do núcleo. Cada um desses recursos tem aparecido em dialetos Lisp, como Common Lisp e Dylan, mas a combinação dos dois em um único idioma é único (ver recursos de linguagem). O aspecto mais notável da implementação da Julia é o seu desempenho que se compara a de linguagens compiladas de alto desempenho.[4]

Julia se inspira significativamente em Matlab e vários dialetos de Lisp, incluindo Scheme e Common Lisp, e compartilha muitas características com Dylan - uma outra linguagem dinâmica múltipla orientada a expedição com a sintaxe - e Fortress, outra linguagem de programação numérica com expedição múltipla e um sofisticado sistema de tipo paramétrico. Enquanto CLOS acrescenta expedição múltipla para Common Lisp, a adição é opt-in: funções só definidos pelo usuário explicitamente declarados genérico pode ser estendida. Em Julia, Dylan e Fortress, por outro lado, essa extensibilidade é o padrão e funções internas do sistema são todos genéricos e extensíveis.[carece de fontes?]

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

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.[5] 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." [6] Jeff Bezanson disse que escolheu o nome por sugestão de um amigo. [7]

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

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

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

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.
  • Poderosa capacidade para o gerenciamento de outros processos.
  • 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.

Compilador JIT[editar | editar código-fonte]

O compilador just-in-time (JIT) baseado em LLVM, combinado com seu design, permite que a linguagem se equipare à performance da linguagem C em vários cenários. Para se ter uma ideia da performance relativa de Julia comparada a outras linguagens que podem ser utilizadas para computação numérica e científica, temos um conjunto de micro-benchmarks realizado nas seguintes linguagens de programação: C, Fortran, Julia, Python, Matlab/Octave, R, JavaScript, Java, Lua, Go, and Mathematica. Os resultados dos micro-benchmarks a seguir foram obtidos utilizando um único núcleo (execução serial) de um processador Intel(R) Core(TM) i7-3960X 3.30GHz CPU com memória RAM DDR3 64GB 1600MHz, rodando openSUSE LEAP 15.0 Linux:

benchmark julia
Benchmark: tempo relativo em relação ao tempo de C.

Interação[editar | editar código-fonte]

Julia inclui um shell com sessão interativa chamado REPL (read–eval–print loop). Além de permitir uma codificação rápida e fácil, o REPL possui um histórico pesquisável, preenchimento de guias, muitas combinações de teclas úteis e modos dedicados de ajuda e shell. Exemplos de códigos.

 1                _
 2    _       _ _(_)_     |  A fresh approach to technical computing
 3   (_)     | (_) (_)    |  Documentation: http://docs.julialang.org
 4    _ _   _| |_  __ _   |  Type "?help" for help.
 5   | | | | | | |/ _` |  |
 6   | | |_| | | | (_| |  |  Version 1.1.1 (2019-05-16)
 7  _/ |\__'_|_|_|\__'_|  |  
 8 |__/                   |  x86_64-linux-gnu
 9 
10 julia> for x in 1:3, y in 1:3
11            @show (sin(x)*y)
12        end
13 sin(x) * y = 0.8414709848078965                                                                                                                                                               
14 sin(x) * y = 1.682941969615793                                                                                                                                                                
15 sin(x) * y = 2.5244129544236893                                                                                                                                                               
16 sin(x) * y = 0.9092974268256817                                                                                                                                                               
17 sin(x) * y = 1.8185948536513634                                                                                                                                                               
18 sin(x) * y = 2.727892280477045                                                                                                                                                                
19 sin(x) * y = 0.1411200080598672                                                                                                                                                               
20 sin(x) * y = 0.2822400161197344                                                                                                                                                               
21 sin(x) * y = 0.4233600241796016    
22 
23 julia> [i^2 + j^2 for i = x, j = y]
24 9×9 Array{Float64,2}:
25   2.0   3.25   5.41   7.25  10.0  12.56  17.0   23.5625   27.01
26   5.0   6.25   8.41  10.25  13.0  15.56  20.0   26.5625   30.01
27  10.0  11.25  13.41  15.25  18.0  20.56  25.0   31.5625   35.01
28  17.0  18.25  20.41  22.25  25.0  27.56  32.0   38.5625   42.01
29  26.0  27.25  29.41  31.25  34.0  36.56  41.0   47.5625   51.01
30  37.0  38.25  40.41  42.25  45.0  47.56  52.0   58.5625   62.01
31  50.0  51.25  53.41  55.25  58.0  60.56  65.0   71.5625   75.01
32  65.0  66.25  68.41  70.25  73.0  75.56  80.0   86.5625   90.01
33  82.0  83.25  85.41  87.25  90.0  92.56  97.0  103.563   107.01
34 
35 julia>

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

$ julia script.jl

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

Tutoriais[editar | editar código-fonte]

Português:

Referências

  1. «Download Julia». Consultado em 30 de agosto de 2020 
  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. Paul Krill (18 de abril de 2012). «New Julia language seeks to be the C for scientists». InfoWorld. Consultado em 13 de fevereiro de 2014 
  4. Mark Gibbs, (9 de janeiro de 2013). «Pure and Julia are cool languages worth checking out». Network World. Consultado em 13 de fevereiro de 2014 
  5. Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman. «Why We Created Julia». JuliaLang.org. Consultado em 5 June 2017  Verifique data em: |acessodata= (ajuda)
  6. Karpinski, Stefan (18 April 2012). «New Julia language seeks to be the C for scientists». InfoWorld  Verifique data em: |data= (ajuda)
  7. Torre, Charles. «Stefan Karpinski and Jeff Bezanson on Julia». Channel 9. MSDN. Consultado em 4 December 2018  Verifique data em: |acessodata= (ajuda)
  8. «Newsletter August 2020». juliacomputing.com. 14 de agosto de 2020. Consultado em 7 de setembro de 2020 
  9. «Julia Computing». juliacomputing.com. Consultado em 12 de agosto de 2020 
  10. «Newsletter November 2019». juliacomputing.com. 7 de novembro de 2019. Consultado em 29 de novembro de 2019 
  11. «Julia Computing Newsletter, Growth Metrics». juliacomputing.com. Consultado em 11 de fevereiro de 2019 
  12. «Newsletter January 2019». juliacomputing.com. 4 January 2019. Consultado em 20 de agosto de 2019  Verifique data em: |data= (ajuda)
  13. «julia - Docker Hub» 
  14. «The Julia Blog» 
  15. «Julia 0.6 Release Announcement» 
  16. «What is Julia 0.7? How does it relate to 1.0?». JuliaLang (em inglês). Consultado em 17 de outubro de 2018 
  17. Davies, Eric. «Writing Iterators in Julia 0.7». julialang.org. Consultado em 5 de agosto de 2018 
  18. «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. 
  19. Bezanson, Jeff; Karpinski, Stefan; Shah, Viral; Edelman, Alan. «The Julia Language». julialang.org. Consultado em 13 de dezembro de 2019 
  20. «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 
  21. 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. 
  22. «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 
  23. Fischer, Keno (2 May 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.  Verifique data em: |data= (ajuda)
  24. 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. 
  25. «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 
  26. «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 
  27. «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 
  28. «Milestones - JuliaLang/julia». The Julia Language. Consultado em 13 de dezembro de 2019 
  29. Bezanson, Jeff; Stefan (23 de setembro de 2012). «Julia: A Fast Dynamic Language for Technical Computing». arXiv:1209.5145 [cs] 

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