Preaching Julia to biologists


#41

Go ahead! I’d add the github integration as one of the “favourite things”, meant to add that…


#42

Lol, I may be someone who abuses this, but the Julia community is much more open to answering whatever question you have.

Wether you’re working on plots, root solving, or anything tangentially related to computation, someone will usually step in and give you an answer. (and they’re usually good ones)

None of this: duplicated question, not my problem, or have you tried jquery nonsense you run into with other programming language communities.

Maybe this will change as Julia explodes, but I think it’s helped me get things done that I would have never thought possible in Python, Ruby, or Fortran


#43

Sometimes there’s “duplicate question,” the key difference I think it’s that people will usually link to the other question and not be sent out of shape about it. Speaking for myself, I usually link to other responses because they’re better than what I would come up with :slight_smile:


#44

Did you post a link to the markdown?


#45

Sorry, that link I referred to wasn’t very helpful (but similar), here:


#46

Is it correct to say that Julia is “interpreted”, which is the opening slide of your talk?

I thought it is compiled?..


#47

Pfff, I’m not the one to ask, but I thought it was dynamic+interpreted…?


#48

That’s actually a bit of a howler :grinning: From the introduction to the manual:

Julia features optional typing, multiple dispatch, and good performance, achieved using type inference and just-in-time (JIT) compilation, implemented using LLVM.

But it’s also somewhat understandable, given how you interact with the REPL. Matlab, too, has a JIT for at least parts of the code, and Numba (Python) also JITs to LLVM. There is at least a bit of a blurry grey area between interpreted and compiled languages these days, but Julia, at least, isn’t interpreted, no. I think the main discussion is whether it is correct to say that it is JIT compiled or AOT ((just) Ahead Of Time) compiled.


#49

Lord. Complicated much. Hmm, please feel free (anyone) to change and add and edit that presentation. I might use it again, and if not me, someone else.


#50

Julia has an interpreter but it is not often used. I would not call Julia an interpreted language.


#51

I want to revisit this talk’s content and at least correct everything that is wrong. So my whole shpeel about interpreted versus compiled languages was wrong (in the context of Julia). I could just remove that section of the talk, clean off any references to “interpreted” and it would still be fine, right?


#52

https://www.youtube.com/watch?v=cjzcYM9YhwA is probably good to watch.


#53

So is it “wrong” to say that Julia is dynamic? I just want to refer to the property that allows coding in Julia to be so dynamic, as opposed to how stiff and static everything is in say C/++. So while most of the speed in R/MATLAB/Python comes from executables programmed in C, Julia is in Julia.


#54

No, Julia is dynamic in the sense that it is dynamically typed, as opposed to statically typed.


#55

Also note that for an audience not familiar with CS terminology, “dynamic” usually means “interactive”, ie that you can type stuff into a REPL (eg R, Matlab, Python, Julia), as opposed to “compiled”, where you can’t (C/C++/Fortran/…). This does not necessarily map to other terminology (type system, compilation/execution model), but is a very important distinction nevertheless.


#56

My take home message from this is that it’s ok to refer to Julia as dynamic. I need something to hold on to…


#57

Julia is definitely a dynamic language.


#58

I would not use the term dynamic language since it is pretty unclear what that actually means. Julia is dynamically typed.


#59

Well, with C++.jl, theres a C++ REPL in Julia…


#60

You are right, but given the context (introducing Julia to scientists with no formal CS education) I would stay away from the whole type system typology discussion. There is no doubt it is important, but it just wastes 10+ minutes on a detail that is pretty irrelevant in the first pass.