ELI – A System for Programming with Arrays | Hacker News Reader

ELI – A System for Programming with Arrays

fastarray.appspot.com

43 pointsemmanueloga_28 comments

APL is fundamentally cool and I'd like to think it will make a comeback. But it seems that most modern APL-derived languages focus on trying to squeeze everything into ASCII as concisely as possible.

The following is an example of quite readable ELI with only a handful of symbols:

    c,[1.5]32+1.8*c<-$_10+5**!10

It's not bad, but when all you have is ASCII, dense notation will inevitably look like line noise.

APL's graphical notation was one of its original inventions, but custom keyboards weren't a viable solution in the PC era... But today the situation is different again. High-DPI displays and touch screens are becoming standard.

Would it be possible to reinvent APL notation to take advantage of high-res graphics and natural input methods? I'd love to see a tablet-only reinvention of APL that doesn't have a keyboard at all, just a number pad and painted gestures.

Honest question: if I know J, what can I get from learning APL? When first looking at array based languages the symbols used by APL scared me off and I decided to go with J, now I wonder if the very same symbol set wouldn't be better than pure-ascii.

I did otherwise when interested in the APL/J/K world: the ASCII use of J scared me and I decided to learn some APL first and then, go through J's ASCIIness (I'm still early in the APL part, though.) I find APLs symbols nice and terse, for some of the basic things it's like learning a good editor's shortcuts (be it emacs or vi[m].) You no longer think about how to do X, but what you want to achieve and your hands do it. Of course, I guess with J it's exactly the same once you know enough of it, I just took the other route.

IMHO learning about a new language (without becoming proficient with it) is always good as it makes you think about the one(s) you're proficient with.

> learning about a new language (without becoming proficient with it)

Mostly true, but there are languages which are completely useless without becoming proficient with them. In my experience Forth and J are such languages: you can "learn about" them, but you won't really understand them without using them for some time. So I suspect APL, K, Q and Eli here are similar; the question is what will I gain from becoming proficient with one of them or alternatively is it worth becoming proficient in one of them if I'm already proficient with another.

+1.

Most text editors operate text substitutions (like "<-" turning to "←" automatically), so ASCII doesn't seem inevitable anymore (and I believe it's even truthier with virtual keyboards).

I worked in a company where APL used to be very strong (large french truck manufacturer) and they even had lots of programs written in Scheme for assembly-line optimisations in the late 90s. Most of those have been rewritten (should I say... painfully rewritten, and now buggy) in Java in 2005.

I feel like APL/CLisps/etc. were the right solutions but developers/managers were/are scared when they saw some of the mathematical/proof concepts they had to use, and were afraid of when they learned about them at the university.

We had an APL implementation and it was replaced 5 or so years ago.

It wasn't because of scared management. It was because they were paying for language knowledge not business knowledge. What replaced it, mostly C++ and Python, had better tooling and a wider pool of subject expertise to draw from.

Honestly, we need a programming language, any language, that is genuinely designed around the limitations of touch input while sticking to a textual style. I can find lots of interpreters for various languages on my phone, but all rely on stock text editing controls to make me peck away at whatever I want to write - even the MIPS assembler I downloaded made you edit a text file. If we just embraced denser notational style, we could do a lot better without being particularly more elaborate in how the code is displayed or parsed.

I dream of a programming language that would bring coding closer to Japanese brush painting. APL's terseness would make it a suitable foundation for that.

Imagine you're handed a tablet that shows such a program. At first glance it's a unique calligraphic image, but when you know the language you can also parse the data flow and manipulated types intuitively upon seeing the shapes. And since it's a dynamic digital document, you could zoom in, isolate parts, or even run "live coding" style experiments to see what the painting actually does.

Amateur ShoDo practitioner here: not sure that "Japanese brush painting" is actually a good idea for programming. Maybe you mean something like the Korean writing system: Hangul (http://en.wikipedia.org/wiki/Hangul)?

For what I know, Hangul "glyphs" provide consistent encoding (see also: http://en.wikipedia.org/wiki/Featural_alphabet).

In Japanese Kanji the "elements" (Radicals, or Bushu, see here: http://en.wikipedia.org/wiki/Radical_%28Chinese_characters%2...) do _often_ work as semantic indicators (see for example Radical 85: http://en.wikipedia.org/wiki/Radical_85 which usually implies some connection with water or other liquids) but the connection may be obscure, or even look random - as an example (among hundreds) see 淋 where the radical for water, followed by two "tree" radicals means: "lonely, deserted, abandoned".

Yeah, my idea is pretty vague. I didn't mean actually using any particular Japanese/Chinese/Korean writing system for programming, but rather something more abstract where elements of the calligraphic aesthetic would be adopted to serve algorithmic notation.

Something like "this large brushy swoop here is the part where all those matrices on the left are reduced, and then on the right we have these leafy things that map them into coordinates"...

Ok, well - maybe I'am going offtopic now but what I'd like to have is a _query language_ based on gesture. I.e. something to analyze data with. This video https://www.youtube.com/watch?v=jbkSRLYSojo gives an idea of what I'd like to have, but of course in this case the data "transformation" are pre-scripted and the speaker goes through a sort of coreography. Imagine being able to play with data interactively by moving stuff around in space around you.

Not all APL-like languages do the conciseness thing. Numpy doesn't. Recently a colleague had some imperative code for computing a specific random variable (average revenue given a certain product selection process). Roughly speaking, the for-loop you expect. In code review I changed it to:

    revs = dot(dirichlet(alpha, NUM_SAMPLES), rev_by_category)

Net result - this draws NUM_SAMPLES dirichlet vectors, dots them with the rev_by_category vector, and generates a list of NUM_SAMPLES of the corresponding random variable.

Or:

    total_variation = var(data.flatten())
    first_axis_var = var(mean(data, axis=0))
    second_axis_var = var(mean(data, axis=1))

From what I understand, this is definitely idiomatic J translated to Python. In general, idiomatic numpy code will always be array oriented since that's (until recently) the only way to shell out to C.

So from what I can tell, APL isn't dead. It's just spelled out in easy to read executable pseudocode.

We have some pretty significant matrix processor apps made with APL at the company.

I'd really like to bring this functionality to our web apps, but it seems HTTP interface and external APIs are not available in these implementations. How can you use ELi, or any APL, with a web app?

ELI site is down at the moment, but I read couple of their docs through google cache. There is support of compiling into C, but what about support for C interface? Or HTTP out of the box?

CGI - or, if you insist, FastCGI - works surprisingly well in 2014.

Well, yes. Simple solutions work too. I was burned trying to write sophisticated Python stuff with plain CGI back in the days of Apache 1.3.

CGI does need something that can start in at most one geological age, yes. FastCGI is, well, faster, and is pretty simple as long as you don't support multiple concurrent requests to a single backend.

Please check a mirror website here http://cs.queensu.ca/~chenh/eli/, if you find the http://fastarray.appspot.com/ is not accessible.

Hanfeng Chen

You may also like http://prog21.dadgum.com/114.html, which is a slightly gentler introduction to the APL world.

Cool, will check it out!

There are lot of recommended books about a selection of languages regarded as more powerful/expressive/safer than the mainstream, but there's not so much good information about APL, I don't think. Every now and then, I hear different people give a hint about APL's power (not too noisily though... as if they did not want to completely give away the secret :).

I keep wondering what problems are good fit for it. From far it doesn't look like a general purpose PL. To my untrained eyes it looks like some sort of query language that you can somehow bend into doing other things (in the same vein you can use SQL to render the Mandelbrot set [1] :).

And then there's the whole clones/successors/spin offs situation. If I were to learn APL today, I wouldn't even know were to start. ELI looks like a good candidate.

1: http://wiki.postgresql.org/wiki/Mandelbrot_set

There's GNU APL as a free APL implementation. As for learning APL... It's essentially learning what all its symbols do (there are some references for free online from the vendors of paid APLs, just avoid reading about their extensions,) even Wikipedia's page about APL works as a fast reference. I just use it to play around with numbers (yes, I also wrote a Mandelbrot set with it, a one liner that fits in a tweet,) and I'm trying to enhance a little its usability with a iPython-like in-browser "REPL" specially suited for my uses.

Exist a array language with more "normal" sytax (ie: more like python than APL, so instead of symbol use words?)

Check out Q from Kx Systems. It uses an SQL-like dialect but is still powerful and expressive. Here are some simple example programs: http://code.kx.com/wiki/Sample_Queries

I have seen this before, but now I do the tutorial and the experience was not as bad as I have imagined.

I hope to draw some idead from it (I'm triying to build a relational language)

Keep me in the loop as you work on your project. I think the world has a lot to learn from array languages, and there still isn't a strong open source option. Contact info in profile.

J is another APL variant using ASCII instead of special symbols. You can easily label or rename any function to make it more readable, but it goes against the idea of learning the symbols for conciseness ala mathematical symbols. There is a recent blog entry about using J for spectral clustering in quantitative neuroscience [1]

I am now very comfortable with J, and I am checking out ELI for comparison. I like the idea of the compiler, however, in J the math routines are very fast, well-crafted c libraries, so the interpreter is very fast with results.

[1] http://procyonic.org/blog/?p=98

Am I the only one reminded of Abre Los Ojos?

How well does it work when doing matrix multiplication or combining arrays in comparison to standard methods in R, matlab etc.?

Reply on news.ycombinator.com