moelf

I mean:

    https://github.com/vim/vim/graphs/contributors
    https://github.com/neovim/neovim/graphs/contributors

technically yes (by others too), but relatively, it's basically a one-man project

IIRC one of the main reasons to split is because Vim is a one-person effort, they don't take PR and they didn't want the drastic change, so Neovim had to be a fork because there's no way to convince Vim author to take changes

maybe... Lua? /s

at least in Julia you have `@code_warntype`, JET.jl, `@benchmark`, and the language being dynamic also helps a lot.

I love Julia so much and I almost exclusively do my physics research in Julia (modulo the time I need to help with C++ legacy stuff)

So I want to raise this caveat as a Julia lover: the love% is highly correlated to why people are using the language, because Julia is not so popular, it's unlikely people (students) are forced to use it, thus less Dread.

But I think Julia deserves to be loved AND widely used.

>aside from performance magic. It seems so klunky to actually use

what's the interface magic in Python? Class inheritance? I suppose you know that multi-dispatch is basically strictly more generic than Class-based OOP, so if you want to lock yourself down in Julia and have less composability that's always an option.

IIRC both Oxygen and Genie use HTTP.jl

well, Julia is not class-based OOP so it's kind of Unix like where packages does one thing right and you just compose them or someone makes a meta package that compose them

Xperia 5 III

:

Unpack.jl happened before this got added to Julia Base.

You can always partially unpack, just only put what you need on the LHS

but I'm showing unpacking by name, not by position.

that's all cool and fine, but can you unpack named tuple or struct (data class)? In Julia one of my favorite quality of life improvement in the 1.7: https://github.com/JuliaLang/julia/pull/39285

Example:

    julia> X = (this = 3, that = 5)
    (this = 3, that = 5)

    julia> this
    ERROR: UndefVarError: this not defined

    julia> (;that, this) = X;

    julia> this
    3

    julia> that
    5

this works with structs as well (in fact anything with getproperty() defined, so like dataframe column too)

every other week there's a post about JIT, LLVM, etc. (either like this or more commonly in Python where people show it improving 5x or whatever)

whenever I see it, it makes me feel like Julia-lang really did a good job picking the approach and technology all the way back in 2010

My personal "disappointment" is: it doesn't do anything for the runtime with all the extra work and headache. I.e. it feels like Julia but without the elegance of multi-dispatch and performance.

https://github.com/mcabbott/Tullio.jl:

  - better syntax (because Julia has proper macro/metaprogramming)
  - faster
  - automatically works with GPU arrays.

or just have multi-dispatch, Julia:

  julia> using Dates

  julia> Millisecond(10)
  10 milliseconds

  julia> sleep(Microsecond(100))

  julia> sleep(Millisecond(10))

>only one type of neutrino can be massless

they would stuck in that type then right? which is not what we see in mid - long baseline experiments, so I think all three types are massive?

high energy physics (HEP) shameless plug: https://github.com/tamasgal/UnROOT.jl

indeed, the grants (in the millions $) given to rewrite C++ or Python just to handle array (because for loop sucks) and ends up making monorepo blobs is jaw dropping -- while it's almost free in Julia, with 1/100 of the line of code and more flexibility we can match and beat even C++ code...

at this point it's user friendly because it has 100x more random snippets and google results... if you give someone only official docs I swear...

>can launch it to the next level like Numpy

one thing people don't see is how "free" things are in Julia... we don't need half a million line CMake and C++ then bind to Python to make something work, and we don't need monorepos that re-invent same interface (array, numpy, autodiff etc.) three times. It just works™, and small libraries constantly build on top of something with only ~100 lines and gives you something fast and flexible.

https://news.ycombinator.com/item?id=30339532 see this comment above regarding compiling to binary

the first two are impossible -- looking at the 10k scientists who program at CERN

there's also https://docs.juliaplots.org/latest/generated/gr/ in the docs which is basically "all the kinds of plots you can make" (see the other comment for Makie gallary)

original title is too long

glad it's well funded: https://nsf.gov/awardsearch/showAward?AWD_ID=2103945

>deployed for the next 100 years

bold for you to assume we will have active internet for 100 more years /s...

>Arnold predicted that every phase space of a certain type contains a minimum number of configurations in which the system it describes returns to where it started.

is this article talking about Ergodicity without mentioning Ergodicity? https://en.wikipedia.org/wiki/Ergodicity

more like 3650 cores/threads

hopefully if enough people are unhappy about it && sees future in alternative (i.e. critical mass), we can collectively have a "phase transition".