What does HackerNews think of ivy?

ivy, an APL-like calculator

Language: Go

My recent exposure to array programming languages came via a podcast called The Array Cast[1]

Not affiliated, just recommending. The regular co-hosts appear to each be experienced with various array languages such as J, APL, etc. They don't get deeply technical, but it's a nice introduction, especially on explaining the appeal.

A recent episode had Rob Pike (UTF-8, Go, etc.) on to talk about his array based calculator, Ivy[2]

[1] https://www.arraycast.com/

[2] https://github.com/robpike/ivy

I like Ivy's[0] approach by using keywords instead of symbols. I feel like something like APL should either be embedded in some host language, be given lots of functionality for I/O, or some static type system with rank polymorphism.

[0]: https://github.com/robpike/ivy

Speaking for myself, I find that whenever I think "I just can't see how..." it makes me want to figure out what it is that others can see that I can't. This is the reason I learnt APL, actually, after seeing half a page of k code and feeling annoyed that I couldn't read it. k subsequently led me to APL.

You can try it for yourself -- NumPy is a fair "Iverson ghost" -- APL without the symbols: it has a similar enough array model, and most of the APL primitives as functions or methods. APL lets you express linear algebra in a very natural way. Doing it in NumPy is much more convoluted.

Or try Rob Pike's (of Go fame) "ivy" -- his attempt at an APL-with-words (https://github.com/robpike/ivy).

Ivy is another APL like language and one I kind of enjoy, because source code is actually readable and writable.

https://github.com/robpike/ivy

He also implemented an APL-like interpreter in Go: https://github.com/robpike/ivy
I'd also suggest looking at Pike's ivy as a simple example of an apl like system in go. https://github.com/robpike/ivy
You have ivy, for example: https://github.com/robpike/ivy by Rob Pike and, of course, gofmted. I have had a quick look at a few APL implementations and some of them are very readable code (by normal standards).

However, although I totally get your point (I've been there), I have to say there is much more to learn if you try to understand that parallel world. It can take a while, but I think it is worth it.

Rob Pike also implemented an APL-like big number calculator in Go more recently: https://github.com/robpike/ivy

>The author has never used APL. It's a chicken and egg problem. (...) All testing has been done with tryapl.org.

There are also a few free software implementations of APL most notably GNU APL. I have been sticking to that while learning APL. https://www.gnu.org/software/apl/

Rob Pike's Ivy: https://github.com/robpike/ivy

Video about it (Nov 2014): "Implementing a bignum calculator" https://www.youtube.com/watch?v=PXoG0WX0r_E