Mike Innes gave a talk/demo of this at the Boston/Cambridge Julia meetup [1] last night and it was really impressive. Some highlights:

- interactive sliders to manipulate input parameters

- support for inline plots (like IJulia)

- very nice code completion

[1] http://www.meetup.com/julia-cajun/

It was one of the more interesting meetups I've ever been to. There is a lot of interesting stuff going on with Julia right now.

For example, the pretty picture in the header of the Juno page is also a Julia project. Yuri Vishnevsky gave a lightning talk about his graphics demo at the same meetup last night. See [1] and [2] for more about that.

[1] https://www.youtube.com/watch?v=aML8nQlaJ6E&noredirect=1

[2] https://github.com/yurivish/Julia-Playground

Yeah, it was exciting. The Julia ecosystem is growing quickly. A few months ago I could more-or-less keep up with all of the issues on most of the important packages, but doing so now feels impossible. A lot of new packages are still at the "it works for me" stage, but there is an amazing range of things in development and maturity will come with time.

Beyond the main LightTable presentation and the generative art you mentioned, there were also lightning talks on:

- calling JITed C++ from the Julia REPL with Clang [1].

- spectrograms, audio playback, and tone generation with interactive manipulation from IJulia [2].

- Kalman filters [3]

[1] https://github.com/Keno/Cxx.jl [2] https://github.com/ssfrr/AudioIO.jl [3] https://github.com/wkearn/Kalman.jl

Pity I didn't know about this, I live in Cambridge. Do you know if his talk was recorded?

Unfortunately not. There was a Mathematica-in-Julia-in-LightTable cameo which you might have found amusing. Maybe we can record in the future, but having everything be informal and low pressure gave it a really fun feeling.

Julia's been on my to-check-out list for a very long time, as has LightTable. It took me less than five minutes on a brand new machine to install the dependencies and get it working.

This is really impressive.

It is also easy to build from source. Their build system gets all the dependencies for you. It takes a little while to build but it is simple.

This is great, as it really lowers the barrier of entering Julia.

It also offers a level of exploration (with the in-place results), which is a neat thing for students – I've found that interactive environments generate interesting solutions to otherwise boring problems. I'm currently trying to replace Matlab as the language I use in our university's Probability class and Juno adds to "why use Julia" argument :)

Thanks!

Is there a video somewhere of someone using this? I'd love to see this in action, without having to install it myself and read a bunch of docs to see what it's good at.

Not yet, but some kind of demo and an easy installer are definitely on the todo list.

What's the license? I couldn't find any mention of a license anywhere. Lighttable itself seems to be GPLv3, so I assume its plugins are too?

That's right, all my Light Table plugins are GPL, my Julia packages are MIT. (My bad for not mentioning this in the right places, I'll fix that.)

I did not know this programming language and found it very interesting. mainly because it is similar to Python.

> I did not know this programming language

There have been numerous articles linked to HN about Julia, I suggest you check in more ;)

This looks really cool, I've played with Julia a bit, but a Light Table introduction might be just the thing to make me dive deeper into Julia and start trying out Light Table a bit.

Except the reference implementation uses a JIT and is really fast.

Still waiting for PyPy to eventually replace CPython as the reference implementation. Even though they still have a bit of catching up to do.

WARNING: Can't handle command editor.block

This is what I get on Linux 64bit and Julia git build when I press Ctrl-Enter to evaluate the line. Any ideas?

Most likely you have an outdated version of the package, try Pkg.update() from the Julia repl.

Yep, now it works

Couldn't get it to work: Couldn't connect to Julia

INFO: Couldn't find Jewel package, attempting installation... ----------------------------------------------- We couldn't install Jewel.jl for you. Try using Pkg.add("Jewel") in a Julia repl.

Probably you have old ```.julia``` folder. Remove it and try again

Awesome, that fixed my issue, thank you

I tried the plot(sin, 0, 2) example and got "plot not defined".

Edit: This http://junolab.org/docs/notes.md also returns a 404.

For plotting you'll need a plotting package – I recommend Gadfly [1]. I should definitely make the docs clearer for people who haven't used Julia before.

That should be notes.html, I'll go ahead and fix that.

[1] https://github.com/dcjones/Gadfly.jl

Is that one of those "all the RGB colors" images in the header?

It is – generated in Julia, of course.

See [1] for to Yuri's code for this (I actually used my own, but his is way better).

[1]: https://github.com/yurivish/Julia-Playground

Intellisense sometime does not work:

Case 1: exp = :(a + b * c + 1)

--> exp. shows head, args, and typ

but --> typeof(exp.) no suggestions.

Case 2:

type Person fName lName end

me = Person("", "")

--> me. not working --> println(me.) not working

Cannot submit issue on Github.

Wow, this looks fantastic. Julia keeps on getting better and better. I can't wait to use it for a 'real' project (hopefully that will be soon!).

Is there a succinct rundown of differences between Julia and R? As in, why would you use one over the other. Thanks!

Julia is generally a more powerful and thoughtfully designed language, so it's great if you want to do your own thing. If you're writing libraries or bespoke algorithms in R and finding yourself struggling for performance, Julia is already a great alternative to R + C (same for Python + C etc.)

At the same time, R's ecosystem is huge and a lot more mature than Julia's, so for the average user who just wants to pull in data and plot it, etc., it's a far better choice.

R is similar to APL with a lot of Scheme influence. Values are all vectors, functions automatically map over vectors, etc...

Julia is more like Python or Ruby, and not quite as data-oriented as R, but feels a little more like a general purpose language...