Julia (linguagem de programação) - Julia (programming language)

Julia
Julia Programming Language Logo.svg
Paradigma Multi-paradigma : envio múltiplo (paradigma primário), procedimental , funcional , meta , multiestágio
Projetado por Jeff Bezanson , Alan Edelman , Stefan Karpinski , Viral B. Shah
Desenvolvedor Jeff Bezanson , Stefan Karpinski , Viral B. Shah e outros colaboradores
Apareceu pela primeira vez 2012 ; 9 anos atrás ( 2012 )
Versão estável
1.6.3  Edite isso no Wikidata / 23 de setembro de 2021 ; 25 dias atrás ( 23 de setembro de 2021 )
Versão de visualização
1.7.0-rc1 / 12 de setembro de 2021 ; 36 dias atrás e 1.7-rc2 e 1.6.4 sendo trabalhados e 1.8.0-DEV com atualizações diárias ( 2021-09-12 )
Disciplina de digitação Dinâmico , forte , nominativo , paramétrico , opcional
Linguagem de implementação Julia, C , C ++ , Scheme , LLVM
Plataforma Camada 1: x86-64 , IA-32 , GPUs CUDA / Nvidia
Camada 2: ARM de 64 bits , Windows de 32 bits (64 bits é a camada 1)
Camada 3: ARM de 32 bits , PowerPC , GPUs AMD.
Também tem suporte para GPUs oneAPI / Intel e TPUs do Google , e tem suporte para navegador da web (para JavaScript e WebAssembly ) e pode funcionar no Android . Para obter mais detalhes, consulte "plataformas suportadas" .
SO Linux , macOS , Windows e FreeBSD
Licença MIT (núcleo), GPL v2 ; uma opção makefile omite bibliotecas GPL
Extensões de nome de arquivo .jl
Local na rede Internet JuliaLang.org
Influenciado por

Julia é uma linguagem de programação dinâmica de alto nível e alto desempenho . Embora seja uma linguagem de propósito geral e possa ser usada para escrever qualquer aplicativo, muitos de seus recursos são adequados para análise numérica e ciência computacional .

Aspectos distintos do design de Julia incluem um sistema de tipos com polimorfismo paramétrico em uma linguagem de programação dinâmica ; com envio múltiplo como seu paradigma de programação central . Julia suporta concorrente , (combináveis) paralelo e computação distribuído (com ou sem o uso de IPM ou o embutido correspondente a " OpenMP estilo de" threads), e de chamada directa de C e Fortran bibliotecas sem código de cola . Julia usa um compilador just-in-time (JIT) que é conhecido como "just -ahead-of-time " (JAOT) na comunidade Julia, já que Julia compila todo o código (por padrão) para o código de máquina antes de executá-lo.

Julia é coletada pelo lixo , usa avaliação rápida e inclui bibliotecas eficientes para cálculos de ponto flutuante, álgebra linear , geração de números aleatórios e correspondência de expressão regular . Muitas bibliotecas estão disponíveis, incluindo algumas (por exemplo, para transformações rápidas de Fourier ) que antes eram empacotadas com Julia e agora estão separadas.

Diversas ferramentas de desenvolvimento suportam codificação em Julia, como ambientes de desenvolvimento integrados (por exemplo, Visual Studio Code da Microsoft , com extensões disponíveis adicionando suporte a Julia para IDEs, por exemplo, fornecendo suporte para depuração e linting ); com ferramentas integradas, por exemplo, um profiler (e suporte gráfico em degradê disponível para o integrado), depurador e o pacote Rebugger.jl "suporta depuração de execução repetida " e muito mais.

História

O trabalho em Julia foi iniciado em 2009, por Jeff Bezanson, Stefan Karpinski , Viral B. Shah e Alan Edelman , que se propôs a criar uma linguagem livre de alto nível e rápida. Em 14 de fevereiro de 2012, a equipe lançou um site com uma postagem no blog explicando a missão da língua. Em uma entrevista para a InfoWorld em abril de 2012, Karpinski disse sobre o nome "Julia": "Não há uma boa razão, realmente. Parecia um nome bonito." Bezanson disse que escolheu o nome por recomendação de um amigo, e anos depois escreveu:

Talvez julia signifique “O ceceio incomum de Jeff é automatizado”?

Desde o lançamento de 2012, a comunidade Julia cresceu e, em 2020, "Julia foi baixada por usuários em mais de 10.000 empresas e é usada em mais de 1.500 universidades" com mais de 29 milhões de downloads em julho de 2021, um aumento de 87% em um ano, e o ecossistema de pacotes Julia tem mais de 11,8 milhões de linhas de código (incluindo documentos e testes). A conferência acadêmica JuliaCon para usuários e desenvolvedores Julia foi realizada anualmente desde 2014, com JuliaCon2020 dando as boas-vindas a mais de 28.900 espectadores únicos e, em seguida, JuliaCon2021 quebrando todos os recordes anteriores (com mais de 300 apresentações JuliaCon2021 disponíveis gratuitamente no YouTube, contra 162 no ano anterior) e 43.000 espectadores únicos durante a conferência.

A versão 0.3 foi lançada em agosto de 2014, a versão 0.6 em junho de 2017. Julia 0.7 e a versão 1.0 foram lançadas em 8 de agosto de 2018. Trabalhar no Julia 0.7 foi um "grande empreendimento" (por exemplo, por causa de um "otimizador totalmente novo"), e algumas mudanças foram feitas na semântica, por exemplo, a interface de iteração foi simplificada; e a sintaxe mudou um pouco (com a sintaxe agora estável, e a mesma para 1.xe 0.7).

O candidato a lançamento do Julia 1.0 (Julia 1.0.0-rc1) foi lançado em 7 de agosto de 2018 e a versão final um dia depois. Julia 1.0.x é a versão mais antiga ainda suportada, tendo suporte de longo prazo (LTS), caso contrário, apenas a versão mais recente, em cada momento, é suportada. O Julia 1.1 foi lançado em janeiro de 2019 com, por exemplo, um novo recurso de linguagem de "pilha de exceções". Lançamentos de correções de bugs eram esperados quase mensalmente, para 1.4.xe 1.0.xe Julia 1.0.1 até 1.0.5 seguiram esse cronograma. O Julia 1.2 foi lançado em agosto de 2019 e tem, por exemplo, algum suporte integrado para navegadores da web (para teste se estiver executando em JavaScript VM). Julia 1.3 adicionou, por exemplo, paralelismo multi-thread combinável e um sistema de artefatos binários para pacotes Julia.

Julia 1.4 permitiu uma melhor sintaxe para indexação de array para lidar, por exemplo , com arrays baseados em 0 , com A[begin+1]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.

O Julia 1.5 lançado em agosto de 2020 adicionou suporte para depuração de registro e reprodução para a ferramenta rr da Mozilla . É um grande lançamento, com comportamento alterado no REPL (escopo suave), o mesmo usado no Jupyter , mas 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 em pilha", reduzindo as alocações de heap, por exemplo, viewsnão estão mais alocando. Todas as versões trabalharam no desempenho, mas especialmente no Julia 1.5 direcionado ao desempenho do chamado "tempo para o primeiro enredo", em geral, a velocidade de compilação em si (em oposição ao desempenho do código gerado) e ferramentas adicionais para os desenvolvedores melhorarem o carregamento de pacotes. Julia 1.6 também melhora esse desempenho ainda mais.

Os pacotes que funcionam no Julia 1.0.x devem funcionar no 1.1.x ou mais recente, habilitado pela garantia de sintaxe compatível com versões futuras . Uma exceção notável foram as bibliotecas de interface de linguagem estrangeira como JavaCall.jl (para linguagens JVM como Java ou Scala ) e Rcall.jl ( linguagem R ) devido a algumas mudanças relacionadas ao encadeamento (em um momento em que toda a funcionalidade de encadeamento em Julia era marcado experimental). 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 é usado. Uma solução alternativa chamada JULIA_ALWAYS_COPY_STACKSfoi postada para Julia 1.3.0, enquanto uma correção completa para Java está pendente e não tem data de vencimento definida. Além disso, as versões da JVM desde o Java 11 não apresentam esse problema.

Julia 1.6 foi a maior versão desde 1.0, mais rápida em muitas frentes, por exemplo, introduziu pré-compilação paralela e carregamento mais rápido de pacotes, em alguns casos "aceleração de 50x nos tempos de carregamento para grandes árvores de artefatos binários", e é provável que se torne a próxima longa lançamento de suporte de termo (LTS) de Julia. O marco para 2.0 atualmente não tem data de vencimento definida.

Julia 1.6.3 foi lançada em 23 de setembro de 2021 (e 1.6 se tornará o próximo lançamento LTS), e Julia 1.7 e 1.8 são os próximos marcos, com 1.7 adiado para 1º de junho de 2021 (ou seja, desde então 1.7 está em congelamento de recursos ) e como da versão 1.7 O desenvolvimento de Julia está de volta aos lançamentos baseados no tempo .

Usos notáveis

Julia atraiu alguns usuários importantes, desde o gerente de investimentos BlackRock , que o usa para análises de séries temporais , até a seguradora britânica Aviva , que o usa para cálculos de risco . Em 2015, o Federal Reserve Bank de Nova York usou Julia para fazer modelos da economia dos Estados Unidos, observando que a linguagem tornava a estimativa do modelo "cerca de 10 vezes mais rápida" do que sua implementação anterior do MATLAB . Os cofundadores de Julia estabeleceram a Julia Computing em 2015 para fornecer suporte pago, treinamento e serviços de consultoria aos clientes, embora Julia continue livre para usar. Na conferência JuliaCon 2017, Jeffrey Regier, Keno Fischer e outros anunciaram que o projeto Celeste usado Julia para alcançar "o desempenho de pico de 1,54  petaFLOPS usando 1,3 milhões de threads" em 9300 Knights Landing (KNL) nós da Cori II (Cray XC40) supercomputador (então o 6º computador mais rápido do mundo). Julia, portanto, junta C, C ++ e Fortran como linguagens de alto nível nas quais os cálculos petaFLOPS foram alcançados.

Três dos co-criadores de Julia são os destinatários do Prêmio James H. Wilkinson de Software Numérico 2019 (concedido a cada quatro anos) "pela criação de Julia, um ambiente inovador para a criação de ferramentas de alto desempenho que permitem a análise e solução de problemas de ciência da computação. " Além disso, Alan Edelman, professor de matemática aplicada no MIT, foi selecionado para receber o Prêmio Sidney Fernbach da Sociedade de Computação IEEE 2019 "por grandes avanços em computação de alto desempenho, álgebra linear e ciência da computação e por contribuições à linguagem de programação Julia. "

Em 2019, Julia Computing anunciou "a disponibilidade da linguagem de programação Julia como um contêiner pré-empacotado no registro de contêiner NVIDIA GPU Cloud (NGC)" e uma postagem de blog no site da Nvidia afirma "Facilmente implantar Julia em x86 e Arm [.. ] Julia oferece um pacote para um ecossistema de HPC abrangente que cobre aprendizado de máquina, ciência de dados, vários domínios científicos e visualização. "

Além disso, "Julia foi selecionada pela Climate Modeling Alliance como a única linguagem de implementação para seu modelo climático global de próxima geração. Este projeto multimilionário tem como objetivo construir um modelo climático em escala terrestre que forneça uma visão sobre os efeitos e desafios das mudanças climáticas. "

Julia é usada pela NASA , por exemplo, para modelar a dinâmica de separação de espaçonaves (15.000 vezes mais rápido do que antes com Simulink / MATLAB) e pelo INPE brasileiro para planejamento de missões espaciais e simulação de satélite . Outro esforço é trabalhar em um projeto embarcado para controlar um satélite no espaço usando Julia para controle de atitude .

JuliaCon

Desde 2014, a Julia Community hospeda uma Julia Conference anual com foco em desenvolvedores e usuários. A primeira JuliaCon aconteceu em Chicago e deu início à realização anual da conferência. Desde 2014, a conferência ocorre em vários locais, incluindo o MIT e a Universidade de Maryland, em Baltimore. O público do evento cresceu de algumas dezenas de pessoas para mais de 28.900 participantes únicos durante a JuliaCon 2020, que aconteceu virtualmente. JuliaCon 2021 acontecerá virtualmente entre 28 e 30 de julho de 2021 com discursos de Jan Vitek, Xiaoye Sherry Li e Soumith Chintala.

Comunidade Julia

A comunidade Julia está presente em várias plataformas: Twitter, LinkedIn, Facebook, Slack, Zulip, Discord, Discourse, Stack Overflow, YouTube e muito mais. Desde maio de 2017, a Julia Language contratou um gerente de comunidade; primeiro Alex Arsland que serviu até o final de 2019 e atualmente Logan Kilpatrick.

Patrocinadores

A linguagem Julia se tornou um projeto patrocinado pela NumFOCUS Fiscal em 2014, em um esforço para garantir a sustentabilidade do projeto a longo prazo. O Dr. Jeremy Kepner, do Laboratório MIT Lincoln, foi o patrocinador fundador do projeto Julia em seus primeiros dias. Além disso, os fundos da Fundação Gordon e Betty Moore , Fundação Alfred P. Sloan , Intel e agências como NSF , DARPA , NIH , NASA e FAA foram essenciais para o desenvolvimento de Julia. A Mozilla , criadora do navegador Firefox, com suas bolsas de pesquisa para o H1 2019, patrocinou "um membro da equipe oficial de Julia" para o projeto "Trazendo Julia para o navegador", ou seja, para o Firefox e outros navegadores da web. A linguagem Julia também é apoiada por doadores individuais no GitHub.

Julia Computing Company

Julia Computing, Inc. foi fundada em 2015 por Viral B. Shah, Deepak Vinchhi, Alan Edelman, Jeff Bezanson, Stefan Karpinski e Keno Fischer .

Em junho de 2017, Julia Computing arrecadou US $ 4,6  milhões em financiamento inicial do General Catalyst and Founder Collective , no mesmo mês foi "concedido US $ 910.000 pela Alfred P. Sloan Foundation para apoiar o desenvolvimento de Julia de código aberto, incluindo US $ 160.000 para promover a diversidade no Julia comunidade ", e em dezembro de 2019 a empresa obteve US $ 1,1  milhão de financiamento do governo dos EUA para" desenvolver uma ferramenta de aprendizado de máquina de componente neural para reduzir o consumo total de energia de sistemas de aquecimento, ventilação e ar condicionado (HVAC) em edifícios ". Em julho de 2021, a Julia Computing anunciou que arrecadou US $ 24 milhões da Série A liderada por Dorilton Ventures, que também é dona da equipe de Fórmula 1 Williams Racing , em parceria com a Julia Computing. O Diretor Comercial de Williams disse: "Investir em empresas que criam a melhor tecnologia em nuvem da classe é um foco estratégico para a plataforma versátil de Dorilton e Julia, com recursos revolucionários em simulação e modelagem, é extremamente relevante para nosso negócio. Estamos ansiosos para incorporar Julia A informática no esporte mais tecnologicamente avançado do mundo ".

Características da linguagem

Julia é uma linguagem de programação de propósito geral , embora também tenha sido originalmente projetada para computação numérica / técnica. Também é útil para programação de sistemas de baixo nível , como uma linguagem de especificação , e para programação da Web tanto no lado do servidor quanto do cliente.

Segundo o site oficial, as principais características do idioma são:

  • Envio múltiplo : fornecendo capacidade de definir o comportamento da função em muitas combinações de tipos de argumento
  • Sistema de tipo dinâmico : tipos para documentação, otimização e despacho
  • Desempenho que se aproxima de linguagens estaticamente tipadas como C
  • Um gerenciador de pacotes embutido
  • Macros semelhantes a Lisp e outros recursos de metaprogramação
  • Chame funções C diretamente: sem wrappers ou APIs especiais
  • Capacidade de fazer interface com outras linguagens, por exemplo, Python com PyCall, R com RCall e Java / Scala com JavaCall
  • Habilidades poderosas do tipo shell para gerenciar outros processos
  • Projetado para computação paralela e distribuída
  • Corrotinas : rosqueamento verde leve
  • Os tipos definidos pelo usuário são tão rápidos e compactos quanto integrados
  • Geração automática de código eficiente e especializado para diferentes tipos de argumento
  • Conversões e promoções elegantes e extensíveis para tipos numéricos e outros
  • Suporte eficiente para Unicode , incluindo, mas não se limitando a UTF-8

O envio múltiplo (também denominado multimétodos em Lisp) é uma generalização do envio único  - o mecanismo polimórfico usado em linguagens de programação orientada a objetos comuns (OOP) - que usa herança . Em Julia, todos os tipos concretos são subtipos de tipos abstratos, direta ou indiretamente subtipos do Anytipo, que é o topo da hierarquia de tipos. Os tipos concretos não podem ser subtipados da mesma forma que em outras linguagens; composição é usada em vez disso (consulte também herança vs subtipagem ).

Por padrão, o tempo de execução Julia deve ser pré-instalado enquanto o código-fonte fornecido pelo usuário é executado. Como alternativa, um executável autônomo que não precisa do código-fonte Julia pode ser criado com PackageCompiler.jl .

As macros sintáticas de Julia (usadas para metaprogramação ), como as macros Lisp, são mais poderosas do que as macros de substituição de texto usadas no pré - processador de algumas outras linguagens como C, porque funcionam no nível de árvores de sintaxe abstrata (ASTs). O macro sistema de Julia é higiênico , mas também suporta captura deliberada quando desejado (como para macros anafóricas ) usando a escconstrução.

Julia tira uma inspiração significativa de vários dialetos do Lisp, incluindo Scheme e Common Lisp , e compartilha muitos recursos com Dylan , também uma linguagem dinâmica orientada para múltiplos despachos (que apresenta uma sintaxe infixa de forma livre semelhante ao ALGOL em vez de um Lisp- como sintaxe de prefixo, enquanto em Julia "tudo" é uma expressão ), e com Fortress , outra linguagem de programação numérica (que apresenta despacho múltiplo e um sistema de tipo paramétrico sofisticado). Enquanto o Common Lisp Object System (CLOS) adiciona despacho múltiplo ao Common Lisp, nem todas as funções são funções genéricas.

Em Julia, Dylan e Fortress, extensibilidade é o padrão e as funções integradas do sistema são todas genéricas e extensíveis. Em Dylan, o despacho múltiplo é tão fundamental quanto em Julia: todas as funções definidas pelo usuário e até mesmo operações internas básicas como +são genéricas. O sistema de tipos de Dylan, no entanto, não suporta totalmente os tipos paramétricos, que são mais típicos da linhagem de linguagens ML . Por padrão, o CLOS não permite o despacho nos tipos paramétricos do Common Lisp; essa semântica de despacho estendida só pode ser adicionada como uma extensão por meio do protocolo CLOS Metaobject . Por design convergente, o Fortress também apresenta despacho múltiplo em tipos paramétricos; ao contrário de Julia, no entanto, o Fortress é tipado estaticamente em vez de dinamicamente, com fases de compilação e execução separadas. Os recursos de linguagem estão resumidos na tabela a seguir:

Língua Sistema de tipo Funções genéricas Tipos paramétricos
Julia Dinâmico Predefinição sim
Lisp Comum Dinâmico Opt-in Sim (mas sem envio)
Dylan Dinâmico Predefinição Parcial (sem envio)
Fortaleza Estático Predefinição sim

Um exemplo da extensibilidade de Julia, o pacote Unitful.jl adiciona suporte para unidades de medida ao idioma.

Interação

A distribuição oficial do Julia inclui um loop interativo de leitura e avaliação de linha de comando (REPL), com um histórico pesquisável, preenchimento de tabulação e ajuda dedicada e modos de shell , que podem ser usados ​​para experimentar e testar código rapidamente. O fragmento a seguir representa um exemplo de sessão de amostra em que as strings são concatenadas automaticamente por println:

julia> p(x) = 2x^2 + 1; f(x, y) = 1 + 2p(x)y
julia> println("Hello world!", " I'm on cloud ", f(0, 4), " as Julia supports recognizable syntax!")
Hello world! I'm on cloud 9 as Julia supports recognizable syntax!

O REPL dá ao usuário acesso ao shell do sistema e ao modo de ajuda, pressionando ;ou ?após o prompt (antes de cada comando), respectivamente. Também mantém o histórico de comandos, inclusive entre sessões. Código que pode ser testado na seção interativa de Julia ou salvo em um arquivo com uma .jlextensão e executado a partir da linha de comando digitando:

 $ julia <filename>

Julia é suportada por Jupyter , um ambiente de "cadernos" interativos online, e Pluto.jl , um " caderno reativo " (onde cadernos são salvos como arquivos Julia puros), um possível substituto para o primeiro tipo.

Use com outros idiomas

Na prática, Julia é interoperável com muitos idiomas (por exemplo, a maioria dos 10-20 idiomas mais populares). A ccallpalavra-chave de Julia é usada para chamar funções de biblioteca compartilhada C-exportada ou Fortran individualmente e pacotes para permitir a chamada de outras linguagens, por exemplo, Python, R, MATLAB, Java ou Scala. E pacotes para outros idiomas, por exemplo, Python (ou R ou Ruby), ou seja pyjulia, para chamar a Julia.

Julia tem suporte para o Unicode 13.0 mais recente, com UTF-8 usado para strings (por padrão) e para o código-fonte Julia (permitindo apenas UTF-8 legal na versão mais recente), o que significa também permitindo como uma opção símbolos matemáticos comuns para muitos operadores , como ∈ para o inoperador.

Julia possui pacotes que suportam linguagens de marcação como HTML (e também para HTTP ), XML , JSON e BSON , e para bancos de dados e uso da web em geral.

Sistema de embalagem

Julia possui um gerenciador de pacotes embutido e inclui um sistema de registro padrão. Os pacotes são geralmente distribuídos como código-fonte hospedado no GitHub , embora alternativas também possam ser usadas. Os pacotes também podem ser instalados como binários, usando artefatos. O gerenciador de pacotes de Julia é usado para consultar e compilar pacotes, bem como gerenciar ambientes. Há suporte para registros de pacotes federados, permitindo que registros diferentes do oficial sejam adicionados localmente.

Implementação

O núcleo de Julia é implementado em Julia e C , junto com C ++ para a dependência LLVM . A análise e redução de código são implementadas no FemtoLisp, um dialeto do Scheme . O projeto de infraestrutura do compilador LLVM é usado como back end para geração de código de máquina otimizado de 64 ou 32 bits, dependendo da plataforma em que Julia é executada. Com algumas exceções (por exemplo, PCRE ), a biblioteca padrão é implementada em Julia. O aspecto mais notável da implementação de Julia é sua velocidade, que geralmente está dentro de um fator de dois em relação ao código C totalmente otimizado (e, portanto, frequentemente uma ordem de magnitude mais rápida do que Python ou R ). O desenvolvimento do Julia começou em 2009 e uma versão de código aberto foi publicada em fevereiro de 2012.

Plataformas atuais e futuras

Embora Julia tenha suporte para macOS de nível 1 , ou seja, para Macs baseados em Intel, os novos Macs baseados em Apple M1 têm apenas suporte experimental, com suporte completo trabalhado, ainda não uma plataforma de nível 1 compatível (nem o Windows em ARM ). No entanto, afirma-se que Julia funciona "ok" em Macs M1 (com desempenho reduzido) através do uso (automático) do Rosetta 2 (que precisa emular Julia). O trabalho no suporte nativo de velocidade total M1 (ou seja, sem emulação) está quase todo concluído, e muitos programas podem funcionar se tal compilação de Julia for usada, uma vez que todos os testes de Julia, exceto um, passam (exceto para "Muitos arquivos abertos").

Como Julia usa JIT, Julia gera código de máquina nativo diretamente, antes de uma função ser executada pela primeira vez (ou seja, uma abordagem diferente da compilação para bytecode , que você distribui por padrão, para ser executado em uma máquina virtual (VM), como com, por exemplo, Java / JVM ; em seguida, traduzido do bytecode durante a execução, como feito por Dalvik em versões mais antigas do Android).

Julia tem quatro níveis de suporte. Todos os processadores IA-32 que implementam completamente a sub-arquitetura i686 são suportados e 64-bit x86-64 (também conhecido como amd64 ), ou seja, todos com menos de uma década são suportados. ARMv8 ( AArch64 ) processadores são suportados na segunda camada, e ARMv7 e ARMv6 (AArch32) são suportadas com algumas restrições (inferior camadas) para Julia 1.0.xe também tinha executáveis oficiais para versões posteriores, enquanto que o apoio ARM de 32 bits mais tarde foi rebaixado para a camada 3 (no entanto, binários não oficiais estão disponíveis para Julia 1.5.1). CUDA (ou seja, GPUs Nvidia; implementação de PTX ) tem suporte de nível 1, com a ajuda de um pacote externo. Existem também pacotes que suportam outros aceleradores, como TPUs do Google e algumas GPUs Intel (integradas), por meio de oneAPI.jl , e as GPUs da AMD têm suporte, por exemplo, OpenCL ; e suporte experimental para a pilha AMD ROCm . A página de downloads de Julia fornece executáveis (e código-fonte) para todas as plataformas oficialmente suportadas.

Em algumas plataformas, Julia pode precisar ser compilada a partir do código-fonte (por exemplo, o Raspberry Pi original ), com opções de compilação específicas, o que foi feito e binários pré-compilados não oficiais (e instruções de compilação) estão disponíveis. Julia foi construída em várias plataformas ARM. PowerPC (64 bits) tem suporte de nível 3, o que significa que "pode ​​ou não construir". Julia agora tem suporte no Raspbian enquanto o suporte é melhor para Pis mais novos, por exemplo, aqueles com ARMv7 ou mais recente; o apoio a Julia é promovido pela Raspberry Pi Foundation .

Também há suporte para navegadores da web / JavaScript por meio de JSExpr.jl; e a linguagem alternativa dos navegadores da web, WebAssembly , tem suporte mínimo para vários projetos Julia externos futuros. Julia pode compilar para ARM; portanto, em teoria, os aplicativos Android podem ser feitos com o NDK , mas por enquanto Julia foi feita para rodar no Android apenas indiretamente, ou seja , com um chroot do Ubuntu no Android.

Veja também

Notas

Referências

Leitura adicional

links externos