Loading AI tools
linguagem de programação Da Wikipédia, a enciclopédia livre
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 | |
|---|---|
 | |
| Paradigma | multiparadigma |
| Surgido em | 2012 |
| Última versão | 1.10.0 (25 de dezembro de 2023[1]) |
| Criado por | Jeff Bezanson, Stefan Karpinski, Viral B. Shah, Alan Edelman |
| Estilo de tipagem | Dinâmica |
| Influenciada por | |
| Licença | MIT |
| Extensão do arquivo | .jl |
| Página oficial | julialang |
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]
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 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.[29]
De acordo com o site oficial da linguagem Julia, as principais características da linguagem são:
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.
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
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]
println("Olá, mundo!")
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
Classe de Texto simples, pode ser definida com Aspas duplas ".
No REPL:
julia> string="foo"
"foo"
julia> string2="$(string)2"
"foo2"
| 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 |
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
| Tipo | Precisão | Número de bits |
|---|---|---|
Float16 |
meia | 16 |
Float32 |
única | 32 |
Float64 |
dupla | 64 |
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
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
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
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]
Português:
Predicate for testing if Julia is running in a JavaScript VM (JSVM), including e.g. a WebAssembly JavaScript embedding in a web browser.
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.
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.
There are some size-based limits to which structs can be stack allocated, but they are unlikely to be exceeded in practice.
JeffBezanson modified the milestones: 1.3, 1.4
Seamless Wikipedia browsing. On steroids.
Every time you click a link to Wikipedia, Wiktionary or Wikiquote in your browser's search results, it will show the modern Wikiwand interface.
Wikiwand extension is a five stars, simple, with minimum permission required to keep your browsing private, safe and transparent.
