If you are thinking about taking Julia, the hot new mathematical, statistical, and data-oriented programming language, for a test drive, you might need a little bit of help. In this blog we round up some great posts discussing various aspects of Julia to get you up and running faster.
Why We Created Julia
If only you could always read through the intentions and thoughts of the creators of a language! With Julia you can. Jump over to here to get the perspectives of four of the original developers, Jeff Bezanson, Stefan Karpinski, Viral Shah, and Alan Edelman.
We are power Matlab users. Some of us are Lisp hackers. Some are Pythonistas, others Rubyists, still others Perl hackers. There are those of us who used Mathematica before we could grow facial hair. There are those who still can’t grow facial hair. We’ve generated more R plots than any sane person should. C is our desert island programming language.
We love all of these languages; they are wonderful and powerful. For the work we do — scientific computing, machine learning, data mining, large-scale linear algebra, distributed and parallel computing — each one is perfect for some aspects of the work and terrible for others. Each one is a trade-off.
We are greedy: we want more.
An IDE for Julia
If you are looking for an IDE for Julia, check out the Julia Studio. Even better, Forio, the makers of this IDE, offer a nice series of beginner, intermediate, and advanced tutorials to help you get up and running.
Julia Documentation
By far the most comprehensive and best source of help and information on Julia are the ever growing Julia Docs which includes a Manual for the language (with a useful getting started guide), details of the Standard Library, and an overview of available packages. Not to be missed are the two sections detailing noteworthy differences between Matlab and R.
MATLAB, R, and Julia: Languages for Data Analysis
Avi Bryant provides a very nice overview and comparison of Matlab, R, Julia, and Python. Definitely recommended reading if you are considering a new data analysis language.
An R Programmer Looks at Julia
This post is from mid-2012 so a lot has changed with Julia. However, it is an extensive look at the language from an experienced R developer.
There are many aspects of Julia that are quite intriguing to an R programmer. I am interested in programming languages for “Computing with Data”, in John Chambers’ term, or “Technical Computing”, as the authors of Julia classify it. I believe that learning a programming language is somewhat like learning a natural language in that you need to live with it and use it for a while before you feel comfortable with it and with the culture surrounding it. Read more …
The State of Statistics in Julia – Late 2012
Continuing on this theme of statistics and Julia, John Myles White provides a great view of using Julia for statistics which he updated in December of last year.
A Matlab Programmer’s Take on Julia – Mid 2012
A quick look at Julia from the perspective of a Matlab programmer and pretty insightful as well.
Julia is a new language for numerical computing. It is fast (comparable to C), its syntax is easy to pick up if you already know Matlab, supports parallelism and distributed computing, has a neat and powerful typing system, can call C and Fortran code, and includes a pretty web interface. It also has excellent online documentation. Crucially, and contrary to SciPy, it indexes from 1 instead of 0. Read more …
Why I am Not on the Julia Bandwagon Yet
Finally, we leave you, good reader, with a contrarian view point.
Why We Created Julia
Source: http://julialang.org/blog/2012/02/why-we-created-julia/
In short, because we are greedy.
We are power Matlab users. Some of us are Lisp hackers. Some are Pythonistas, others Rubyists, still others Perl hackers. There are those of us who used Mathematica before we could grow facial hair. There are those who still can’t grow facial hair. We’ve generated more R plots than any sane person should. C is our desert island programming language.
We love all of these languages; they are wonderful and powerful. For the work we do — scientific computing, machine learning, data mining, large-scale linear algebra, distributed and parallel computing — each one is perfect for some aspects of the work and terrible for others. Each one is a trade-off.
We are greedy: we want more.
We want a language that’s open source, with a liberal license. We want the speed of C with the dynamism of Ruby. We want a language that’s homoiconic, with true macros like Lisp, but with obvious, familiar mathematical notation like Matlab. We want something as usable for general programming as Python, as easy for statistics as R, as natural for string processing as Perl, as powerful for linear algebra as Matlab, as good at gluing programs together as the shell. Something that is dirt simple to learn, yet keeps the most serious hackers happy. We want it interactive and we want it compiled.
(Did we mention it should be as fast as C?)
While we’re being demanding, we want something that provides the distributed power of Hadoop — without the kilobytes of boilerplate Java and XML; without being forced to sift through gigabytes of log files on hundreds of machines to find our bugs. We want the power without the layers of impenetrable complexity. We want to write simple scalar loops that compile down to tight machine code using just the registers on a single CPU. We want to write A*B and launch a thousand computations on a thousand machines, calculating a vast matrix product together.
We never want to mention types when we don’t feel like it. But when we need polymorphic functions, we want to use generic programming to write an algorithm just once and apply it to an infinite lattice of types; we want to use multiple dispatch to efficiently pick the best method for all of a function’s arguments, from dozens of method definitions, providing common functionality across drastically different types. Despite all this power, we want the language to be simple and clean.
All this doesn’t seem like too much to ask for, does it?
Even though we recognize that we are inexcusably greedy, we still want to have it all. About two and a half years ago, we set out to create the language of our greed. It’s not complete, but it’s time for a 1.0 release — the language we’ve created is calledJulia. It already delivers on 90% of our ungracious demands, and now it needs the ungracious demands of others to shape it further. So, if you are also a greedy, unreasonable, demanding programmer, we want you to give it a try.
Download and Install Julia on Various Operating Systems
Source: http://julialang.org/downloads/#beta
Current version: release v0.1.2 | beta v0.2-pre
My Note: I downloaded Release v0.1.2 (147 MB)
Release v0.1.2
| Windows Archive (.zip) | 32-bit | 64-bit |
|---|---|---|
| Mac OS X Package (.dmg) | 64-bit | |
| Source (Git) | git@github.com:JuliaLang/julia -b release0.1 | |
Beta v0.2-prerelease
| Windows Self-Extracting Archive (.exe) | 32-bit | 64-bit |
|---|---|---|
| Mac OS X Package (.dmg) | 64-bit | |
| Linux packages | Ubuntu | |
| Source (Git) | git@github.com:JuliaLang/julia | |
If the provided download files do not work for you, please file an issue.
Platform Specific Instructions
Windows
Julia is available for both 32-bit and 64-bit Windows since XP SP3.
- Download the Windows julia.exe installer for your platform. 32-bit julia works on both x86 and x86_64. 64-bit julia will only run on 64-bit Windows (x86_64).
- Run the downloaded program to extract julia
- Double-click julia.bat in the unpacked folder to start julia
The Windows README contains information on dependencies.
Uninstallation is performed by deleting the extracted directory. If you would also like to remove your preferences files, they can be found in your user directory at %APPDATA%/julia; this is typically expanded to %USERHOME%/Application Data/Roaming/julia.
OS X
On Mac, a Julia-version.dmg file is provided, which contains Julia.app. Installation is the same as any other Mac software — copy the Julia.app to your hard-drive (anywhere) or run from the disk image. OS X Lion (10.7) or later are required to be able to use the precompiled binaries. OS X Snow Leopard (10.6) has also been reported to work, but it may not work in all cases. In such cases, you may need to build from source.
Uninstall Julia by deleting Julia.app and the packages directory in ~/.julia. Multiple Julia.app binaries can co-exist without interfering with each other. If you would also like to remove your preferences files, remove ~/.juliarc.jl.
Linux
Instructions will be added here as more linux distributions start including julia. If your Linux distribution is not listed here, you should still be able to run julia by building from source. See the Julia README for more detailed information.
- Ubuntu 13.04: apt-get install julia
Uninstallation is platform dependent. If you did a source build, it can be performed by deleting your julia source folder. If you would also like to remove your preferences files, they are ~/.julia and ~/.juliarc.jl.
Beta installation instructions
A PPA (Personal Package Archive) is provided for Ubuntu systems to allow for automatic updating to the latest beta version of Julia. To use this PPA and install julia on Ubuntu 12.04 or later, simply type:
$ sudo add-apt-repository ppa:staticfloat/julianightlies
$ sudo add-apt-repository ppa:staticfloat/julia-deps
$ sudo apt-get update
$ sudo apt-get install julia
Add graphics capabilities to Julia
Graphics in Julia are available through external packages. These packages are under heavy development and take different approaches towards graphics and plotting.
Gaston
Gaston provides an interface to gnuplot. Gaston also includes detailed documentation and examples in its manual. Add the Gaston package to your Julia installation with the following commond on the Julia prompt:
Pkg.add("Gaston")using GastonGaston.set_terminal("aqua")#(this may be necessary, if the following reports that your terminal type is unknown)x=-pi:.001:pi; y=x.*sin(10./x); plot(x,y)#(plotx*sin(10/x))
In order to use Gaston, you will need to install gnuplot and ensure it is accessible from ENV[“PATH”] within Julia. Gnuplot is widely used, and binaries are available for all platforms.
Winston
Winston provides 2D plotting capabilities for Julia. Add the Winston package to your Julia installation with the following command on the Julia prompt:
Pkg.add("Winston")using Winstonplot( cumsum(randn(1000)) )#(plot a random walk)
Winston’s interface will be familiar to MATLAB users. See examples and documentation on the Winston homepage.
Gadfly
Gadfly is an implementation of a Wickham-Wilkinson style grammar of graphics in Julia. Add the Gadfly package to your Julia installation with the following command on the Julia prompt:
Pkg.add("Gadfly")using Gadflydraw(SVG("output.svg", 6inch, 3inch), plot([sin, cos], 0, 25))#(plot a pair of simple functions over a range)
Gadfly’s interface will be familiar to users of R’s ggplot2 package. See examples and documentation on the Gadfly homepage.
Comments