ivy VS april

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 enjoyed russ cox's advent of code series using rob pike's ivy (https://github.com/robpike/ivy), an apl-like calculator

https://www.youtube.com/playlist?list=PLrwpzH1_9ufMLOB6BAdzO...

Ivy is an APL-like programming language created by Rob Pike https://github.com/robpike/ivy

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

https://github.com/robpike/ivy

I really like Ivy as a simple, friendly introduction to APL. There is a surprising lack of APL-derived languages that use words to name things -- most stick with the original symbols; J and friends choose equally-cryptic symbols composed of ASCII characters.

Earlier this year I decided to solve AoC 2021 in Ivy, then watch Russ Cox's videos to see how he did it and use that to learn something about array programming -- a topic I knew absolutely nothing about going into this.

Unfortunately, Ivy really is, as Rob Pike says, a plaything. It is buggy -- if you ever write a function that returns a vector or a higher-rank array, you are entering bizarre undefined behavior territory. The array-language equivalent of "concat_map" or "flat_map" or "map-cat" or whatever you want to call it just produces garbage values, which is very confusing when you're learning about array programming for the first time ("Wait, this vector says its length is 25, but it contains 50 elements...?" or "The transpose of this array is just the first column repeated over and over??").

Beyond that, a very cool thing about array languages is that, you know, functions can implicitly act on entire arrays. You can multiple a vector by 2 and it will know to multiply every element in the vector by 2, because multiplication is defined for scalars.

But in Ivy, this is only true for the built-in functions. There is no way to write user-defined functions that have this implicit act-on-every-element behavior. Which is basically the looping primitive in array languages -- so to do anything nontrivial, you have to write it out with explicit recursion (still with the caveat that your functions can only return scalars, or you enter undefined behavior town) or rewrite your operations as binary operations with an ignored right-hand side and use "fold" to "map" them. It's bad.

The latter is crippling enough that Russ Cox [eventually forks Ivy](https://github.com/robpike/ivy/pull/83) to add support for it, but it is not currently part of the language.

Anyway that's a long comment to say: Ivy is a good, friendly introduction to APL syntax (stranding, precedence, etc) and some array language concepts, but it is far more of a calculator than a programming language.

But it's a good arbitrary-precision calculator! And if you're still interested in trying it, maybe check out this thing I made. It's an... Ivy programming environment?... that lets you run Ivy scripts and see the results inline. (Ivy's repl is... very primitive, and has to be wrapped by something like readline. Russ Cox uses 9term to get around this; self-modifying programs are my preferred approach.)

https://github.com/ianthehenry/privy

My frustration with Ivy led me to look into other array languages, trying to find one that 1) used English words instead of cryptic symbols and 2) worked. And I really couldn't find any! Someone should do something about that. :)

But your project is all about the command ytdial, so I think having a separate cmd directory is superfluous. Rob Pike also has project ivy which is laid out like this.

There are attempts to combine those...

April (Array Programming Re-Imagined in Lisp)

https://github.com/phantomics/april

> operations that apply to the whole array

like MAP and REDUCE, higher order functions are not really new to Lisp. In Common Lisp they are extended to vectors.

> list languages and array languages are quite different.

There are some common things like interactive use, functional flavor, etc.

There's also April APL: https://github.com/phantomics/april

Also the array language family seems to be stronger than ever with foss: ngn/k, BQN, uiua, and of course J but as you mentioned they're all different languages.

I love J and APL, but April takes the cake for me[1]. APL in Lisp.

I also prefer SPARK2014 instead of Rust if I am not going to use C. I've started learning Rust a few times. SPARK2014 is easier to get going for me, and it has been used to produce high-integrity software and real-world applications for over a decade, and more if you include Ada from which it sprang[2].

[1] https://github.com/phantomics/april

[2] https://www.adacore.com/about-spark

The one big use case was RabbitMQ in a messaging app, not HFT. I doubt Elixir even with Nx can compete with low-level HFT code. Python DL/ML code libraries are just wrappers around C too. Maybe if BeamAsm and Nx are used Elixir could be used for more numerical or not just distributed applications.

I've programmed in Python and Julia, and when I worked at an engineering (mechanical, entertainment engineering) company, Julia was great for its similarity to Matlab. I am a self-taught engineer, so I did not get pulled into Matlab in college.

Personally, I took to Erlang, so I could write plugins for Wings3D back in the early 2000s, but I never stuck with Erlang, or Wings3D (Blender3D was my choice and I even contributed to have it go opensource way back when). I like Erlang's syntax better for some reason, although Elixir's is beautiful too. I was not a Ruby programmer, and I had delved into Haskell and Prolog, so I think Erlang made more sense to me. I think Elixir has a lot more momentum behind it than Erlang, but at the root it's Erlang, so I think I'll stick with Erlang for BEAM apps. My favorite language is April[1] (APL in Lisp), and given my love of J, would be a better fit for any finance apps I might write. I am trying to convert some of the Lisp code in this book, "Professional Automated Trading: Theory and Practice" to April.

Maybe I'll write some equivalent Elixir code to compare.

[1] https://github.com/phantomics/april

I'm also very curious for hear from expert lispers. I've tried to find the sweat spot where lisp would fit better than what I already know: shell for glue and file ops, R for data munging and vis, python to not reinvent things, perl/core-utils for one liners. But before I can find the niche, I get turned off by the amount of ceremony -- or maybe just how different the state and edit/evaluate loop is.

I'm holding onto some things that make common lisp look exciting and useful (static typing[0], APL DSL[1], speed [2,3,4]) and really want to get familiar with structural editing [5]

[0] https://github.com/phantomics/april - APL dsl

The 2 0 at the start of the APL line above controls the mirroring behavior. The second number can be set to 0 or 1 to choose which side of the image to mirror, while the 2 sets the axis along which to mirror. This will be 1 or 2 for a raster image but this function can mirror any rank of array on any axis.

April was used to teach image filtering in a programming class for middle-schoolers, you can see a summary in this video: https://vimeo.com/504928819

For more APL-driven graphics, April's repo includes an ncurses demo featuring a convolution kernel powered by ⌺, the stencil operator: https://github.com/phantomics/april/tree/master/demos/ncurse...

#1: Thanks to J, I was able to get in the global Top 100 in the first day of Advent of Code. I've never done this before and I'm feeling a bit emotional. Thanks, J. #2: April 1.0 Is Released | 4 comments #3: BQNPAD — a BQN REPL with syntax highlighting and live evaluation preview | 8 comments

APL + Lisp =

https://github.com/phantomics/april/ and yes it is used in production©!

> What pushed the development of April really is that April is used by a hardware startup called Bloxl (of which I am the CTO). There are other users but Bloxl is the flagship application.

https://www.arraycast.com/episodes/episode23-andrew-sengul

Bloxl in use: https://user-images.githubusercontent.com/3721004/159686845-... See also the ELS conference 2022.