DNF2

The answer to this is simple: inertia.

Our customers use Matlab, our colleagues do, all our code, built up over years, is Matlab. Learning a new language incurs a cost, with somewhat unknown long-term payoff.

Julia is, in my opinion, far superior to Matlab (and also better than Python), but I'm stuck with Matlab (and a bit of Python) because of those things.

LinearAlgebra is mainly julia code. It does indeed call out to BLAS for many operations, but a huge amount of it is native Julia.

There's a very major revamp going on of how binary dependencies are handled. I don't know much about it, but it might possibly change this picture.

Many of these features sound like Julialang to me.. Not certain how well they fit with Nim.

In fact, I almost suspect you are hinting in that direction yourself ;)

I have no idea, and I don't really see how relevant this is to the original remark that you responded to.

You don't really need the `@simd` macro, though. The compiler is pretty good at vectorizing on its own now.

From the docs: "In many cases, Julia is able to automatically vectorize inner for loops without the use of `@simd`. Using `@simd` gives the compiler a little extra leeway to make it possible in more situations."

The poster said "(even though you obviously can)".

People will try all sorts of weird language experiments, so it's no surprise those libraries exist. But do you really expect a significant number of web developers to shift over to C, just because it's technically possible?

But didn't it become more intuitive when I explained it? 'Type something to enter a mode, delete it to exit'. I'm pretty used to invisible characters, but I just think it makes sense. Anyway, you really just need to hear it once, and then it should stick.

I believe the `psort!` code that was shown in the blog post was a 'toy example', meant to demonstrate how to use different parallel techniques, one of them being the use of thread-local state.

There's probably going to be a lot of development of parallelized code going forward. Maybe you could help? :)

Well, you get into the pkg mode by typing `]`, so from an intuitive standpoint you get out by deleting that character. When you're in any REPL mode there is a character typed at the beginning of your line that renders as a mode. Delete it, and it goes away.

I think it makes more sense than escape, actually, but everyone is so used to using escape that it's not too strange to not think of it.

That is strange. It is literally as easy as `using Plots; plot(...)`

No need to `copy` from `d[:,3]`. Slicing already creates copies (so you're copying twice), but even if it made a view you could still just write `B = d[:, 3]`.

This particular example appears to be an implementation of a 'Computer algebra system', which seems to be a type of symbolic computing rather than numerical computing.

Numpy is great if you can vectorize your code in a straightforward manner. But when you start doing anything non-standard it becomes difficult.

I can tell you that programmer productivity can plummet drastically when you need to get everything into vectorized form.

Also, custom classes and types do not vectorize well at all.

We're not talking about concurrency, but actual parallelism.

Anyway, if by data parallelism you mean simd, then that is already available and widely used in Julia. Multithreading comes on top of that.

Maybe I misunderstand you, but telling the thread to halt is surely a waste of those resources?

My understanding was that the depth-first scheduling was basically 'new'.

If you're talking about the Parallel Computing Toolbox (PCT), then, no, you do not get access to multithreading through that, only multiprocessing and GPU processing. I recently considered buying the PCT, and this is one of the main reasons I probably won't.

The only type of multithreading in Matlab is the type that is built into the core language, and you don't get any control over that.

Finally, the claim to originality here isn't just the introduction of multithreading (which isn't even new in Julia!), but the particular threading model and scheduler, which lends itself particularly well to composable multithreading.

What would be the purpose of yielding control from the thread and tell it to wait, rather than just let it run to completion?

Which ways are those?

My understanding is that it's not just about the parallelism, but about the type of threading model that is used, which makes it extremely composable.

He didn't really say that, though, rather that just Go and Erlang has a similar kind of _composable_ parallelism. (Don't know about Haskell.)

The equivalent of `a = b[:n]` is `a = b[1:n]`. And I don't think you can get around admitting that there is a fundamental ambiguity in the spoken statement "Take a look at the fourth column!" in a zero-based index system. You always need a follow-up question to clarify whether you mean "everyday informal speech fourth" or "zero-index fourth."

You don't need to annotate function definitions with types, but you should actually annotate your composite type definitions with concrete (parametric) types for each field.