

Videos from the Julia tutorial at MIT - ViralBShah
http://julialang.org/blog/2013/03/julia-tutorial-MIT/

======
shared4you
Couple more suggestions:

1\. In the REPL, highlighting of matching parenthesis/brackets (like in CLISP)
would be good.

2\. In the top-level Makefile, add a target "make distclean" to mean "make
cleanall". distclean is the "GNU standard" [1]. Similarly "make mostlyclean"
could clean everything except major dependencies.

[1]
[http://www.gnu.org/software/make/manual/html_node/Standard-T...](http://www.gnu.org/software/make/manual/html_node/Standard-
Targets.html)

~~~
ViralBShah
These are both good points.

We did use to have a distclean, but seems to have been lost in various build
system updates.

Matching parentheses/brackets in the REPL would be really nice too. Can one do
this with readline? It would be great if you could file an issue - just trying
to nudge you into joining the fun. :-)

~~~
shared4you
I created a GitHub account just for Julia, and the issue 2738 is here:
<https://github.com/JuliaLang/julia/issues/2738>

------
lincolnq
Julia is a huge step forward in practical programming languages. I was super
impressed when I saw it at Strange Loop last year, and they've made strides
since then.

------
shared4you
I just saw that you have a run() command for invoking the shell. Would be cool
to just use ! (like Matlab) or %%! (like IPython).

BTW, the lightning round is awesome. Thanks विराळ् :)

~~~
StefanKarpinski
The ! operator already has a meaning, which is negation. There are also many
different ways to run pipelines: `run` just runs it, letting output pass
through to stdout/stderr and returning nothing, but raising an error if the
process fails; `success` suppresses process output and returns true or false
based on the return status of the pipeline; there are also various ways of
reading from and writing to pipelines, or starting pipelines asynchronously
and letting them run in the background. So using ! for just one of these many
ways of running external programs seems short-sighted.

~~~
ViralBShah
Within `run`, you still can use nice syntactic sugar such as `|` for pipes.
BTW, almost correct rendering of my name in Devanagari! :-)

------
klrr
Julia looks a bit like Lua.

~~~
StefanKarpinski
There are superficial similarities. The main things that make Julia different
than other dynamic languages are:

    
    
      1. The expressive, sophisticated type system
      2. Using multiple dispatch as its core paradigm
      3. Extreme interoperability with C libraries
      4. C-like performance
    

Of course, LuaJIT gets great performance too, so that's actually rather
similar to Lua. Lua also isn't nearly as naturally suited to scientific
programming.

~~~
BruceM
Those 4 bullet points all sound a lot like Dylan (<http://opendylan.org/>).

I'd have said Common Lisp as well, but some might argue point #1 with respect
to that.

It is nice to see others (re-)discovering the joy of full on multiple dispatch
though!

~~~
pjmlp
Reading the new Dylan documentation makes me wonder how if would have turned
out if Apple invested more strongly in the language.

An expressive dynamic language with repl and native code compilers. quite
nice.

The one thing so far that I don't like is <> around identifiers.

~~~
cgay
< > is a naming convention for types (e.g., classes) only.

~~~
pjmlp
I know, but still makes the code ugly to my liking.

