
Out in the Open: Man Creates One Programming Language to Rule Them All - superasn
http://www.wired.com/2014/02/julia/
======
sveme
Here's the previous discussion:
[https://news.ycombinator.com/item?id=7171126](https://news.ycombinator.com/item?id=7171126)

It's a nine months old story. And the hyperbole in the title has been
thoroughly acknowledged in that discussion as well.

------
scott_s
Opening line: "Stefan Karpinski was building a software tool that could
simulate the behavior of wireless networks, and his code was a complete mess.
But it wasn’t his fault."

Interestingly, it was Bjarne Stroustrup's experience implementing a
distributed system simulator in Simula that lead to him working on what became
C++. He liked the architecture of the code, but it was too slow for him to get
any results. He reimplemented the whole thing in BCPL, and that experience got
him interested in having a fast language that provided Simula-like
abstractions.

I originally read this anecdote in his book "The Design and Evolution of C++",
but it's also in the beginning of his History of Programming Languages paper:
[http://www.stroustrup.com/hopl2.pdf](http://www.stroustrup.com/hopl2.pdf)

------
coding4all
Julia is interesting for sure, but I think Clojure has had more of an impact
in terms of what the future of languages might look like. I would argue the
same for Rust as well.

~~~
michaelochurch
I agree on Clojure. Rust I'd need to know more about, but I may study it now
that it's post-1.0.

What do you think about Haskell's impact on the future? I think that static
typing, although less popular as of now, could make a resurgence given the
value it adds once one learns how to use the type system.

Most of the negative reputation of static typing, I'd argue, comes from
languages that are falling out of favor (C++, Java) and that never did static
typing right in the first place.

~~~
coding4all
TLDR; Optional type systems are the future

I hear a lot about Haskell but I don't see a lot about Haskell...

Clojure has two optional type systems known as the core.typed library, and
Prismatic's schema library. I don't think it's an all or nothing situation.
Use types when you need them and don't when you don't.

~~~
codygman
You are overlooking how powerful programming with types can be. This applies
to Haskell, but even moreso to languages like Idris.

Did you hear about Haxl[0]?

[0]:
[https://code.facebook.com/projects/854888367872565/haxl/](https://code.facebook.com/projects/854888367872565/haxl/)

~~~
coding4all
You're overlooking my entire comment...

~~~
codygman
No I'm not, but I guess there was a possibility of you thinking that. Let's
erase all ambiguity.

> TLDR; Optional type systems are the future

Optional type systems have their place, but I think you are ignoring
applications that types can have besides type assertion and documentation.

> I hear a lot about Haskell but I don't see a lot about Haskell...

It's a shame you haven't "seen" Haskell and have only heard about it, I know
how that can make the entire language seem like vaporware. I personally have
seen at least one big thing from a large company that used Haskell. I'm
guessing you didn't see Facebook's semi-recent release of Haxl[0].

> Clojure has two optional type systems known as the core.typed library, and
> Prismatic's schema library. I don't think it's an all or nothing situation.
> Use types when you need them and don't when you don't.

Optional typing is cool, but it's not useful for type based programming since
it makes types optional. You can do some cool stuff by programming types.
Haskell does some of this, but Idris[1] does much more by taking advantage of
dependent typing[2].

------
danso
The comments in the OP pretty much state the skepticism that I feel...but let
me limit my layperson's cynicism:

> _Stefan Karpinski was building a software tool that could simulate the
> behavior of wireless networks, and his code was a complete mess. But it
> wasn’t his fault._

 _As a computer science grad student with years of industry experience under
his belt, Karpinski was far from a programming novice. He knew how to build
software. The problem was that in order to build his network simulation tool,
he needed four different programming languages. No single language was suited
to the task at hand, but using four languages complicated everything from
writing the code to debugging it and patching it._

Is the code for this simulation open-source? I'm not sure what that simulation
entails, to need four different languages to effectively implement it...but I
would definitely be interested in reading some specifics on what these
languages are (or at least, the domains that they pertain to) and in which
ways Julia adequately fulfilled their roles (I'm going to assume that Julia
wasn't the flat-out best language across all the roles...though really, that's
what the OP's headline leads me to believe...)

I'm mostly a Rubyist. I hope Julia is faster than Ruby (what _isn 't?_)...but
is it as easy to read and write, and does it serve well as a glue language?

~~~
mynegation
Not simulation, but here is my example from finance which does things pretty
similar to those in technical computing. First you want to prototype things
and see what works. You need low-overhead fast iteration interpreted language
with good graphing abilities. This is usually Excel, sometimes Matlab, R, or
Python. The solution that you get does not scale, so you roll up your sleeves
and re-implement calculations in C++, C#, or Java (and in some cases more
exotic languages like F#, Haskell or OCaml). Then you need to present these
results to users, which means you need Visual Basic or C# to integrate that
back into Excel, or C# or Java (or maybe Python) to build a standalone desktop
GUI application or web application. At this point build and deployment is
supported by a bunch of other technologies, like Makefiles, batch scripts,
maven files and what not.

~~~
tjradcliffe
A large part of this is discipline and knowledge.

There is nothing to stop you from writing a nice-looking, fast app in C++. I
routinely do this kind of thing in a mix of C++ and Python because wxPython
makes it easier to throw together a UI, but the development overhead for doing
it in C++ is relatively small.

There are very few algorithms in Matlab or R that you can't find in decent
libs for C++, so translating is no big deal given you're going that way
anyway.

The question is: are we better to put resources into new special-purpose,
highly-optimized-for-a-single-type-of-job languages like Julia (which for some
reason the article talks about as universal, then admits at the end it is
totally special purpose and unsuited for a whole bunch of applications)... or
are we better off learning to use the tools we have with greater discipline?

I generally opt for the latter. Changing our behaviour as developers will
produce better results than building new tools. We have the tools to manage
our processes now (CMake, for example, rather than Makefiles). We need to be
disciplined about using them. If we aren't, no new tools will help that much.

------
washedup
Anyone on here have day-to-day experience using Julia? If so, what do you use
it for? What languages are you supplementing with Julia?

~~~
andrewflnr
I've been using it to to play with fractals and other procedural graphics.
I've enjoyed it. The only thing that was slightly unpleasant (besides growing
pains and REPL startup time) was getting used to 1-based indices.

------
progx
[http://xkcd.com/927/](http://xkcd.com/927/)

now we have 5 programming languages ;)

------
dchichkov
>> As a computer science grad student with years of industry experience under
his belt, Karpinski was far from a programming novice. He knew how to build
software.

Probably was coding as a kid. And according to his resume his first
professional (money paid) part-time job was in 1996, coding in
C/ALGOL/C++/Perl. That is close to 20 years. Reasonable enough. People tend to
keep it simple and not design overly complicated things when they've been
doing something for 20 years.

A style guide page here gives a good feel of the language:
[http://julia.readthedocs.org/en/latest/manual/style-
guide/](http://julia.readthedocs.org/en/latest/manual/style-guide/)

Compare with Python:
[http://www.python.org/dev/peps/pep-0008/](http://www.python.org/dev/peps/pep-0008/)

And, say, Ocaml:
[http://caml.inria.fr/resources/doc/guides/guidelines.en.html](http://caml.inria.fr/resources/doc/guides/guidelines.en.html)

------
mcphage
>He and several other computer scientists are building a new language they
hope will be suited to practically any task. [...] What we need, Karpinski
realized after struggling to build his network simulation tool, is a single
language that does everything well.

a few paragraphs later:

> That said, it isn’t for everyone. Bezanson says it’s not exactly ideal for
> building desktop applications or operating systems, and though you can use
> it for web programming, it’s better suited to technical computing.

So he made one language that's good for everything, as long as everything
doesn't include desktop apps, operating systems, or web apps? That's a pretty
big lacuna...

------
lallysingh
Am I the only one who saw the title and thought Perl 6?

~~~
Stubb
Yes.

------
mwfogleman
"Julia is also designed parallelism."

------
stewbrew
For whatever reason, I expected the article to be about haxe -- one language
that transpiles to everything.

------
ColinWright
So, apparently Julia is the "One True Language."

~~~
norswap
One does not simply code C in Mordor.

~~~
paulmd
Nope, legacy code base. FORTRAN.

~~~
qznc
In Middle-Earth Mordor is the progressive nation, which (together with
Isengard) is inventing industrialization. Gondor, Rohan and the elves are the
conservative faction. ;)

~~~
fractallyte
...and, just to back up your comment, here's The Book that tells that side of
the story:
[http://ymarkov.livejournal.com/280578.html](http://ymarkov.livejournal.com/280578.html)

------
ilaksh
Don't know what happened. Think someone deleted my comment. What I said was we
need a common metalanguage or knowledge representation for algorithms that can
be translated to different programing languages.

~~~
JetSpiegel
LLVM IR?

~~~
ilaksh
Yes similar but generally higher level where possible.

------
malux85
[http://imgs.xkcd.com/comics/standards.png](http://imgs.xkcd.com/comics/standards.png)

------
tempodox
If it were only true! But the way Julia is tied in (REPL _ONLY_ ), it's
nothing more than a _lab tool_ for number crunchers. And the developers don't
plan to make Julia create stand-alone binary executables (R or Matlab users
wouldn't expect that). That's a deal breaker for me.

(Edit: Typo)

~~~
sveme
Where do you get that from? Stefan Karpinski actually claimed quite the
opposite:

[https://groups.google.com/d/topic/julia-
users/rttSG6_pAiA/di...](https://groups.google.com/d/topic/julia-
users/rttSG6_pAiA/discussion)

~~~
tempodox
I will believe it just as soon as I see it. Until then, I prefer to remain
skeptical.

~~~
sveme
Well, first you're stating that they don't plan it, then you're called out,
now you're simply stating that you remain sceptical. That's pretty poor.

~~~
tempodox
Touché.

