Revision 6889723 of "Julia (programming language)" on simplewiki

{{simplifying}}
{{qd|a3|editor=Zaxxon0|date=09:53, 5 April 2020 (UTC)}}
{{wait}}
{{Use dmy dates|date=October 2015}}
{{Infobox programming language
| name = Julia
| logo = Julia Programming Language Logo.svg
| logo caption = 
| screenshot = <!-- filename is enough -->
| screenshot caption = 
| paradigm = [[multi-paradigm programming language|Multi-paradigm]]: [[multiple dispatch]] (core), [[procedural programming|procedural]], [[functional programming|functional]], [[metaprogramming|meta]], [[multistaged programming|multistaged]]<ref>{{cite web |url=https://medium.com/@acidflask/smoothing-data-with-julia-s-generated-functions-c80e240e05f3#.615wk3dle |title=Smoothing data with Julia's @generated functions |quote=Julia's generated functions are closely related to the multistaged programming (MSP) paradigm popularized by Taha and Sheard, which generalizes the compile time/run time stages of program execution by allowing for multiple stages of delayed code execution. |date=5 November 2015 |accessdate=9 December 2015}}</ref>
| released = {{Start date and age|2012}}<ref name="announcement">{{cite web
  | title        = Why We Created Julia
  | date         = February 2012
  | website      = Julia website
  | url          = https://julialang.org/blog/2012/02/why-we-created-julia
  | accessdate   = 7 February 2013
  }}</ref>
| designer = Jeff Bezanson, [[Alan Edelman]], [[Stefan Karpinski]], [[Viral B. Shah]]
| developer = Jeff Bezanson, [[Stefan Karpinski]], [[Viral B. Shah]], and other contributors<ref name="license">{{cite web
  | url = https://github.com/JuliaLang/julia/blob/master/LICENSE.md
  | title = LICENSE.md
  | publisher = [[GitHub]]
  }}</ref><ref>{{cite web
  | url = https://github.com/JuliaLang/julia/graphs/contributors
  | title = Contributors to JuliaLang/julia
  | publisher = [[GitHub]]
  }}</ref>
| latest release version = 1.4.0<ref>{{cite web|author= |url=https://github.com/JuliaLang/julia/releases/tag/v1.4.0 |title=v1.4.0 |website=Github.com |date=2020-03-21 |accessdate=2020-03-21}}</ref>
| latest release date = {{Start date and age|2020|03|21|df=yes}}
| latest preview version = <!--1.4.0-rc2<ref>{{cite web|author= |url=https://github.com/JuliaLang/julia/releases/tag/v1.4.0-rc2 |title=v1.4.0-rc2 |website=Github.com |date=2020-02-24 |accessdate=2020-02-24}}</ref>
| latest preview date = {{Start date and age|2020|02|24|df=yes}} / --> 1.5.0-DEV with daily updates (and 1.4.1 worked on<ref>https://github.com/JuliaLang/julia/pull/35229</ref>)
| typing = [[dynamic programming language|Dynamic]], [[nominal type system|nominative]], [[parametric polymorphism|parametric]], [[optional typing|optional]]
| implementations = 
| dialects = 
| influenced by = {{startflatlist}}
* [[C (programming language)|C]]<ref name="announcement"/>
* [[Lisp (programming language)|Lisp]]<ref name="announcement"/><!--only the parser implemented by femtolisp, a [[Scheme (programming language)|Scheme]]-like implementation (see: "unsupported" "julia --lisp" that invokes it, but its only influence on the language/syntax – Lisp-like macros? Maybe not even Lisp's CLOS "multimethods"? as Dylan with "multiple dispatch" was cut from the list-->
* [[Lua (programming language)|Lua]]<ref name="Introduction">{{Cite web|url=https://docs.julialang.org/en/v1/|title=<!--Chapter: Introduction under --> Home · The Julia Language|website=docs.julialang.org|language=en|access-date=2018-08-15}}</ref>
* [[Mathematica]]<ref name="announcement"/> (strictly its [[Wolfram Language]]<ref name="announcement"/><ref>{{cite web |url=https://fatiherikli.github.io/programming-language-network/ |title=Programming Language Network |publisher=GitHub |accessdate=6 December 2016}}</ref>)
* [[MATLAB]]<ref name="announcement"/>
* [[Perl]]<ref name="Introduction"/>
* [[Python (programming language)|Python]]<ref name="Introduction"/>
* [[R (programming language)|R]]<ref name="announcement"/>
* [[Ruby (programming language)|Ruby]]<ref name="Introduction"/>
* [[Scheme (programming language)|Scheme]]<ref name="JuliaCon2016">{{cite web |url=http://www.juliacon.org |title=JuliaCon 2016 |publisher=JuliaCon |quote="He has co-designed the programming language Scheme, which has greatly influenced the design of Julia"|accessdate=6 December 2016}}</ref>
{{endflatlist}}
| influenced = 
| programming language = Julia, [[C (programming language)|C]],<!--"Remove when C11 is required for C code" https://github.com/JuliaLang/julia/search?utf8=%E2%9C%93&q=C11&type=

"These roughly follows the c11/c++11 memory model [..] The only exception is the GC safepoint and GC state transitions [..] We use the compiler intrinsics to implement a similar API to the c11/c++11" https://github.com/JuliaLang/julia/blob/44f3d7c921cbe50105a54258db2febb65a4b9d44/src/julia_threads.h
--> [[C++]], [[Scheme (programming language)|Scheme]], [[LLVM]]<ref name="JuliaHome">{{cite web |url=https://julialang.org/ |title=Julia |author=<!--Staff writer(s); no by-line.--> |date=<!--None listed.--> |website=Julia |publisher=[[NumFocus]] project |access-date=9 December 2016 |quote=Julia's Base library, largely written in Julia itself, also integrates mature, best-of-breed open source C and Fortran libraries for ...}}</ref>
| platform = Tier&nbsp;1: [[x86-64]], [[IA-32]], [[CUDA]]<br> Tier&nbsp;2: [[ARM architecture|ARM]] (both 32- and 64-bit)<br> Tier&nbsp;3: [[PowerPC]]<br> Also has web browser support (for [[JavaScript]] and [[WebAssembly]]) and works in [[Android (operating system)|Android]].
| operating system = [[Linux]], [[macOS]], [[Microsoft Windows|Windows]] and <!-- no longer just community support for --> [[FreeBSD]]
| license = [[MIT License|MIT]] (core),<ref name="license"/><!--for core language while, by default, "the environment, which consists of the language, user interfaces, and libraries, is under the GPL"--> [[General Public Licence|GPL v2]];<ref name="JuliaHome" /><ref>{{cite newsgroup|url=https://groups.google.com/forum/#!topic/julia-users/v4OjEK7azBs |title=Non-GPL Julia? |website=Groups.google.com |date= |accessdate=2017-05-31}}</ref><!--as some few libraries used by the standard library (that can be excluded) are [[copyleft]]--> a [[makefile]] option omits GPL libraries<ref>{{cite web |url=https://github.com/JuliaLang/julia/pull/10870 |title=Introduce USE_GPL_LIBS Makefile flag to build Julia without GPL libraries |quote=Note that this commit does not remove GPL utilities such as git and busybox that are included in the Julia binary installers on Mac and Windows.<!--dropped as of 0.5 then only libgit2--> It allows building from source with no GPL library dependencies.}}</ref>
| file ext = .jl
| website = {{Official website|https://JuliaLang.org|name=JuliaLang.org}}
}}

'''Julia''' is a [[high-level programming language|high-level]], high-performance, dynamic [[programming language]]. While it is a general purpose language and can be used to write any application, many of its features are well-suited for high-performance [[numerical analysis]] and [[computational science]].<ref>{{cite web
  | date       = 15 October 2012
  | last       = Bryant
  | first      = Avi
  | title      = Matlab, R, and Julia: Languages for data analysis
  | url        = https://strata.oreilly.com/2012/10/matlab-r-julia-languages-for-data-analysis.html
  | archiveurl = https://web.archive.org/web/20140426110631/https://strata.oreilly.com/2012/10/matlab-r-julia-languages-for-data-analysis.html
  | archivedate= 2014-04-26
  | publisher  = O'Reilly Strata
  }}</ref><ref>{{cite web
  | date       = 23 August 2015
  | last       = Singh
  | first      = Vicky
  | title      = Julia Programming Language – A True Python Alternative
  | url        = https://www.technotification.com/2018/08/julia-programming-language.html
  | publisher  = Technotification
  }}</ref><ref>{{cite magazine
  | last       = Krill
  | first      = Paul
  | title      = New Julia language seeks to be the C for scientists
  | url        = https://www.infoworld.com/d/application-development/new-julia-language-seeks-be-the-c-scientists-190818
  | magazine   = InfoWorld
  | date       = 18 April 2012
  }}</ref><ref>{{cite magazine
  | last       = Finley
  | first      = Klint
  | title      = Out in the Open: Man Creates One Programming Language to Rule Them All
  | url        = https://www.wired.com/2014/02/julia/
  | magazine   = Wired
  | date       = 3 February 2014
  }}</ref>

Julia can be used be people from a young age (e.g. a 15-year-old<ref name="Tanmay"/> has used and written a book on Julia) to any age, and Julia is commonly used in universities.

Distinctive aspects of Julia's design include a type system with [[parametric polymorphism]] in a [[dynamic programming language]]; with [[multiple dispatch]] as its core [[programming paradigm]], meaning it provides the ability to define function behavior across many combinations of argument types.

<!-- Julia supports [[Concurrent computing|concurrent]], (composable) [[parallel computing|parallel]] and [[distributed computing]] (with or without using [[Message Passing Interface|MPI]]<ref>{{cite web|title=GitHub - JuliaParallel/MPI.jl: MPI wrappers for Julia.|url=https://github.com/JuliaParallel/MPI.jl|publisher=Parallel Julia|access-date=2019-09-22}}</ref> and/or the built-in corresponding<ref>{{Cite web|url=https://discourse.julialang.org/t/questions-about-getting-started-with-parallel-computing/25341/3?u=palli|title=Questions about getting started with parallel computing|date=2019-06-16|website=JuliaLang|language=en-US|access-date=2019-10-08}}</ref> to "[[OpenMP]]-style" threads<ref>{{Cite web|url=https://discourse.julialang.org/t/julia-and-concurrency/25556/2|title=Julia and Concurrency|date=2019-06-24|website=JuliaLang|language=en-US|access-date=2019-09-22}}</ref>), and [[foreign function interface|direct calling]] of [[C (programming language)|C]] and [[Fortran]] libraries without [[adapter pattern#gluecode|glue code]]. A [[Just-in-time compilation|just-in-time]] compiler that is referred to as "just-[[Ahead-of-time compilation|ahead-of-time]]"<ref>{{cite web |last1=Fischer |first1=Keno |last2=Nash |first2=Jameson |title=Growing a Compiler - Getting to Machine Learning from a General Purpose Compiler |url=https://juliacomputing.com/blog/2019/02/19/growing-a-compiler.html |website=Julia Computing Blog |accessdate=11 April 2019}}</ref> in the Julia community is used.
-->
Julia is [[garbage collection (computer science)|garbage-collected]] language, shared by many other languages like JavaScript and Go, and it's a feature to make programming easier for developers, to not have implement deallocation of memory, and thus eliminate memory-leaks. It also makes the language safer than many other commonly-used languages like C.

Tools available for Julia include, not just many widely used editors, such as [[Vim (text editor)|Vim]] and [[Emacs]], but also [[integrated development environment|IDEs]] (e.g. Juno, and Microsoft's [[Visual Studio Code]], with [[Plug-in (computing)|extensions]] adding Julia support, both providing debugging support); with integrated tools, e.g. a [[lint (software)|linter]],<ref>{{Cite web|url=https://discourse.julialang.org/t/ann-linter-julia-plugin-for-atom-juno/2118|title=ANN: linter-julia plugin for Atom / Juno|date=2017-02-15|website=JuliaLang|language=en|access-date=2019-04-10}}</ref> [[profiling (computer programming)|profiler]] (and flame graph support available<ref>{{Citation|last=Holy|first=Tim|title=GitHub - timholy/ProfileView.jl: Visualization of Julia profiling data.|date=2019-09-13|url=https://github.com/timholy/ProfileView.jl|access-date=2019-09-22}}</ref><ref>{{Citation|last=Gregg|first=Brendan|title=GitHub - brendangregg/FlameGraph: Stack trace visualizer.|date=2019-09-20|url=https://github.com/brendangregg/FlameGraph|access-date=2019-09-22}}</ref> for the built-in one), debugger,<ref>{{Cite web|url=https://julialang.org/blog/2019/03/debuggers|title=A Julia interpreter and debugger|website=julialang.org|access-date=2019-04-10}}</ref> and the Rebugger.jl package "supports [[interactive programming|repeated-execution debugging]]"{{Efn|<!--quote= --> [With Rebugger.jl] you can:
* test different modifications to the code or arguments as many times as you want; you are never forced to exit “debug mode” and save your file
* run the same chosen block of code repeatedly (perhaps trying out different ways of fixing a bug) without needing to repeat any of the “setup” work that might have been necessary to get to some deeply nested method in the original call stack.<ref name="Rebugger">{{Cite web|url=https://discourse.julialang.org/t/ann-rebugger-interactive-debugging-for-julia-0-7-1-0/13843|title=[ANN] Rebugger: interactive debugging for Julia 0.7/1.0|quote=<!--Better in the "Efn" footnote above?-->
|date=2018-08-21|website=JuliaLang|language=en|access-date=2019-04-10}}</ref>}} and more.<ref>{{Cite web|url=https://timholy.github.io/Rebugger.jl/dev/|title=Home · Rebugger.jl|website=timholy.github.io|access-date=2019-04-10}}</ref>

==History==
Work on Julia was started in 2009, by Jeff Bezanson, [[Stefan Karpinski]], [[Viral B. Shah]], and [[Alan Edelman]], who set out to create a free language that was both high-level and fast. On 14 February 2012, the team launched a website with a blog post explaining the language's mission.<ref>{{cite web|last1=Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman|title=Why We Created Julia|url=https://julialang.org/blog/2012/02/why-we-created-julia|website=JuliaLang.org|accessdate=5 June 2017}}</ref>  In an interview with InfoWorld in April 2012, Karpinski said of the name "Julia": "There's no good reason, really. It just seemed like a pretty name."<ref>[[Stefan Karpinski]], [https://www.infoworld.com/article/2616709/application-development/new-julia-language-seeks-to-be-the-c-for-scientists.html New Julia language seeks to be the C for scientists], [[InfoWorld]], 18 April 2012</ref> Bezanson said he chose the name on the recommendation of a friend.<ref>{{cite web |last1=Torre |first1=Charles |title=Stefan Karpinski and Jeff Bezanson on Julia |url=https://channel9.msdn.com/Blogs/Charles/Stefan-Karpinski-and-Jeff-Bezanson-Julia-Programming-Language |website=Channel 9 |publisher=MSDN |accessdate=4 December 2018}}</ref>

Since the 2012 launch, the Julia community has grown, with over 13,000,000 downloads {{as of|2020|03|lc=y}} (and is used at more than 1,500 universities),<ref>{{Cite web|url=https://juliacomputing.com/|title=Julia Computing|website=juliacomputing.com||access-date=2020-04-05}}</ref><ref>{{Cite web|url=https://juliacomputing.com/blog/2019/11/07/november-newsletter.html|title=Newsletter November 2019|date=2019-11-07|website=juliacomputing.com|access-date=2019-11-29}}</ref><ref>{{Cite web|url=https://juliacomputing.com/blog/2019/01/04/january-newsletter.html |title=Julia Computing Newsletter, Growth Metrics|website=juliacomputing.com|access-date=2019-02-11}}</ref> <!-- The Official Julia Docker images, at [[Docker, Inc.|Docker Hub]], have seen over 4,000,000 downloads as of January 2019.<ref>{{Cite web|url=https://juliacomputing.com/blog/2019/01/04/january-newsletter.html|title=Newsletter January 2019|website=juliacomputing.com|date=4 January 2019|access-date=2019-08-20}}</ref><ref>https://hub.docker.com/_/julia</ref> --> The JuliaCon<ref>{{cite web|url=http://juliacon.org/ |title=JuliaCon website |website=juliacon.org |accessdate=2018-05-10}}</ref> [[academic conference]] for Julia users and developers has been held annually since 2014.

Julia 1.0 was released on 8 August 2018. Bugfix releases are expected roughly monthly, for 1.4.x and 1.0.x and Julia 1.0.1, up to 1.0.5 have followed that schedule. JuliaPro version 1.4.0-1 is also out.<ref>{{Cite web|url=https://juliacomputing.com/|title=Julia Computing|website=juliacomputing.com|access-date=2019-09-15}}</ref>

===Notable uses===
There are many resources to learn Julia, for simple things up to very complex.<ref>{{Cite web|url=https://julialang.org/learning/|title=The Julia Language|authors=Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman, et al|website=julialang.org|language=en|access-date=2020-04-05}}</ref> E.g. [[Tanmay Bakshi]], when 15-year-old, wrote a book to teach Julia for beginners, including for [[machine learning]] (a subfield of [[artificial intelligence]]).<ref name="Tanmay">{{Cite web|url=https://www.mheducation.co.uk/tanmay-teaches-julia-for-beginners-a-springboard-to-machine-learning-for-all-ages-9781260456639-emea|title=Tanmay Teaches Julia for Beginners: A Springboard to Machine Learning for All Ages|website=www.mheducation.co.uk|quote=Written by 15-year-old technology phenom [[Tanmay Bakshi]], the book is presented in an accessible style that makes learning easy and enjoyable. Tanmay Teaches Julia for Beginners: A Springboard to Machine Learning for All Ages clearly explains the basics of Julia programming and takes a look at cutting-edge machine learning applications.|language=en|access-date=2020-04-05}}</ref>

Julia has attracted some high-profile users, from investment manager [[BlackRock]], which uses it for [[time-series analytics]], to the British insurer [[Aviva]], which uses it for [[risk calculations]]. In 2015, the [[Federal Reserve Bank of New York]] used Julia to make models of the US economy, noting that the language made model estimation "about 10 times faster" than its previous [[MATLAB]] implementation. Julia's co-founders established Julia Computing in 2015 to provide paid support, training, and consulting services to clients, though Julia itself remains free to use. At the 2017 JuliaCon<ref>{{cite web|url=http://juliacon.org/2017/ |title=JuliaCon 2017 |website=juliacon.org |accessdate=2017-06-04}}</ref> conference, Jeffrey Regier, [[Keno Fischer]] and others announced<ref>{{cite web|last1=Fisher|first1=Keno|title=The Celeste Project|url=https://juliacon2017.sched.com/speaker/thecelesteproject|website=juliacon.org|accessdate=24 June 2017}}</ref> that the Celeste project<ref>{{cite arxiv|last1=Regier|first1=Jeffrey|last2=Pamnany|first2=Kiran|last3=Giordano|first3=Ryan|last4=Thomas|first4=Rollin|last5=Schlegel|first5=David|last6=McAulife|first6=Jon|last7=Prabat|title=Learning an Astronomical Catalog of the Visible Universe through Scalable Bayesian Inference|eprint=1611.03404|class=cs.DC|year=2016}}</ref> used Julia to achieve "peak performance of 1.54&nbsp;[[FLOPS|petaFLOPS]] using 1.3 million threads"<ref>{{cite press |url=https://juliacomputing.com/press/2017/09/12/julia-joins-petaflop-club.html |title=Julia Joins Petaflop Club |date=12 September 2017 | first=Andrew |last=Claster |work=Julia Computing |quote=Celeste is written entirely in Julia, and the Celeste team loaded an aggregate of 178 terabytes of image data to produce the most accurate catalog of 188 million [[astronomical object]]s in just 14.6 minutes [..] a performance improvement of 1,000x in single-threaded execution.}}</ref> on 9300 <!-- on 9,300 (vs. 8192 Xeon cores") possibly "optional nVidia" GPU cards of Cori are used (or not), unclear conflated with lower numbers? --> [[Knights Landing (microarchitecture)|Knights Landing]] (KNL) nodes of the [[Cray XC40#United States|Cori II (Cray XC40)]] supercomputer (then 6th fastest computer in the world).<ref>{{Cite web|url=https://twitter.com/Viral_B_Shah/status/930928375400751105|title=. @KenoFischer is speaking on Celeste in the @Intel theatre at @Supercomputing. 0.65M cores, 56 TB of data, Cori - world's 6th largest supecomputer.pic.twitter.com/21nLHo1qty|last=Shah|first=Viral B.|date=2017-11-15|website=@Viral_B_Shah|language=en|access-date=2019-09-15}}</ref> Julia thus joins C, C++, and Fortran as high-level languages in which petaFLOPS computations have been achieved.

Three of the Julia co-creators are the recipients of the 2019 [[J. H. Wilkinson Prize for Numerical Software|James H. Wilkinson Prize for Numerical Software]] (awarded every four years) "for the creation of Julia, an innovative environment for the creation of high-performance tools that enable the analysis and solution of computational science problems."<ref>{{Cite web|url=https://news.mit.edu/2018/julia-language-co-creators-win-james-wilkinson-prize-numerical-software-1226|title=Julia language co-creators win James H. Wilkinson Prize for Numerical Software|website=MIT News|access-date=2019-01-22}}</ref>  Also, Alan Edelman, professor of applied mathematics at MIT, has been selected to receive the 2019 IEEE Computer Society Sidney Fernbach Award "for outstanding breakthroughs in high-performance computing, linear algebra, and computational science and for contributions to the Julia programming language."<ref>{{Cite press|url=https://www.computer.org/press-room/2019-news/2019-ieee-fernbach-award-edelman|title=Alan Edelman of MIT Recognized with Prestigious 2019 IEEE Computer Society Sidney Fernbach Award {{!}} IEEE Computer Society|language=en-US|date=1 October 2019|access-date=2019-10-09}}</ref>

Julia Computing and [[NVIDIA]] announce "the availability of the Julia programming language as a pre-packaged container on the NVIDIA GPU Cloud (NGC) container registry"<ref name="Julia_Nvidia">{{Cite web|url=https://juliacomputing.com/blog/2019/12/03/nvidia-ngc-arm.html|title=Julia Computing and NVIDIA Bring Julia GPU Computing to Arm|date=2019-12-03|website=juliacomputing.com|access-date=2019-12-03}}</ref> with NVIDIA stating "Easily Deploy Julia on x86 and Arm [..] Julia offers a package for a comprehensive HPC ecosystem covering machine learning, data science, various scientific domains and visualization."<ref>{{Cite web|url=https://blogs.nvidia.com/blog/2019/11/18/ngc-containers-arm/|title=NVIDIA Expands Support for Arm with HPC, AI, Visualization Containers on NGC {{!}} NVIDIA Blog|last=Patel|first=Chintan|date=2019-11-19|website=The Official NVIDIA Blog|language=en-US|access-date=2019-12-03}}</ref>

Additionally, "Julia was selected by the [https://clima.caltech.edu/ Climate Modeling Alliance] as the sole implementation language for their next generation global climate model. This multi-million dollar project aims to build an earth-scale climate model providing insight into the effects and challenges of climate change."<ref name="Julia_Nvidia"/>

===Sponsors===
Julia has received contributions from over 870 developers worldwide.<ref>{{Cite web|title=JuliaLang/julia: The Julia Language: A fresh approach to technical computing.|date=2019-01-26|url=https://github.com/JuliaLang/julia|publisher=The Julia Language|access-date=2019-01-26}}</ref> Dr. Jeremy Kepner at [[MIT Lincoln Laboratory]] was the founding sponsor of the Julia project in its early days. In addition, funds from the [[Gordon and Betty Moore Foundation]], the [[Alfred P. Sloan Foundation]], [[Intel]], and agencies such as [[National Science Foundation|NSF]], [[DARPA]], [[National Institutes of Health|NIH]], [[NASA]], and [[Federal Aviation Administration|FAA]] have been essential to the development of Julia.<ref>{{Cite web|url=https://julialang.org/research/|title=The Julia Language|website=julialang.org|access-date=2019-09-22}}</ref> In addition [[Mozilla]], the maker of Firefox web browser, with its research grants for H1 2019, sponsored "a member of the official Julia team" for the project "Bringing Julia to the Browser",<ref>{{Cite web|url=https://www.zdnet.com/article/mozilla-is-funding-a-way-to-support-julia-in-firefox/|title=Mozilla is funding a way to support Julia in Firefox|last=Cimpanu|first=Catalin|website=ZDNet|language=en|access-date=2019-09-22}}</ref> meaning to Firefox <!-- "and the general browser environment--> and other web browsers.<ref>{{Cite web|url=https://alpha.iodide.io/notebooks/225/|title=Julia in Iodide|website=alpha.iodide.io|access-date=2019-09-22}}</ref><ref>{{Cite web|url=https://iodide-project.github.io/docs/language_plugins/|title=Language plugins - Iodide Documentation|website=iodide-project.github.io|access-date=2019-09-22}}</ref><ref>{{Cite web|url=https://mozilla-research.forms.fm/mozilla-research-grants-2019h1/forms/6510|title=Mozilla Research Grants 2019H1|website=Mozilla|language=en|quote=running language interpreters in WebAssembly. To further increase access to leading data science tools, we’re looking for someone to port R or Julia to WebAssembly and to attempt to provide a level 3 language plugin for Iodide: automatic conversion of data basic types between R/Julia and Javascript, and the ability to share class instances between R/Julia and Javascript.|access-date=2019-09-22}}</ref><ref>{{Citation|title=Literate scientific computing and communication for the web: iodide-project/iodide|date=2019-09-20|url=https://github.com/iodide-project/iodide|publisher=iodide|quote=We envision a future workflow that allows you to do your data munging in Python, fit a quick model in R or JAGS, solve some differential equations in Julia, and then display your results with a live interactive d3+JavaScript visualization... and all that within within a single, portable, sharable, and hackable file.|access-date=2019-09-22}}</ref>

===Julia Computing===
Julia Computing, Inc. was founded in 2015 by [[Viral B. Shah]], Deepak Vinchhi, [[Alan Edelman]], Jeff Bezanson, [[Stefan Karpinski]] and Keno Fischer.<ref>{{Cite web|url=https://juliacomputing.com/about-us|title=About Us – Julia Computing|website=juliacomputing.com|access-date=2017-09-12}}</ref>

In June 2017, Julia Computing raised $4.6M in seed funding from [[General Catalyst]] and [[Founder Collective]].<ref>https://juliacomputing.com/communication/2017/06/19/seed-funding.html</ref>
<!--
==Language features==
Though designed for numerical computing, Julia is a [[general-purpose programming language]].<ref>{{cite web
  | title      = The Julia Language
  | type       = official website
  | url        = https://julialang.org/
  | quote      = General Purpose [..] Julia lets you write UIs, statically compile your code, or even deploy it on a webserver.
}}</ref>
It is also useful for low-level [[system programming|systems programming]],<ref name="LowLevelSystemsProgrammingInJulia">{{cite web |url=http://juliacon.org/2018/talks_workshops/42/
|archiveurl=https://web.archive.org/web/20181105083419/http://juliacon.org/2018/talks_workshops/42/
|archivedate=5 November 2018
|first=Todd |last=Green
|title=Low-Level Systems Programming in High-Level Julia
|date=10 August 2018
|accessdate=5 November 2018
}}</ref> as a [[specification language]],<ref name="spec">{{cite web |url=http://juliacon.org/talks.html#friday
|archiveurl=https://web.archive.org/web/20150701182804/http://juliacon.org/talks.html
|archivedate=1 July 2015
|first=Robert |last=Moss
|title=Using Julia as a Specification Language for the Next-Generation Airborne Collision Avoidance System
|quote=[[Airborne collision avoidance system]]
|date=26 June 2015
|accessdate=29 June 2015
}}</ref> and for web programming at both server<ref>{{Cite web|url=https://medium.com/@richardanaya/how-to-create-a-multi-threaded-http-server-in-julia-ca12dca09c35|title=How to create a multi-threaded HTTP server in Julia|last=Anaya|first=Richard|date=2019-04-28|website=Medium|language=en|access-date=2019-07-25|quote=In summary, even though Julia lacks a multi-threaded server solution currently out of box, we can easily take advantage of its process distribution features and a highly popular load balancing tech to get full CPU utilization for HTTP handling.}}</ref><ref>{{Cite web|last=Anthoff|first=David|title=Node.js installation for julia|date=2019-06-01|url=https://github.com/davidanthoff/NodeJS.jl|access-date=2019-07-25}}</ref> and client<ref name="JSExpr"/><ref name="WebAssembly"/> side.

According to the official website, the main features of the language are:

* [[Multiple dispatch]]: providing ability to define function behavior across many combinations of argument types
* [[Dynamic type]] system: types for documentation, optimization, and dispatch
* Good performance, approaching that of [[Type system|statically-typed]] languages like C
* A built-in [[package manager]]
* [[Lisp (programming language)|Lisp]]-like macros and other [[metaprogramming]] facilities
* Call [[Python (programming language)|Python]] functions: use the PyCall package{{Efn|For calling the newer [[Python 3]] (the older default to call Python 2, is also still supported)<ref>{{cite web |url=https://github.com/JuliaPy/PyCall.jl |title=PyCall.jl |work=stevengj |publisher=github.com}}</ref><ref>{{cite newsgroup |url=https://groups.google.com/forum/#!topic/julia-users/lDM7-YXT2LU |title=Using PyCall in julia on Ubuntu with python3 |work=julia-users at Google Groups|quote=to import modules (e.g., python3-numpy)}}</ref> and calling in the other direction, from Python to Julia, is also supported with ''pyjulia''.<ref>{{cite web |url=https://github.com/JuliaPy/pyjulia |title=python interface to julia}}</ref>}}
* Call [[C (programming language)|C]] functions directly: no wrappers or special [[application programming interface|APIs]]
* Powerful [[shell (computing)|shell]]-like abilities to manage other processes
* Designed for [[Parallel computing|parallel]] and [[distributed computing]]
* [[Coroutine|Coroutines]]: lightweight [[Green threads|''green'' threading]]
* User-defined types are as fast and compact as built-ins
* Automatic generation of efficient, specialized code for different argument types
* Elegant and extensible conversions and promotions for numeric and other types
* Efficient support for [[Unicode]], including but not limited to [[UTF-8]]

Multiple dispatch (also termed [[multimethod]]s in Lisp) is a [[generalization]] of [[single dispatch]]{{snd}} the [[Polymorphism (computer science)|polymorphic mechanism]] used in common [[object-oriented programming]] (OOP) languages{{snd}} that uses [[Inheritance (object-oriented programming)|inheritance]]. In Julia, all concrete types are [[subtyping|subtypes]] of abstract types, directly or indirectly subtypes of the ''Any'' type, which is the top of the type hierarchy. Concrete types can not themselves be subtyped the way they can in other languages; composition is used instead (see also [[Inheritance (object-oriented programming)#Inheritance vs subtyping|inheritance vs subtyping]]).

Julia draws significant inspiration from various dialects of Lisp, including [[Scheme (programming language)|Scheme]] and [[Common Lisp]], and it shares many features with [[Dylan (programming language)|Dylan]], also a multiple-dispatch-oriented dynamic language (which features an [[ALGOL]]-like [[Free-form language|free-form]] [[Infix notation|infix]] syntax rather than a Lisp-like prefix syntax, while in Julia "everything"<ref name="Learn Julia in Y">{{cite web|url=https://learnxinyminutes.com/docs/julia/ |title=Learn Julia in Y Minutes |website=Learnxinyminutes.com |date= |accessdate=2017-05-31}}</ref> is an [[Expression (computer science)|expression]]), and with [[Fortress (programming language)|Fortress]], another numerical programming language (which features multiple dispatch and a sophisticated parametric type system). While [[Common Lisp Object System]] (CLOS) adds multiple dispatch to Common Lisp, not all functions are generic functions.

By default, the Julia runtime must be pre-installed as user-provided source code is run. Alternatively, a standalone [[executable]] that needs no Julia source code can be built with ''ApplicationBuilder.jl''<ref>{{Cite web|last=Daly|first=Nathan|title=GitHub - NHDaly/ApplicationBuilder.jl: Compile, bundle, and release julia software.|date=2019-02-13|url=https://github.com/NHDaly/ApplicationBuilder.jl|access-date=2019-02-15}}</ref> and ''PackageCompiler.jl''.<ref>{{cite web|title=GitHub - JuliaLang/PackageCompiler.jl: Compile your Julia Package.|date=2019-02-14|url=https://github.com/JuliaLang/PackageCompiler.jl|publisher=The Julia Language|access-date=2019-02-15}}</ref>

Julia's [[Macro (computer science)#Syntactic macros|syntactic macros]] (used for [[metaprogramming]]), like Lisp macros, are more powerful than [[Macro (computer science)#Text-substitution macros|text-substitution macros]] used in the [[preprocessor]] of some other languages such as C, because they work at the level of [[abstract syntax tree]]s (ASTs). Julia's macro system is [[hygienic macro|hygienic]], but also supports deliberate capture when desired (like for [[anaphoric macro]]s) using the <code>esc</code> construct.
-->

==Interaction==
The Julia official distribution includes a "full-featured interactive command-line REPL" ([[read–eval–print loop]]),<ref>{{Cite web|url=https://docs.julialang.org/en/v1/stdlib/REPL/|title=The Julia REPL · The Julia Language|website=docs.julialang.org|access-date=2019-09-22}}</ref> with a searchable history, [[tab-completion]], many helpful keybindings, and dedicated help and [[shell (computing)|shell]] modes;<ref>{{Cite web|url=https://en.wikibooks.org/wiki/Introducing_Julia/The_REPL|title=Introducing Julia/The REPL - Wikibooks, open books for an open world|website=en.wikibooks.org|quote=you can install the Julia package OhMyREPL.jl (https://github.com/KristofferC/OhMyREPL.jl) which lets you customize the REPL's appearance and behaviour|access-date=2019-09-22}}</ref> which can be used to experiment and test code quickly.<ref>{{Cite web|url=https://docs.julialang.org/en/v1/manual/getting-started/|title=Getting Started · The Julia Language|website=docs.julialang.org|language=en|access-date=2018-08-15}}</ref> The following fragment represents a sample session example where strings are concatenated automatically by println:<ref>See also: https://docs.julialang.org/en/v1/manual/strings/ for string interpolation and the <code>string(greet, ", ", whom, ".\n")</code> example for preferred ways to concatenate strings. <!--While the <code>+</code> operator is not used for string concatenation, it could easily be defined to do so.--> Julia has the println and print functions, but also a @printf macro (i.e., not in function form) to eliminate run-time overhead of formatting (unlike the same function in C).</ref>

<source lang="jlcon">
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!
</source>

The REPL gives user access to the system shell and to help mode, by pressing <code>;</code> or <code>?</code> after the prompt (preceding each command), respectively. It also keeps the history of commands, including between sessions.<ref>{{cite web|title=Julia Documentation|url=https://docs.julialang.org|website=JuliaLang.org|accessdate=18 November 2014}}</ref> Code that can be tested inside the Julia's interactive section or saved into a file with a <code>.jl</code> extension and run from the command line by typing:<ref name="Learn Julia in Y">{{cite web|url=https://learnxinyminutes.com/docs/julia/ |title=Learn Julia in Y Minutes |website=Learnxinyminutes.com |date= |accessdate=2017-05-31}}</ref>

<source lang="console">
 $ julia <filename>
</source>

<!--Julia is supported by [[Jupyter]], an online interactive "notebooks" environment.<ref>{{cite web |url=https://jupyter.org/ |title=Project Jupyter}}</ref>
-->
<!-- ==See also==
* [[Comparison of numerical analysis software]]
* [[Comparison of statistical packages]]
-->
==Notes==
{{Notelist|80em}}

==References==
{{Reflist|30em}}

==Further reading==
* {{cite book|last=Nagar|first=Sandeep|year=2017|title=Beginning Julia Programming-For Engineers and Scientists|publisher=Springer}}
* {{cite journal|author1=Bezanson, J|author2=Edelman, A|author3=Karpinski, S|author4=Shah, V. B|year=2017|title=Julia: A fresh approach to numerical computing|publisher=SIAM Review |volume=59 |issue=1 |pages=65–98}}
* {{cite book|last=Joshi|first=Anshul|year=2016|title=Julia for Data Science － Explore the world of data science from scratch with Julia by your side|publisher=Packt Publishing}}

==External links==
<!--{{wikibook|Introducing Julia}}-->
* {{Official website|https://julialang.org}}
* [https://github.com/JuliaLang/julia Source code]
<!--
{{Programming languages}}
{{FOSS}}
{{Numerical analysis software}}
{{Mathematical optimization software}}
{{Statistical software}}
-->
[[Category:2012 software]]
[[Category:Array programming languages]]
[[Category:Computational notebook]]
[[Category:Cross-platform software]]
[[Category:Data mining and machine learning software]]
[[Category:Data-centric programming languages]]
[[Category:Dynamically typed programming languages]]
[[Category:Free compilers and interpreters]]<!-- note there's also a Julia interpreter (not on by default); beside FemptoLisp-->
[[Category:Free computer libraries]]
[[Category:Free data analysis software]]
[[Category:Free data visualization software]]
[[Category:Free software projects]]
[[Category:Free software programmed in C]]
[[Category:Free statistical software]]
[[Category:Functional languages]]
[[Category:High-level programming languages]]
[[Category:Lisp programming language_family]]
[[Category:Multi-paradigm programming languages]]<!-- ok? Mostly only using the main paradigm multiple-dispatch, but Julia enables using more, e.g. implementing class-based OO-->
[[Category:Numerical analysis software for Linux]]
[[Category:Numerical analysis software for MacOS]]
[[Category:Numerical analysis software for Windows]]
[[Category:Numerical libraries]] <!--for Julia's standard library: seems ok, as e.g. part of (and all planned) C's libm has been rewritten in Julia-->
[[Category:Numerical linear algebra]]
[[Category:Numerical programming languages]]
[[Category:Object-oriented programming languages]]
[[Category:Parallel computing]]
[[Category:Procedural programming languages]]
[[Category:Programming languages]]
[[Category:Programming languages created in 2012]]
[[Category:Software using the MIT license]]
<!-- [[Category:Scripting languages]] ? -->
[[Category:Statistical programming languages]]
[[Category:Text-oriented programming languages]]
[[Category:Homoiconic programming languages]]
[[Category:Articles with example Julia code]]