LWN: Comments on "Concurrency in Julia"

Concurrency in Julia

leephillips — Fri, 12 Nov 2021 21:46:36 +0000

The oops is mine—I didn’t realize that was cut. But for those with the wisdom to read the comments, there it is. It’s a shell command, nothing to do with Julia.

Concurrency in Julia

jake — Fri, 12 Nov 2021 21:30:32 +0000

> That’s true, which is why I thought it worth mentioning the lscpu
> command, which will tell you the truth about your CPU.

some darned editor may have dropped that line on the editing room floor ... oops :)

jake

Concurrency in Julia

leephillips — Fri, 12 Nov 2021 21:24:43 +0000

That’s true, which is why I thought it worth mentioning the lscpu command, which will tell you the truth about your CPU.

Concurrency in Julia

ballombe — Fri, 12 Nov 2021 20:24:34 +0000

> This allows access to all of the logical threads on the machine. This is often not optimal, and a better choice can be -t n, where n is the number of physical cores.

This is true, and this is not a Julia-specific issue. However, OS make it much easier to query the number of logical threads than of physical threads.

Concurrency in Julia

rsidd — Fri, 12 Nov 2021 06:29:29 +0000

Even for factorial, the parameter type can be anything, the function body can convert it to bigint if needed.

julia> function factorial(n::Integer)
           return prod(1:convert(BigInt,n))
       end
factorial (generic function with 1 method)

julia> factorial(convert(Int32,100))
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Concurrency in Julia

droundy — Fri, 12 Nov 2021 04:34:57 +0000

My brain somehow converted it to a factorial program. Not sure how that happened.

Concurrency in Julia

rsidd — Thu, 11 Nov 2021 05:36:36 +0000

I'm only an occasional user of Julia but should have thought of that point, that if you don't define the second function a method exception will be thrown anyway for wrong type of argument. But leaving it out would confuse readers...

Concurrency in Julia

mathstuf — Wed, 10 Nov 2021 22:28:01 +0000

What `isprime` algorithm requires values larger than the queried number (assuming non-negative values)?

Concurrency in Julia

droundy — Wed, 10 Nov 2021 16:08:47 +0000

Wouldn't using smaller int types simply make overflow almost inevitable? An Int version of factorial is bad enough in terms of uselessness.

Concurrency in Julia

leephillips — Wed, 10 Nov 2021 16:06:00 +0000

All relevant observations! The Integer type would also include BigInt, so you could supply as big a prime candidate as you wanted.

Concurrency in Julia

xecycle — Wed, 10 Nov 2021 15:39:10 +0000

Threads in Julia indeed was a part that confused me a lot when getting started. Wow I couldn’t find a primitive to start a new OS thread? Either I can use the auto-parallelize tools feeling very similar to OpenMP, or I can go with M:N user threads.

Now I think I have a better grasp of the whole picture and no longer worry about that. I used to think of Julia as “a high-performance general-purpose langauge with sugar for numeric computation”, but that view doesn’t fit well. Perhaps it is better viewed as “a high-performance numeric computing DSL with abilities to do some general-purpose programming”. The community measures and improves performance of Julia based on FLOPS numbers, instead of e.g. packets/s or 99.9% response time; this is not the tool for me if I wrap up a flat-combining data structure every other day, but it’s an excellent choice for crunching terabytes of tabular data, millions-by-millions sparse matrices, etc. Its bias towards OLAP made it a great tool, but also made some scenarios harder. The term “high performance” need some qualifications, but well, OLTP and OLAP community never agreed with each other on this topic…

Concurrency in Julia

garrison — Wed, 10 Nov 2021 14:57:20 +0000

I think the version in the article is great in that is succinctly illustrates the important point to a reader potentially unfamiliar with Julia. If we want to talk about idiomatic Julia, however, instead of defining a second isprime method that throws an exception, one should simply get rid of the second method. When no method is given with compatible types, a MethodError will be thrown, and this is the best way to communicate that a method has not been implemented for the given type(s).

Another comment about making isprime more idiomatic: instead of specializing on Int (which, as the article notes, is a synonym for Int64), it could specialize on Integer instead. Integer is an abstract type that includes all integers, so with this change, the function would still work if passed e.g. an Int32. (The JIT will automatically compile specialized machine code for each case encountered.)

Concurrency in Julia

leephillips — Wed, 10 Nov 2021 05:24:35 +0000

I suppose throwing an exception is a better idea. But then I would have to explain the syntax for that, and my version does what I want.

Concurrency in Julia

rsidd — Wed, 10 Nov 2021 04:30:17 +0000

Thanks for all the articles on Julia. Interesting point on using multiple dispatch in Julia to check for invalid data types without polluting your main function with checks. But shouldn't the type-check function throw an exception, rather than return a string value? It's equally short and better programming practice I'd think, and wouldn't confuse LWN readers. A minor and tangential matter, but a bit of a turn-off when it's right at the top of the article.