Giving up on Julia • Hacker News Board

Re: Giving up on Julia

#201

Post by ScottPJones » Sat, May 14, 2016, 8:17 AM UTC

vitaut wrote: post #160

KenoFischer wrote: post #9

Happy to address these points: - Startup performance/memory usage Yes, we are definitely very acutely aware of these. Julia is not currently optimized for frequently run short scripts. That's the price on pays for having to bring up the entire runtime system (initializing the compiler, RNG, external libraries etc). The good news is that there will be a solution to this soon, which is to statically compile your julia…

Regarding the slowdown in development, perhaps it's a seasonal variation connected to GSoC. For example, notice a drop in postings since October in https://groups.google.com/forum/#!aboutgroup/julia-dev . This seems to be more or less consistent with the observation in http://www.davideaversa.it/2015/12/the-most-promising-langua... , but that's just a guess.

I do think it's seasonal, however not connected to GSoC. Many of the major contributors are (or were) students (Julia seems to be detrimental to people finishing their PhDs, except in the case of Jeff Bezanson, where in some sense he crowdsourced a lot of the research, as Julia was the topic of his thesis ;-) ) Many who aren't students are professors. Definite drop off when people are taking classes, exams, teaching, etc.

Re: Giving up on Julia

#202

Post by ScottPJones » Sat, May 14, 2016, 8:22 AM UTC

KenoFischer wrote: post #25

rch wrote: post #22

Earlier quoted context omitted.

I liked how the Template Numerical Toolkit implemented one-based indexing: // Construct matrix. Elements are not initialized. // To initialize all elements to zero use // Matrix a(2, 2, 0.0). Matrix a(2, 2); // Assign elements to first row using // Fortran-style one-based indexing. a(1,1) = 0.5; a(1,2) = 1.0; // Assign elements to second row using // C-style zero-based indexing. a[1][0] = 1.5; a[1][1] = 2.0; -- http:…

This syntax is available in julia as well, but I'm not sure it's a great idea to encourage mixing the two indexing behaviors, even if they have different syntax. As I hinted in the original reply, I have seen very few cases where the choice of index offset actually makes a difference. For example, loops over indices generally use `eachindex` which doesn't care about your choice of index base.

Actually, for the sort of low-level bit twiddling code that I frequently do, 1-based indexing complicates the code greatly. I also need to pass structures that contain indices back and forth to C, so the 1-based indices cause extra overhead to constantly add or subtract the size of the element. I find that it's the largest cause of bugs in my code (which is why I really want Gallium working!)

Re: Giving up on Julia

#203

Post by max_ » Sat, May 14, 2016, 8:24 AM UTC

The author has addressed very valid issues, but I strongly disagree with his objective theme of "Giving up"

I don't think the Julia team should be blamed for anything. I have not heard of the project receiving any support from large companies as Python, Golang and Rust do.

For this reason, I find it very unfair to compare Julia to these languages. FYI Julia has not even reached version 1.0 yet!

The language just needs support, and the author is not helping out.

Re: Giving up on Julia

#204

Post by argonaut » Sat, May 14, 2016, 8:52 AM UTC

patrickthebold wrote: post #122

whyever wrote: post #101

Earlier quoted context omitted.

> But measuring performance with timing a "hello world" program? Seriously? What scenario does the author have in mind that makes this particular benchmark even remotely relevant? If Julia is to replace Python in scientific computing, people will want to use it for short plotting scripts. Startup time matters there. That hello world is so slow is already telling. A plotting script needs tens of seconds just to load t…

They use the REPL like R.

Not all of them. Many of them? Sure. Many people also use scripts and so on.

Re: Giving up on Julia

#205

Post by scriptproof » Sat, May 14, 2016, 8:52 AM UTC

xixi77 wrote: post #58

Libraries? Sure. Ease of development, I cannot comment on. But measuring performance with timing a "hello world" program? Seriously? What scenario does the author have in mind that makes this particular benchmark even remotely relevant? The rest of the rant pretty much comes down to "it doesn't look like Python" (which is IMO a good thing, and I would certainly not call Python a "de facto standard of numerical comput…

I had also the feeling the "benchmark" is a joke. Even if it takes some seconds to print hello, speed is only important when you run big programs with million of operations.

Re: Giving up on Julia

#206

Post by argonaut » Sat, May 14, 2016, 8:53 AM UTC

SolarNet wrote: post #90

papaf wrote: post #72

I know R and have used Octave. I started learning Julia this morning after a physicist recommended it to me after he switched from python. I used Jupyter/Julia to simulate a neuron as a practice exercise. This is my experience as a beginner: 1. The static typing makes a big and positive difference. Its nice having a statically typed repl. 2. The documentation is good. 3. Using unicode symbols and \mu style tab comple…

> The base install is a bit bare. I think the problem here is the library approach. They should break stuff out of Julia's core library and move them into default included libraries (like python does).

What is the difference?

Re: Giving up on Julia

#207

Post by Extigy » Sat, May 14, 2016, 8:55 AM UTC

gh02t wrote: post #159

bmh100 wrote: post #41

Earlier quoted context omitted.

One-based indexing is also used in Fortran, which seems to be used in a great deal of numerical computing even today. Additionally, BLAS/LAPACK is an important linear algebra library written in Fortan. I am somewhat confused by your discussion of startup times. Since Julia is a "programming language for technical computing", what scenario are you imagining where startup times would be a significant concern?

Fortran has the rather unusual feature that you can change the indexing to an arbitrary offset. You can declare arrays to be indexed from 0 if you want, but it defaults to 1 and almost nobody uses this feature for obvious reasons.

I index from -N:N so that 0 is in the centre of my computational boxes.

Re: Giving up on Julia

#208

Post by ScottPJones » Sat, May 14, 2016, 9:07 AM UTC

davidacoder wrote: post #171

SolarNet wrote: post #164

Earlier quoted context omitted.

I'm referring to one specific core dev. However they all know each other from MIT so it makes it difficult for them to deal with that fact. I can point to 3 public examples, in addition to a couple of private reports about problems which allow me to be certain. But admittedly it's all second hand to me (from people who work close to the language).

I've been using julia for a little more than two years now. I've been subscribed to all the mailing lists and regularly read the github issues. Not all of them, but a fair share. I've never, ever seen any behavior by any of the core devs that one could even remotely describe as toxic, rude or anything like that. The community is actually really helpful and supportive. I have seen this point about a toxic dev been mad…

The rude behavior definitely exists, I can point out a number of examples if you send me your e-mail address (you can look me up, @ScottPJones on GitHub, easily enough). I've seen that that sort of disrespectful behavior tends to spread in the community, unfortunately, when nobody dares call out one person for their comments and actions, because of their position.

Re: Giving up on Julia

#209

Post by klibertp » Sat, May 14, 2016, 9:09 AM UTC

jjnoakes wrote: post #102

dom96 wrote: post #93

Earlier quoted context omitted.

Sorry, it wasn't my intention to imply that. I'm genuinely curious, I haven't used many language's FFI to know which is best. You mention non-GC languages. Are there any GC languages that do? :)

I don't think so. I think by virtue of having a GC language you pretty much have to manually anchor pointers before calling code which knows nothing of the GC. But if anyone knows of counter examples, I would be interested in them as well.

> you pretty much have to manually anchor pointers before calling code which knows nothing of the GC.

Which I'd still consider trivial...

Re: Giving up on Julia

#210

Post by Avshalom » Sat, May 14, 2016, 9:22 AM UTC

dnautics wrote: post #182

bluecalm wrote: post #148

Earlier quoted context omitted.

It's very error prone if you implemented algorithms using 0 based indexing your whole programming life. You are just bound to make mistakes if suddenly it's 1 based indexing. I am not saying 0 based indexing is technically superior (I really have no opinion on that). I could compare it to switching positions of brake and accelerator in a car - you can talk about brake on the right design being superior all you want b…

0-based indexing is technically superior, because it makes offsets for memory addressing simpler.

Well unless your array is more than just x-many addresses in a row, like if the array carries metadata related to length (like every language but C) or if it's a sparse array (hint sparse arrays are super common in numerical work).