eismcc

If this kind of thing interests you, you can try KlongPy (based on Klong) which also now has backprop support making it a differential array language.

I added autograd support to the KlongPy array language. It’s been fun to integrate PyTorch and come up with new examples.

https://klongpy.org

You may want to look into the nintendo zelda chemistry engine

I’m ded

Not yet. I want to make an online book.

I don’t use windows so not sure.

Numpy is just the backend and KlongPy has a lot more application features than Numpy. You can see something like kdb+ as inspiration.

KlongPy has a lot of other features beyond pure NumPy operations (such as IPC and web server), which you could see as a kind of making use of array operations in some application. You could look at the core Klong language as what you suggest.

KlongPy author here: AMA

Working on WaddleML, and open source variant of weights and balances that uses DuckDb.

https://github.com/briangu/waddleml

You can do realtime in the sense that you can build Numpy arrays in memory from realtime data and then use these as columns in DuckDb. This is approach I took when designing KlongPy to interop array operations with DuckDb.

I recall that Richard Hamming used to also reserve Friday afternoons to deep/big thinking. Sounds wonderful.

Steve Omohundro was one of the main authors of starlisp.

After my class read this book in high school, we wrote the author and he responded. How often does that happen in today’s schools?

Thanks the insights. Not to over do self promotion, but aside from learning, the main reason I made KlongPy was to allow for optionality with the ecosystem. Use Klong for array operations and other libraries for standard stuff.

shakti has GPU support now, i believe.

Arthur Whitney is showing how to build an array language using C in array language form.

AW is known for kdb+ which is often used in finance due to its extreme performance properties and ability for quants to quickly explore ideas.

Personally, to get a better handle on how array languages worked, I implemented KlongPy which is a python implementation of Klong, which descends from K (which AW wrote).

You have to play with this stuff to understand it intuitively.

In KlongPy, dot product is: dot::{+/x*y}

    P::[2 3 4]
    Q::[1 0 2]
    dot(P;Q)

Just gonna say, this is why i wrote KlongPy - an array language in Python that lets you interop with Python while also getting some array lang. efficiencies. Klong isn't as smooth as K, but it's still quite useful.

Judging by the google group, they are in early development phase and are onboarding their first customer.

KlongPy sits on NumPy so gets pretty far. For some features, it’s still early days.

Http://klongpy.org

I was mainly surprised how fast NumPy can be if you push it. KlongPy is effectively a NumPy DSL (array language). So vector thinking is natural.

Since NumPy is called out here, I wrote an example in KlongPy which is NumPy backed and got about 1ns/iter on my M2 Studio:

dot::{+/xy};mag::{(+/xx)^0.5};cossim::{dot(x;y)%mag(x)*mag(y)};cd::{1-cossim(x;y)}

https://github.com/briangu/klongpy/blob/main/examples/ml/cos...

Chapel[0] was created, in part to replace MPI in HPC communities. However, MPI remains dominant.

[0] https://chapel-lang.org/

I worked on windows kernel team and my first real projects were ACPI 1 and 2 implementation. It's been a while and ACPI was well on its way when i got there, the story at the time was that huge gaps in BIOS were problem and we need to move it into the kernel. There was also a big push from the industry at the same time to use EFI to allow devices to have a pre-os experience (e.g. play DVDs) and not be dependent upon Windows for those.

Another memory I have for that time was that powermgmt was a big priority. So i suspect the ability for the OS to do that via ACPI was strategic - I wasn't involved in the decision making.

I worked in the windows kernel team and my favorite story about DC is when he basically made x64 happen because he hated Itanium architecture so much. He worked with AMD and basically made it happen while cranking in his corner office.

KlongPy has improved a lot since it was last on HN:

You can now directly load Python modules into KlongPy, making it easy to reuse existing libraries. KlongPy now has IPC support, making it easy to build complex, networked, data applications. It also now includes simple web so you can create sites that are backed by KlongPy.

Thanks! Now I’m curious what some examples would look like.

This makes me think about a better plugin model where capabilities are selectable.

Thanks!

I need to read more about hooks and forks to answer that. Klong itself is relatively straightforward, however with Python integration there’s a lot that can be done.

Multiple backends would be quite interesting. There’s still some gaps in fully supporting CuPy so perhaps after getting that further along it would be interesting to expand the backends.

Related to multiple backends, I think there’s a lot to explore with JIT and other tricks to make KlongPy faster.

Generally, the bulk of my focus will be on performance going forward.

Author here, AMA.

Nils' book on Klong is awesome. Very well written and could not have done this project without his very detailed and thorough documentation and C code reference implementation. Nils also helped with some clarifying details on the finer points of the language for KlongPy.