.. _man-getting-started:
*****************
Getting Started
*****************
Julia installation is straightforward, whether using precompiled
binaries or compiling from source. Download and install Julia by
following the instructions at
`http://julialang.org/downloads/ `_.
The easiest way to learn and experiment with Julia is by starting an
interactive session (also known as a read-eval-print loop or "repl")::
$ julia
_
_ _ _(_)_ | A fresh approach to technical computing
(_) | (_) (_) | Documentation: http://docs.julialang.org
_ _ _| |_ __ _ | Type "help()" to list help topics
| | | | | | |/ _` | |
| | |_| | | | (_| | | Version 0.3.0-prerelease+3690 (2014-06-16 05:11 UTC)
_/ |\__'_|_|_|\__'_| | Commit 1b73f04* (0 days old master)
|__/ | x86_64-apple-darwin13.1.0
julia> 1 + 2
3
julia> ans
3
To exit the interactive session, type ``^D`` — the control key
together with the ``d`` key or type ``quit()``. When run in interactive
mode, ``julia`` displays a banner and prompts the user for input. Once
the user has entered a complete expression, such as ``1 + 2``, and
hits enter, the interactive session evaluates the expression and shows
its value. If an expression is entered into an interactive session
with a trailing semicolon, its value is not shown. The variable
``ans`` is bound to the value of the last evaluated expression whether
it is shown or not. The ``ans`` variable is only bound in interactive
sessions, not when Julia code is run in other ways.
To evaluate expressions written in a source file ``file.jl``, write
``include("file.jl")``.
To run code in a file non-interactively, you can give it as the first
argument to the julia command::
$ julia script.jl arg1 arg2...
As the example implies, the following command-line arguments to julia
are taken as command-line arguments to the program ``script.jl``, passed
in the global constant ``ARGS``. ``ARGS`` is also set when script code
is given using the ``-e`` option on the command line (see the ``julia``
help output below). For example, to just print the arguments given to a
script, you could do this::
$ julia -e 'for x in ARGS; println(x); end' foo bar
foo
bar
Or you could put that code into a script and run it::
$ echo 'for x in ARGS; println(x); end' > script.jl
$ julia script.jl foo bar
foo
bar
Julia can be started in parallel mode with either the ``-p`` or the
``--machinefile`` options. ``-p n`` will launch an additional ``n``
worker processes, while ``--machinefile file`` will launch a worker
for each line in file ``file``. The machines defined in ``file`` must be
accessible via a passwordless ``ssh`` login, with Julia installed at the
same location as the current host. Each machine definition takes the form
``[user@]host[:port] [bind_addr]`` . ``user`` defaults to current user,
``port`` to the standard ssh port. Optionally, in case of multi-homed hosts,
``bind_addr`` may be used to explicitly specify an interface.
If you have code that you want executed whenever julia is run, you can
put it in ``~/.juliarc.jl``:
.. raw:: latex
\begin{CJK*}{UTF8}{mj}
::
$ echo 'println("Greetings! 你好! 안녕하세요?")' > ~/.juliarc.jl
$ julia
Greetings! 你好! 안녕하세요?
...
.. raw:: latex
\end{CJK*}
There are various ways to run Julia code and provide options, similar to
those available for the ``perl`` and ``ruby`` programs::
julia [options] [program] [args...]
-v, --version Display version information
-h, --help Print this message
-q, --quiet Quiet startup without banner
-H, --home
Set location of julia executable
-e, --eval Evaluate
-E, --print Evaluate and show
-P, --post-boot Evaluate right after boot
-L, --load Load right after boot on all processors
-J, --sysimage Start up with the given system image file
-p Run n local processes
--machinefile Run processes on hosts listed in
-i Force isinteractive() to be true
--no-history-file Don't load or save history
-f, --no-startup Don't load ~/.juliarc.jl
-F Load ~/.juliarc.jl, then handle remaining inputs
--color={yes|no} Enable or disable color text
--code-coverage Count executions of source lines
--check-bounds={yes|no} Emit bounds checks always or never (ignoring declarations)
--int-literals={32|64} Select integer literal size independent of platform
Resources
---------
In addition to this manual, there are various other resources that may
help new users get started with julia:
- `Julia and IJulia cheatsheet `_
- `Learn Julia in a few minutes `_
- `Tutorial for Homer Reid's numerical analysis class `_
- `An introductory presentation `_
- `Videos from the Julia tutorial at MIT `_
- `Forio Julia Tutorials `_