_      
   _       _ _(_)_     |
  (_)     | (_) (_)    | A fresh approach to technical computing 
   _ _   _| |_  __ _   | 
  | | | | | | |/ _` |  | 
  | | |_| | | | (_| |  | Web: https://github.com/JuliaLang/julia
 _/ |\__'_|_|_|\__'_|  | Mailing list: [email protected]
|__/                   |

Compiling
---------

Required tools: gcc, g++, gfortran, curl, gnu make
Supported platforms: GNU/Linux on x86 and x86/64, Mac OS X on x86/64

Run "make" in external/ to download and build external dependencies.

Run "make" in the top-level directory to build julia.

No installation is necessary; julia can be run from the directory where
it was built.


Directories
-----------

contrib/       emacs and textmate support for julia
doc/           TeX manual and other notes
external/      external dependencies
j/             source code for julia's standard library
lib/           shared libraries loaded by julia's standard libraries
src/           source for julia language core
ui/            source for various frontends
test/          some tests


Emacs setup
-----------

Add the following line to ~/.emacs

(require 'julia-mode "JULIA_PATH/contrib/julia-mode.el")

where JULIA_PATH is the location of the top-level julia directory.


Brief introduction
------------------

Julia is a very high level dynamic language with good performance,
implemented as a JIT compiler using the LLVM toolchain.
Julia is multi-paradigm, combining features of functional, object-oriented,
and imperative languages. The primary unifying feature is multiple dispatch:
defining functions on different combinations of datatypes, and defining
new datatypes. Operators are functions. This model fits mathematical
programming well, where it is most common to define new functions on
existing datatypes, and it is not natural for one datatype to "own" an
operation (as in typical single-dispatch OO languages). The compiler uses
type inference to eliminate dispatch overhead where possible.

Advantages of julia over other comparable systems are as follows:

- Consistent and powerful generic function model
- High performance
- Better performance for user-defined types
- Low syntactic overhead to define new types
- Redefinable low-level behavior
- High-level constructs for parallelism
- Free and open source
- Multi-dimensional array comprehensions
- Coroutines and cooperative threading
- Rich type system
- Better handling of numeric types
- Macros
- Powerful shell-like capabilities for managing other processes


Rationale
---------

Scientific computing has traditionally required the highest performance,
yet domain experts have largely moved to slower dynamic languages for
daily work. We believe there are many good reasons to prefer dynamic languages
for these applications, and we don't expect their use to diminish any time
soon. Fortunately, modern language design and compiler techniques make it
possible to mostly eliminate the performance trade-off and provide a
single environment productive enough for prototyping and performant enough
for deploying applications. However, an open-source language with these
characteristics has not emerged. Our project, Julia, fills this gap.

MATLAB generally dominates the field of programming languages for the
applied sciences. We take note of some of the reasons for its success:
it is well-suited to linear algebra and array manipulation, easy to use, and
achieves impressive performance due to a JIT compiler (introduced in 2003).
Several open source systems (Python/NumPy, R, Octave, SciLab) offer comparable
advantages, but in particular have not kept up in the last category.

Closing this performance gap is a primary goal of ours, but at the same time
we feel there is room to increase power, flexibility, and simplicity.
The rising importance of parallel computing and cloud computing provides
further motivation to design a new system with those concerns in mind from
the beginning.