Julia Language is a simple application for technical calculations and has a fairly minimalist interface and simple terminal code line type.
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 do not expect their use to diminish. 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 efficient enough for deploying performance-intensive applications. The Julia programming language fills this role: it is a flexible dynamic language, appropriate for scientific and numerical computing, with performance comparable to traditional statically-typed languages.
Because Julias compiler is different from the interpreters used for languages like Python or R, you may find that Julias performance is unintuitive at first. If you find that something is slow, we highly recommend reading through the Performance Tips section before trying anything else. Once you understand how Julia works, its easy to write code thats nearly as fast as C.
Julia features optional typing, multiple dispatch, and good performance, achieved using type inference and just-in-time (JIT) compilation, implemented using LLVM. It is multi-paradigm, combining features of imperative, functional, and object-oriented programming. Julia provides ease and expressiveness for high-level numerical computing, in the same way as languages such as R, MATLAB, and Python, but also supports general programming. To achieve this, Julia builds upon the lineage of mathematical programming languages, but also borrows much from popular dynamic languages, including Lisp, Perl, Python, Lua, and Ruby.
* Free and open source (MIT licensed)
* User-defined types are as fast and compact as built-ins
* No need to vectorize code for performance; devectorized code is fast
* Designed for parallelism and distributed computation
* Lightweight green threading (coroutines)
* Unobtrusive yet powerful type system
* Elegant and extensible conversions and promotions for numeric and other types
* Efficient support for Unicode, including but not limited to UTF-8
* Call C functions directly (no wrappers or special APIs needed)
* Powerful shell-like capabilities for managing other processes
* Lisp-like macros and other metaprogramming facilities
Thus, arithmetic with Julia integers is actually a form of modular arithmetic. This reflects the characteristics of the underlying arithmetic of integers as implemented on modern computers. In applications where overflow is possible, explicit checking for wraparound produced by overflow is essential; otherwise, the BigInt type in Arbitrary Precision Arithmetic is recommended instead.
FLOATING-POINT NUMBERS 35
> julia> x = typemax(Int64)
> julia> x + 1
> julia> x + 1 == typemin(Int64)
Screenshots Julia Language
Video Julia Language