Julia (programming language) - Wikipedia

https://en.wikipedia.org/wiki/Julia_(programming_language)

Not logged in Talk Contributions Create account Log in

Article Talk Read Edit View history Search Wikipedia Go

Julia (programming language)

From Wikipedia, the free encyclopedia

Julia is a high-level dynamic programming language designed to
Main page Julia
Contents
address the needs of high-performance numerical analysis and
Featured content computational science while also being effective for general-
Current events purpose programming,[15][16][17][18] web use [19][20] or as a
Random article specification language.[21]
Donate to Wikipedia
Wikipedia store Distinctive aspects of Julia's design include a type system with
Interaction parametric polymorphism and types in a fully dynamic
Help programming language and multiple dispatch as its core
About Wikipedia programming paradigm . It allows concurrent , parallel and
Community portal
Recent changes distributed computing , and direct calling of C and Fortran Official Julia logo
Contact page libraries without glue code . Paradigm Multi-paradigm:
multiple dispatch
Tools Julia is garbage-collected ,[22] uses eager evaluation and includes
What links here ("object-oriented"),
efficient libraries for floating-point calculations, linear algebra , procedural, functional,
Related changes
Upload file random number generation , fast Fourier transforms and regular meta, multistaged[1]
Special pages expression matching. Designed by Jeff Bezanson, Stefan
Permanent link Karpinski, Viral B.
Page information Contents
 [hide]  Shah, Alan Edelman
Wikidata item
1 Language features Developer Jeff Bezanson, Stefan
Cite this page
2 Interaction Karpinski, Viral B.
Print/export 2.1 Use with other languages Shah, and other
Create a book contributors[2][3]
3 Implementation
Download as PDF
3.1 Current and future platforms First appeared 2012; 5 years ago[4]
Printable version
3.2 Julia2C source-to-source compiler
In other projects Stable release 0.5.1[5] / 0.4.7[6] /
Wikimedia 4 See also 5 March 2017; 27 days
Commons 5 Notes ago[8]
Languages 6 References
Preview release 0.6.0-pre.alpha[7] /
‫العربية‬ 7 External links
Čeština 0.6.0-dev / daily
Deutsch updates

Language features
Español Typing Dynamic, nominative,
[ edit ]
‫فارسی‬ discipline parametric
Français According to the official website, the main features of the Implementation Julia, C, C++ (mostly
한국어 language are: language LLVM dependency),
Italiano Scheme (the parser;
日本語 Multiple dispatch : providing ability to define function behavior
using the FemtoLisp
Português across many combinations of argument types implementation);
Русский standard library: Julia
Dynamic type system: types for documentation, optimization,
Српски / srpski
(mostly), C (a few
Türkçe and dispatch
dependencies),
中文 Good performance, approaching that of statically-typed Fortran (BLAS and
Edit links with assembly)[9]
languages like C
Built-in package manager Platform IA-32, x86-64
Lisp-like macros and other metaprogramming facilities OS Linux, macOS,
Call Python functions: use the PyCall package [a] FreeBSD, Windows

Call C functions directly: no wrappers or special APIs License MIT (core),[2] GPL
v2;[9][10] a make-file
Powerful shell -like abilities to manage other processes
option omits GPL
Designed for parallel and distributed computing libraries[11]
Coroutines: lightweight green threading

https://en.wikipedia.org/wiki/Julia_(programming_language)[04/04/2017 2:17:59 PM]

Julia (programming language) - Wikipedia

Filename .jl
User-defined types are as fast and compact as built-ins extensions
Automatic generation of efficient, specialized code for Website julialang.org
different argument types Influenced by
Elegant and extensible conversions and promotions for C · Fortran[4] · Lisp · Lua[12] ·
numeric and other types Mathematica[4] (strictly its Wolfram
Efficient support for Unicode , including but not limited to Language[4][13]) · MATLAB[4] · Perl ·
UTF-8 Python · R · Ruby[12] · Scheme[14]

Multiple dispatch (also termed multimethods in Lisp) is a

generalization of single dispatch  – the polymorphic mechanism used in common object-oriented
programming (OOP) languages – that uses inheritance . In Julia, all concrete types are subtypes of abstract
types, directly or indirectly subtypes of the Any type, which is the top of the type hierarchy. Concrete types
can not be subtyped, but composition is used over inheritance, that is used by traditional object-oriented
languages (see also Inheritance vs subtyping).
Julia draws significant inspiration from various dialects of Lisp, including Scheme and Common Lisp , and it
shares many features with Dylan (such as an ALGOL-like free-form infix syntax rather than a Lisp-like
prefix syntax, while in Julia "everything"[26] is an expression ) – also a multiple-dispatch-oriented dynamic
language – and Fortress , another numerical programming language with 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.
In Julia, Dylan and Fortress extensibility is the default, and the system's built-in functions are all generic and
extensible. In Dylan, multiple dispatch is as fundamental as it is in Julia: all user-defined functions and even
basic built-in operations like + are generic. Dylan's type system, however, does not fully support parametric
types, which are more typical of the ML lineage of languages . By default, CLOS does not allow for dispatch
on Common Lisp's parametric types; such extended dispatch semantics can only be added as an extension
through the CLOS Metaobject Protocol . By convergent design, Fortress also features multiple dispatch on
parametric types; unlike Julia, however, Fortress is statically rather than dynamically typed, with separate
compiling and executing phases. The language features are summarized in the following table:

Language Type system Generic functions Parametric types

Julia Dynamic Default Yes
Common Lisp Dynamic Opt-in Yes (but no dispatch)
Dylan Dynamic Default Partial (no dispatch)
Fortress Static Default Yes

By default, the Julia runtime must be pre-installed as user-provided source code is run, while another way is
possible, where a standalone executable can be made that needs no Julia source code built with
BuildExecutable.jl. [27][28]
Julia's syntactic macros (used for metaprogramming ), like Lisp macros, are more powerful and different
from text-substitution macros used in the preprocessor of some other languages such as C, because they
work at the level of abstract syntax trees (ASTs). Julia's macro system is hygienic , but also supports
deliberate capture when desired (like for anaphoric macros ) using the esc construct.

Interaction [ edit ]
The Julia official distribution includes an interactive session shell, called Julia's read–eval–print loop (REPL),
which can be used to experiment and test code quickly.[29] The following fragment represents a sample
session on the REPL:[30]

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!

https://en.wikipedia.org/wiki/Julia_(programming_language)[04/04/2017 2:17:59 PM]

Julia (programming language) - Wikipedia

The REPL gives user access to the system shell and to help mode, by pressing ; or ? after the prompt
(preceding each command), respectively. The REPL also keeps the history of commands, even between
sessions. For other examples, see the Julia documentation,[31] which gives code that can be tested inside the
Julia's interactive section or saved into a file with a .jl extension and run from the command line by
typing (for example):[32]

$ julia <filename>

Julia is also supported by Jupyter , an online interactive "notebooks" environment (project Jupyter is a
multi-language extension, that "evolved", from the IPython command shell; now includes IJulia). See for
other ways in the next section.

Use with other languages [ edit ]

Julia's ccall keyword is used to call C-exported or Fortran shared library functions individually.
Julia has Unicode 9.0 support, with UTF-8 used for source code (and by default for strings) and e.g.
optionally allowing common math symbols for many operators, such as ∈ for the in operator.
Julia has packages supporting markup languages such as HTML, (and also for HTTP ), XML, JSON and
BSON .

Implementation [ edit ]
Julia's core is implemented in C and C++ (the LLVMdependency is in C++), its parser in Scheme
("femtolisp" ), and the LLVM compiler framework is used for just-in-time (JIT) generation of 64-bit or 32-
bit optimized machine code (i.e. not for VM[33]) depending on the platform Julia runs on. With some
exceptions (e.g., libuv), the standard library is implemented in Julia itself. The most notable aspect of Julia's
implementation is its speed, which is often within a factor of two relative to fully optimized C code (and thus
often an order of magnitude faster than Python or R).[34] Development of Julia began in 2009 and an open-
source version was publicized in February 2012.[4][35]
Julia, the 0.5.x line, is on a monthly release schedule where bugs are fixed and some new features from 0.6-
dev are backported (and possibly also to 0.4.x).

Current and future platforms [ edit ]

While Julia uses JIT [36] (MCJIT [37] from LLVM) – it still means Julia generates native machine code,
directly, before a function is first run (not a bytecode that is run on a virtual machine (VM) or translated as
the bytecode is running, as with e.g., Java; the JVM or Dalvik in Android).
Current support is for 32- and 64-bit (all except for ancient pre-Pentium 4 -era, to optimize for newer) x86
processors (and with download of executables or source code also available for other architectures).
Experimental and early support for ARM, AArch64 , and POWER (little-endian ) is available too. [38]
Including support for Raspberry Pi 1 and later (e.g., requires at least ARMv6).[39][40]
Support for GNU Hurd is being worked on. [41]

Julia version 0.6 was planned for 2016 and 1.0 for 2017 and some features are discussed for 2+ that is also
planned, e.g., "multiple inheritance for abstract types". [42]

Julia2C source-to-source compiler [ edit ]

A Julia2C source-to-source compiler from Intel Labs is available. [43] This compiler is a fork of Julia, that
implements the same Julia language syntax, which emits C code (for compatibility with more CPUs ) instead
of native machine code, as an intermediate language, for functions or whole programs. The compiler is also
meant to allow analyzing code at a higher level than C.[44]
Intel's ParallelAccelerator.jl can be thought of as a partial Julia to C++ compiler (and then to machine
code transparently), but the objective is parallel speedup (can be "100x over plain Julia", for the older 0.4
version,[45] and could in cases also speed up serial code manyfold for that version); not compiling the full

https://en.wikipedia.org/wiki/Julia_(programming_language)[04/04/2017 2:17:59 PM]

Julia (programming language) - Wikipedia

Julia language to C++ (C++ is only an implementation detail, later versions might not compile to C++). It
doesn't need to compile all of Julia's syntax, as the rest is handled by Julia.

See also [ edit ]

Comparison of numerical analysis software

Notes [ edit ]
a. ^ Calling newer Python 3 also works[23][24] (and PyPy[25]) and calling in the other direction, from
Python to Julia, is also supported with pyjulia . Even calling recursively (back and forth) between
these languages is possible, without (or with) using Polyglot.jl , that supports additional languages
to Python.

References [ edit ]
1. ^ "Smoothing data with Julia's @generated functions" . 5 November 2015. Retrieved 9 December
2015. "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."
2. ^ a b "LICENSE.md" . GitHub.
3. ^ "Contributors to JuliaLang/julia" . GitHub.
4. ^ a b c d e f "Why We Created Julia" . Julia website. February 2012. Retrieved 7 February 2013.
5. ^ http://julialang.org/downloads/
6. ^ http://julialang.org/downloads/oldreleases.html
7. ^ https://discourse.julialang.org/t/0-6-release-timeline/836/38
8. ^ https://github.com/JuliaLang/julia/releases/tag/v0.5.1
9. ^ a b "Julia" . Julia. NumFocus project. Retrieved 9 December 2016. "Julia’s Base library, largely
written in Julia itself, also integrates mature, best-of-breed open source C and Fortran libraries for ..."
10. ^ Non-GPL Julia?
11. ^ "Introduce USE_GPL_LIBS Makefile flag to build Julia without GPL libraries" . "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. It allows building from source with no GPL library dependencies."
12. ^ a b "Introduction" . The Julia Manual. Read the Docs. Retrieved 6 December 2016.
13. ^ "Programming Language Network" . GitHub. Retrieved 6 December 2016.
14. ^ "JuliaCon 2016" . JuliaCon. Retrieved 6 December 2016. "He has co-designed the programming
language Scheme, which has greatly influenced the design of Julia"
15. ^ "The Julia Language" (official website).
16. ^ Bryant, Avi (15 October 2012). "Matlab, R, and Julia: Languages for data analysis" . O'Reilly
Strata.
17. ^ Krill, Paul (18 April 2012). "New Julia language seeks to be the C for scientists" . InfoWorld.
18. ^ Finley, Klint (3 February 2014). "Out in the Open: Man Creates One Programming Language to
Rule Them All" . Wired.
19. ^ "Escher lets you build beautiful interactive Web UIs in Julia" . Retrieved 27 July 2015.
20. ^ "Getting Started with Node Julia" . node-julia.
21. ^ Moss, Robert (26 June 2015). "Using Julia as a Specification Language for the Next-Generation
Airborne Collision Avoidance System" . Archived from the original on 1 July 2015. Retrieved
29 June 2015. "Airborne collision avoidance system"
22. ^ "Suspending Garbage Collection for Performance...good idea or bad idea?" .
23. ^ "PyCall.jl" . stevengj. github.com.
24. ^ "Using PyCall in julia on Ubuntu with python3" . julia-users at Google Groups. "to import modules
(e.g. python3-numpy)"
25. ^ "Polyglot.jl" . wavexx. github.com.
26. ^ Learn X in Y minutes: Where X=Julia at learnxinyminutes.com
27. ^ dhoegh/BuildExecutable.jl: Build a standalone executables from a Julia script
28. ^ https://groups.google.com/forum/#!topic/julia-users/MtF4wHc77sw
29. ^ Julia REPL documentation
30. ^ See also: http://julia.readthedocs.org/en/latest/manual/strings/ for string interpolation and the
string(greet, ", ", whom, ".\n") example for preferred ways to concatenate strings.

https://en.wikipedia.org/wiki/Julia_(programming_language)[04/04/2017 2:17:59 PM]

Julia (programming language) - Wikipedia

While the + 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, while not in a function form, to eliminate
run-time overhead of formatting (unlike the same function in C).
31. ^ "Julia Documentation" . julialang.org. Retrieved 18 November 2014.
32. ^ Learn Julia in Y Minutes
33. ^ "Chris Lattner discusses the name LLVM" . Retrieved 22 December 2011.
34. ^ "Julia: A Fast Dynamic Language for Technical Computing" (PDF). 2012.
35. ^ Gibbs, Mark (9 January 2013). "Pure and Julia are cool languages worth checking out" . Network
World (column). Retrieved 7 February 2013.
36. ^ "Support MCJIT" . Retrieved 26 May 2015.
37. ^ "Using MCJIT with the Kaleidoscope Tutorial" . 22 July 2013. Retrieved 26 May 2015. quote=The
older implementation (llvm::JIT) is a sort of ad hoc implementation that brings together various pieces
of the LLVM code generation and adds its own glue to get dynamically generated code into memory
one function at a time. The newer implementation (llvm::MCJIT) is heavily based on the core MC
library and emits complete object files into memory then prepares them for execution.
38. ^ https://github.com/JuliaLang/julia/blob/v0.5.0/README.md
39. ^ "Cross-compiling for ARMv6" . Retrieved 16 May 2015. "I believe #10917 should fix this. The CPU
used there arm1176jzf-s."
40. ^ "ARM build failing during bootstrap on Raspberry Pi 2" . Retrieved 16 May 2015. "I can confirm
(FINALLY) that it works on the Raspberry Pi 2 [..] I guess we can announce alpha support for arm in
0.4 as well."
41. ^ https://github.com/JuliaLang/openlibm/pull/129 Fix building tests on GNU/kFreeBSD and
GNU/Hurd
42. ^ https://github.com/JuliaLang/julia/issues/6975 Interfaces for Abstract Types
43. ^ https://github.com/IntelLabs/julia/tree/j2c/j2c
44. ^ "Julia2C initial release" . "By translating Julia to C, we leverage the high-level abstractions (matrix,
vector, ..), which are easier to analyze, and can potentially add the rich extensions of C (like openmp,
tbb, ...).

The tool may also extend Julia to new architectures where the only available tool chain is for C
[..]
Translation from C to Julia might be harder."
45. ^ Lindsey Kuper (1 March 2016). "An introduction to ParallelAccelerator.jl" .

External links [ edit ]

Official website
The Julia manual Wikibooks has a book on the
topic of: Introducing Julia
Julia Package Listing – a searchable listing of all (currently
over 1300 with combined about 25,000 GitHub stars) registered packages

v·t·e Programming languages [show]

v·t·e Free and open-source software [show]
v·t·e Numerical analysis software [show]
v·t·e Mathematical optimization software [show]
v·t·e Statistical software [show]

Categories : 2012 software Array programming languages Computational notebook

Data mining and machine learning software Data-centric programming languages
Dynamically typed programming languages Free data analysis software
Free data visualization software Free software projects Free statistical software
Functional languages High-level programming languages
Numerical analysis software for Linux Numerical analysis software for MacOS
Numerical analysis software for Windows Numerical linear algebra
Numerical programming languages Object-oriented programming languages
Parallel computing Programming languages created in 2012 Software using the MIT license
Statistical programming languages

https://en.wikipedia.org/wiki/Julia_(programming_language)[04/04/2017 2:17:59 PM]

Julia (programming language) - Wikipedia

This page was last modified on 30 March 2017, at 08:40.

Text is available under the Creative Commons Attribution-ShareAlike License;
additional terms may apply. By using this site,
you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc., a
non-profit organization.
Privacy policy About Wikipedia Disclaimers Contact Wikipedia Developers Cookie statement Mobile view

https://en.wikipedia.org/wiki/Julia_(programming_language)[04/04/2017 2:17:59 PM]