Julia Language Co-Creators Win James H. Wilkinson Prize for Numerical Software

Post by zem » Thu, Jan 24, 2019, 12:44 AM UTC

Athas wrote: post #159

eigenspace wrote: post #127

Earlier quoted context omitted.

This is why the language creators usually avoid using the word 'homoiconic' because every time one uses that word there's a finite probability of being bogged down in an incredibly uninteresting semantic argument. Instead, people prefer to say that julia code is just another (tree-like) data-structure in the language and it can be manipulated at runtime with functions or compile time with macros or at parse time with…

Then why not just say 'Julia has macros'? Lightly perusing the description of Julia's features, that seems like a clear way of expressing what it is. (I also vaguely recall Julia describing its type system as "dependent" in way that goes against convention. Maybe they just liked controversy in the early days!)

Post by newen » Thu, Jan 24, 2019, 1:21 AM UTC

Iwan-Zotow wrote: post #172

hhmc wrote: post #136

Earlier quoted context omitted.

1-indexed ranges can still be composable if we define them as open on the right at N+1 (which is how I imagine one would want to define things in their implementation). [1...N] = [1...N+1) = [1...K+1) + [K+1..N+1) So the real loss is your point (2) - which, I agree, makes the implementation much less elegant and simple.

> 1-indexed ranges can still be composable you could make them work, but improper abstraction leaks out in so many fugly ways. F.e. in Python you could compose functions, not only ranges. What do you pass in? Simple, [0, len(a)). What you get out? Simple, len(a). So you could operate on ranges composing function calls like in FP. Even works for unknown beforehand sequences/streams, just count along the sequence how m…

    function mean(a, l, r)
        s = 0
        N = r-l+1
        for k in l:r
            s += a[k]
        end
        s/N, N
    end
    
    function mean2(a)
        N = length(a)
        lr1 = (1,div(N,2))
        lr2 = (div(N,2)+1,N)
        v1, N1 = mean(a, lr1...)
        v2, N2 = mean(a, lr2...)
        N = N1+N2
        (v1 * N1 + v2 * N2) / N, N
    end

    function compose(M1, M2)
        v1, N1 = M1
        v2, N2 = M2
        N = N1+N2
        (v1 * N1 + v2 * N2) / N
    end
    
    function mean3(a)
        N = length(a)
        lr1 = (1,div(N,2))
        lr2 = (div(N,2)+1,N)
        compose(mean(a, lr1...), mean(a, lr2...))
    end

Post by viraptor » Thu, Jan 24, 2019, 1:32 AM UTC

weberc2 wrote: post #190

viraptor wrote: post #183

Earlier quoted context omitted.

> CPython is 100 to 1000 times slower than C That's very context dependant. With annotations, typical calculations compile to C code roughly equivalent to native. The more of the actual runtime you use, the more you call into cpython which can't be sped up this way. Cython compiled code will be somewhere between C and cpython in terms of speed, but putting a single number to it will be always misleading.

>> CPython is 100 to 1000 times slower than C > That's very context dependant. With annotations, typical calculations compile to C code roughly equivalent to native. The more of the actual runtime you use, the more you call into cpython which can't be sped up this way. Cython compiled code will be somewhere between C and cpython in terms of speed, but putting a single number to it will be always misleading. OP said "…

Post by xiaodai » Thu, Jan 24, 2019, 1:36 AM UTC

lenticular wrote: post #122

dman wrote: post #92

Earlier quoted context omitted.

Wish advocates of all new languages stuck with this principle.

I wasn't being disrespectful of Python. We are allowed to criticize languages. The fact is, by any reasonable measure, Julia is more expressive than Python, which was all I stated. This is an advantage of Julia. Both languages have advantages and disadvantages, and comparing them honestly is necessary for people to make a good choice when selecting a language for a project. C is less expressive than Python or Julia,…

Post by mruts » Thu, Jan 24, 2019, 1:46 AM UTC

yellowapple wrote: post #152

mruts wrote: post #50

Julia is interesting, but the block syntax is a little off-putting. I'm not sure why someone would design a language that uses 'end' to delineate a block. Curly brackets make sense. Tabs make sense. But 'end'? All it does is make code harder to read and harder to write.

Ruby and Elixir both made the same decision, and I don't feel like it's had an actual negative impact, for me at least; I've found both languages to be delightfully readable. I haven't dabbled very much in Julia since the pre-1.0 days, but I don't recall it being any more or less jarring. I suppose it could indeed be jarring if you're not already used to languages which use 'end' to terminate blocks, but after awhile…