Julia (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Julia
Official Julia logo
Paradigma multiparadigma
Surgido em 2012
Última versão 0.5.0[1] / 0.4.7[2]
Versão em teste 0.6.0
Criado por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, Alan Edelman
Estilo de tipagem: Dinâmica
Influenciada por MATLAB, Scheme, Common Lisp, Lisp, C, Python, Perl, Ruby
Licença: MIT
Página oficial http://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[3] . Uma referência de conteúdo é o tutorial disponibilizado pela comunidade JuliaLang do Brasil e Portugal [4]

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

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 muitas vezes é o dobro do código C , totalmente otimizado, colocando-o no reino de linguagens compiladas de alto desempenho.[6]

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 (linguagem de programação), 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.[7]

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:

  • Multi-métodos: 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 estatica, exemplo a linguagem C.
  • Possui embutido um gerenciador de pacotes.
  • Possui macros com 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ído.
  • 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.

Julia também se inspira significativamente em vários dialetos de Lisp, incluindo Scheme e Common Lisp. Utilizou também conceitos da linguagem Fortress, sendo uma linguagem acadêmica, numérica e com despacho múltiplo.

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

O compilador just-in-time (JIT) baseado em LLVM de Julia, 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, escrevemos um pequeno conjunto de micro-benchmarks em uma variedade de linguagens: 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® Xeon® CPU E7-8850 2.00GHz com 1TB de memória RAM DDR3 de 1067MHz, rodando Linux:

Benckmark julia.png

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

Julia inclui um shell com sessão interativa que pode ser usado para experimentar o código rapidamente. Funciona em sistemas operacionais Linux, Windows e Mac. Abaixo apresenta uma pequena sessão como exemplo de uma soma simples.

 1                _
 2    _       _ _(_)_     |  A fresh approach to technical computing
 3   (_)     | (_) (_)    |  Documentation: http://docs.julialang.org
 4    _ _   _| |_  __ _   |  Type "?help" for help.
 5   | | | | | | |/ _` |  |
 6   | | |_| | | | (_| |  |  Version 0.5.0 (2016-09-19 18:14 UTC)
 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> x = [1,2,3,4,5,6,7,8,9]; y = [1.0, 1.5, 2.1, 2.5, 3.0, 3.4, 4.0, 4.75, 5.1];
24 julia> coef = linreg(x,y) # coeficientes ajuste linear
25 (0.4680555555555559,0.5141666666666667)
26 
27 julia> [i^2 + j^2 for i = x, j = y]
28 9×9 Array{Float64,2}:
29   2.0   3.25   5.41   7.25  10.0  12.56  17.0   23.5625   27.01
30   5.0   6.25   8.41  10.25  13.0  15.56  20.0   26.5625   30.01
31  10.0  11.25  13.41  15.25  18.0  20.56  25.0   31.5625   35.01
32  17.0  18.25  20.41  22.25  25.0  27.56  32.0   38.5625   42.01
33  26.0  27.25  29.41  31.25  34.0  36.56  41.0   47.5625   51.01
34  37.0  38.25  40.41  42.25  45.0  47.56  52.0   58.5625   62.01
35  50.0  51.25  53.41  55.25  58.0  60.56  65.0   71.5625   75.01
36  65.0  66.25  68.41  70.25  73.0  75.56  80.0   86.5625   90.01
37  82.0  83.25  85.41  87.25  90.0  92.56  97.0  103.563   107.01
38 
39 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.[8]

Tutorial em Língua Portuguesa[editar | editar código-fonte]

A linguagem Julia é ainda muito jovem e não há ainda livros em PT-BR. Uma referência de conteúdo é o tutorial disponibilizado pela comunidade JuliaLang do Brasil e Portugal [4]

Referências

  1. http://julialang.org/downloads/
  2. http://julialang.org/downloads/oldreleases.html
  3. Avi Bryant (15 de outubro de 2012). «MATLAB, R, and Julia: Languages for data analysis». Oreilly. Consultado em 13 de fevereiro de 2014 
  4. a b «JuliaLang do Brasil e Portugal». GitHub. Consultado em 14 de novembro de 2016 
  5. 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 
  6. 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 
  7. «Traduzido de Julia (programming language)». en-Wikipedia. Versão 29 de janeiro de 2014. Consultado em 13 de fevereiro de 2014  Verifique data em: |data= (ajuda)
  8. Bezanson, Jeff; Stefan (23 de setembro de 2012). «Julia: A Fast Dynamic Language for Technical Computing». arXiv:1209.5145 [cs]