Hacker News Reader

Comment by oivey | Hacker News Reader

This is a little reductive. The speed comparison was between the highly parallel and optimized CPU version vs GPU. The GPU’s advertised FLOPS was only 4x the CPU setup’s. That the performance is so similar isn’t all that surprising and could come down to low level optimization details. There are likely some areas in Julia’s GPU stack that could be made better, but it’s certainly already pretty performant.

It’s also comparing against Fortran. Their Python comparison is 100x+ slower. That a high level language even comes close is impressive.

View on HN

Why should it be impressive?

Compiled high level languages have always been pretty fast in general, for decades, before 20 years ago it started to be trendy to use interpreted scripting languages to do their work.

Anyone used to Modula-2, Object Pascal, QuickBasic, Clipper, AMOS, Lisp, Scheme, Dylan, Smalltalk, SELF, Oberon, VB, Delphi, C++, SML, Miranda, Haskell, Prolog from 1980-1990's, isn't going to be surprised about speedups over Python.

100x relative to NumPy is still quite a lot, depending on how much of their code manages to stay in the C extension. If it was pure Python the delta would likely be much, much larger.

Julia is definitely built on the shoulders of giants. I don’t have experience with most of those languages, especially in high performance Lisp or Haskell. Calling C++ high level is definitely not in the same vein as Python or Julia. My understanding is that Haskell can run into all sorts of performance gotchas because lazy evaluation can be unpredictable and recursion may not always easily unroll into optimizable loops. I think the combination of features, especially borrowed from Lisp and C++, really come together as something very productive for writing fast, very high level code.

C++ is definitely high level, in the same vein as Python and Julia, the only thing missing is reflection (if we ignore C++/CLI, C++ Builder and custom libraries), which with some luck might still make the cut to C++26.

Just because some people insist in using it like C, doesn't make it less higher level in available features and tooling.

Regardless of how easy it is to optimize Haskell code, even stupid Haskell code beats an interpreted language like Python. And C bindings are not Python, regardless of how the Python community likes to think otherwise.

If anything, I look forward to Julia and others to put pressure in the community to take PyPy and other JIT attempts more seriously.

Or maybe it doesn't matter and in a couple of years everyone has moved into mojo, if it is successful.

I disagree that C++ is high level in the same way. The core of the language’s memory management relying at some level on bare pointers adds complexity that can never be removed. The syntax itself is not simple and rarely has the magic of 1 line of code expanding into an incredibly complex yet simply understandable computation. That functionality cannot even be retrofitted on because its metaprogramming system sucks.

PyPy will still never be as fast as C++ because the semantics of Python itself make it hard to compile into efficient code. Funny enough, Haskell has that similar problem that it’s difficult to compile well. That’s the actual magic of Julia: its semantics are designed so it can be compiled to fast code while still being ergonomic like Python. Mojo may end up being good, but in the examples I’ve seen the real “fast” part of the language doesn’t look all that much like Python anyway.

As mentioned, some people insist in using C++ as if it was C.

Smalltalk, Common Lisp, JavaScript, SELF, Dylan JIT implementations, for highly dynamic languages, beg to differ.

Some of those, anything in the process space can change at any time, either by using language features, or stopping into the debugger, changing the world as much as we like, hit continue or retry as if it was still the original code.

The Python dynamism as a problem is an excuse from a language culture that sees writing C extensions as being Python code, thus not willing to spend the resources to make it happen.

Thankfully even Ruby is leaving Python behind, joining the list of highly dynamic languages with a JIT in the baggage.

No, it’s not just that people write C++ like it’s C. Another example: there is no simple syntax for broadcasting a function over a collection. Anonymous functions have syntax that is all parentheses and brackets. They’re this way because adding them to the language itself would be breaking. You can’t easily improve the syntax of these things yourself for your subset of code because the meta programming systems C++ has just aren’t great compared to Lisp and Lispy languages like Julia. Further, even if you do add a bunch of cool stuff yourself like a GC or some other syntax magic, it rarely composes well with other libraries. Core to this is that inheritance never really panned out as hoped, and templates are cumbersome. C++ has come a long way, but all of that is due to the overall design of the language itself, not just how it is used.

Can you write something as fast as BLAS in JavaScript? As far as I know, the answer is no.

Python’s dynamism makes it so that a compiler often times can’t do anything to infer what some function calls will do. No investment will completely fix it without breaking changes to the language itself.

I suggest learning about C++ ranges and CUDA algorithms.

Parenthesis and brackets have nothing to do with how high level a language happens to be.

BLAS in JavaScript would certainly be faster than Python, this is what is being discussed here.

Again the dynamism excuse.

You can change ANYTHING in Smalltalk, SELF, Common Lisp, and their JITs make up for it.

Might not be C++ fast by today standards, as those languages don't see much investment nowadays, they certainly beat Python no matter what.

> I suggest learning about C++ ranges and CUDA algorithms.

I’m familiar.

> Parenthesis and brackets have nothing to do with how high level a language happens to be.

I would argue readability and expressiveness do, though. When someone is talking about high level languages in the context of Python, they don’t mean in terms of instructions, registers, and interrupts.

> BLAS in JavaScript would certainly be faster than Python, this is what is being discussed here.

No, it explicitly is not. You originally replied to my comment that it was impressive how Julia in this case was competitive with Fortran and much faster than Python.

You agree that no JavaScript JIT is going to make it as fast as C/C++/Fortran, right?

> Again the dynamism excuse.

Julia is a dynamic language, so I’m not sure what excuse you think I’m making. The reality is that the languages you cited generally are not competitive with C/C++/Fortran. The reality is that none of the languages you cited are even being considered for those applications. The reality is that languages that have had massive investment in a JIT like JavaScript are still relatively slow.

Julia seems to be different than the other dynamic languages you cited in this regard. Why do you think the relatively small investments in Julia have been able to achieve this while others, often with more resources, have failed? I think it probably has something to do with the language design.

I am not arguing against Julia, I am arguing against Python, but you aren't getting it at all.

I am not going to bother with Julia vs C++ evangelism.

By the way, there are 1980's papers about Common Lisp versus Fortran floating point performance, that you can certainly easily find out.

If only they didn’t chose 1 based array indexing, like matlab. Having worked with matlab and for that reason I can’t seem to take them seriously.

But you can take Fortran seriously?

Plenty of serious languages have either 1 based indexing, or allow the flexibility to set lower boundary explicitly.

The choice of 1 based array indexing is due to Julia having it's roots in mathematics - which is a common choice for mathematics based programming languages (e.g. Fortran, Julia, MATLAB/GNU Octave, Mathematica, R and Wolfram). The reason being is that matrix notation starts at 1 and not 0.

For a comparison on array indexing in different programming languages see here: https://en.wikipedia.org/wiki/Comparison_of_programming_lang...

From personal experience, I wouldn't let something as simple as starting index getting in the way of programming for a language as you'll soon start automatically switching to thinking in 1 based and 0 based indexing depending on the programming language.

If you think 0 or 1 based indexing will hinder your ability to write a program, it's not the indexing, it's a skill issue.

Reply on news.ycombinator.com