I recently came across this article http://www.wired.com/2014/02/julia/. On the Julia homepage there are some benchmarks times relative to C. I know that bearophile has mentioned Julia several times on this forum. Has anyone compared D's vs Julia's performance as well as design features?

On Tuesday, 6 May 2014 at 09:11:30 UTC, Chris wrote:
> I recently came across this article http://www.wired.com/2014/02/julia/. On the Julia homepage there are some benchmarks times relative to C. I know that bearophile has mentioned Julia several times on this forum. Has anyone compared D's vs Julia's performance as well as design features?

I can only comment on design features.

You can think of Julia as a dynamic language similar to Python, with optional typing and for such a young language, a quite good JIT compiler backed by the LLVM backend.

It is a multi-paradigm language, with an OO approach based on multi-methods and direct support for scientific programming.

The target audience are the scientifc community that makes use of R, Python with NumPy and so on, which are currently disappointed with the performance of said systems. Their goal is to keep the programming flexibility of R and Python, while improving the performance without having to be forced to write C code.

--
Paulo

Paulo Pinto:

> You can think of Julia as a dynamic language similar to Python, with optional typing and for such a young language, a quite good JIT compiler backed by the LLVM backend.

Unlike dynamic languages, at running time all variables are strongly typed.

Bye,
bearophile

On Tuesday, 6 May 2014 at 11:20:33 UTC, Paulo Pinto wrote:
> On Tuesday, 6 May 2014 at 09:11:30 UTC, Chris wrote:
>> I recently came across this article http://www.wired.com/2014/02/julia/. On the Julia homepage there are some benchmarks times relative to C. I know that bearophile has mentioned Julia several times on this forum. Has anyone compared D's vs Julia's performance as well as design features?
>
> I can only comment on design features.
>
> You can think of Julia as a dynamic language similar to Python, with optional typing and for such a young language, a quite good JIT compiler backed by the LLVM backend.
>
> It is a multi-paradigm language, with an OO approach based on multi-methods and direct support for scientific programming.
>
> The target audience are the scientifc community that makes use of R, Python with NumPy and so on, which are currently disappointed with the performance of said systems. Their goal is to keep the programming flexibility of R and Python, while improving the performance without having to be forced to write C code.
>
> --
> Paulo

Maybe it's time to think about a D interface to Julia. If Julia catches on within the scientific community, it would be good to have a foot in the door. Science quickly creates large code bases, unfortunately, so far it's mostly Python and Matlab which makes it hard to use the algorithms in real world applications.

On 5/6/14, 8:23 AM, bearophile wrote:
> Paulo Pinto:
>
>> You can think of Julia as a dynamic language similar to Python, with
>> optional typing and for such a young language, a quite good JIT
>> compiler backed by the LLVM backend.
>
> Unlike dynamic languages, at running time all variables are strongly typed.

What do you mean?

On Tuesday, 6 May 2014 at 13:25:56 UTC, Ary Borenszweig wrote:
> On 5/6/14, 8:23 AM, bearophile wrote:
>> Paulo Pinto:
>>
>>> You can think of Julia as a dynamic language similar to Python, with
>>> optional typing and for such a young language, a quite good JIT
>>> compiler backed by the LLVM backend.
>>
>> Unlike dynamic languages, at running time all variables are strongly typed.
>
> What do you mean?

Just a wild guess: that the compiler infers the type of a variable and turns it into a static type. That would increase the security during runtime (plugins, libraries, crackers).

Chris:

> That would increase the security during runtime (plugins, libraries, crackers).

Yes, and also gives almost native performance.

Bye,
bearophile

On Tuesday, 6 May 2014 at 11:20:33 UTC, Paulo Pinto wrote:
> On Tuesday, 6 May 2014 at 09:11:30 UTC, Chris wrote:
>> I recently came across this article http://www.wired.com/2014/02/julia/. On the Julia homepage there are some benchmarks times relative to C. I know that bearophile has mentioned Julia several times on this forum. Has anyone compared D's vs Julia's performance as well as design features?
>
> I can only comment on design features.
>
> You can think of Julia as a dynamic language similar to Python, with optional typing and for such a young language, a quite good JIT compiler backed by the LLVM backend.
>
> It is a multi-paradigm language, with an OO approach based on multi-methods and direct support for scientific programming.
>
> The target audience are the scientifc community that makes use of R, Python with NumPy and so on, which are currently disappointed with the performance of said systems. Their goal is to keep the programming flexibility of R and Python, while improving the performance without having to be forced to write C code.

Excellent summary, one quibble, you omit MATLAB and Octave users from your target audience, when they may be the most important one. Julia reads much more like MATLAB than like R or Python, and numerical linear algebra is one of the things Julia is being aimed at.

It has a very rich language of types, and a macro system. Disappointingly, whilst you can annotate function arguments and variables with types, you can't annotate the function itself with a return type.

TL;DR MATLAB reimagined by Lisp hackers. I like it!

Not really competing in the same space as D. Yes, I know, I'm pigeonholing D, which is supposed to be a wide spectrum language, etc. etc.

On 5/6/14, 10:41 AM, Chris wrote:
> On Tuesday, 6 May 2014 at 13:25:56 UTC, Ary Borenszweig wrote:
>> On 5/6/14, 8:23 AM, bearophile wrote:
>>> Paulo Pinto:
>>>
>>>> You can think of Julia as a dynamic language similar to Python, with
>>>> optional typing and for such a young language, a quite good JIT
>>>> compiler backed by the LLVM backend.
>>>
>>> Unlike dynamic languages, at running time all variables are strongly
>>> typed.
>>
>> What do you mean?
>
> Just a wild guess: that the compiler infers the type of a variable and
> turns it into a static type. That would increase the security during
> runtime (plugins, libraries, crackers).

Julia doesn't have a compiler. There's no compile-time and run-time distinction. But functions are jitted before execution.

I don't see how that means "variables are strongly typed". If you mean that at runtime they carry their type information, so do dynamic languages.

bearophile wrote:

> Chris:
> 
>> That would increase the security during runtime (plugins,
>> libraries, crackers).
> 
> Yes, and also gives almost native performance.
> 
> Bye,
> bearophile

One can argue that every modern JIT achieves "almost native performance" ...

-- 
http://dejan.lekic.org