Wrong link, no? Shouldn't it be https://discourse.julialang.org/t/one-does-not-simply-walk-i... ?

We are free to come up with myths about the name origin. My favorite one is that it comes from Julia character of George Orwell's 1984 novel :D

This presentation is only a few days old.

Julia multiple dispatch allows dynamic polymorphism.

Check https://stackoverflow.com/questions/1801216/what-is-the-diff... and https://www.youtube.com/watch?v=kc9HwsxE1OY

This is very good news for people like me who would like to play with GPU kernels and arrays but usually have no access to NVIDIA/AMD hardware. (Although specific Intel hardware and Linux is being required for now.) I'm waiting for KernelAbstractions.jl integration.

AFAIK it is the opposite of what you have said. And although Julia has a lot of inspiration of Matlab syntax, it is absolutely not derived from it. https://julialang.org/blog/2012/02/why-we-created-julia/

There are many fine languages that have used `end` to delimit blocks, including: Pascal — an elegant, classic language (and my first, personally); Ruby — another gem (get it). And yes, also Matlab, which is hardly unique in this respect.

Right, but Julia is not derived from Ruby or Pascal.

Julia isn't derived from Matlab either and was influenced as much by Ruby as by Matlab.

> derive: base a concept on an extension or modification of (another concept).

Obviously I didn't mean the implementation was based on MATLAB because that would be impossible.

""" [...] it is possible to perform kernel-like operations without actually writing your own GPU kernels: a = CUDA.zeros(1024) b = CUDA.ones(1024) a.^2 .+ sin.(b) """ [https://juliagpu.gitlab.io/CUDA.jl/usage/overview/#The-CuArr...]

As far as I know, that example code creates an ad-hoc kernel that performs the computation in a single pass.

I honestly don't know if that is possible in other frameworks.

Yeah, that's definitely available in Python frameworks. (I was wrong to mention Numba - I think CuPy would be a better example: https://docs.cupy.dev/en/stable/overview.html)

That's right, I found it: https://docs.cupy.dev/en/stable/tutorial/kernel.html#kernel-...

There seems to be a kind of Godwin's law for Julia that states that "When on an online discussion someone mentions Julia, the probability of a complaint about 1-based indexing is 1".

Or maybe it should be "When on an online discussion someone mentions Julia, the probability of that discussion turning into a 0-based versus 1-based indexing discussion is 1"

That is pretty amazing! I wonder how would it look like if it was written in C. Anyone has some links to "Blobs" implementations in C?

If you allow codegen in advance it looks pretty similar eg https://capnproto.org/cxx.html

I've used a protobuf library for Arduino that was zero copy... A lot of callbacks to do something with each new thing that's read.

In part, the fact that there are major problems moving the "giant" to where one would like (speed), e.g., unladen swallow, pypy, pyston, ...