Klong – a simple array language

I've taught myself Forth and K. Each time, it was like going back to the beginning of learning to program. Familiar algorithms are hard to implement. Subtle typos and confusion abound. It takes time to learn how to break down the syntax of the language and read the code fluently.

But you begin to see patterns. You write programs and begin to feel out the fringes of the language. You start to be able to write small programs that work correctly the first time.

With Forth, I learned to track the stack in my head. With K, I learned to think in parallel, collective operations. They are eminently learnable, and when you make it through the learning process, you will emerge with new tools for thinking about problem solving.

I now find K a very pleasant language to reach for when I want to tinker. I can write complex and interesting programs quickly, and completely rewrite them in seconds when I get a different idea. Here is a GIF recording of me making a series of programs in K, perhaps demonstrating the kind of fluidity you can get when you become conversant in the language:

https://raw.githubusercontent.com/JohnEarnest/ok/gh-pages/ik...

I expect that learning to read (and write) K is a lot like learning regular expressions. I don't know K, but regular expressions are eminently useful in everyday life, so I've had the experience of learning to casually read and write them.

It's a lot like learning any new language, and probably spoken languages are a better comparison than programming languages.

At first, you have trouble even differentiating boundaries between words, but as you gain experience, your brain extracts the features as units. You begin to see units directly, which gives context that assists in reading component characters, whereas before you'd have to first labor through each character individually to construct the context.

I had the opposite experience with learning J. After a couple of days meditating about concept of rank (here is the most relevant part of the excellent book - http://www.jsoftware.com/help/jforc/declarations.htm#_Toc191...) it went much easier. On the other hand, with Haskell I can even write monads myself now, but I hardly see their usefulness yet.

I recently started coming to grips little by little with J. The best way I found was doing /r/dailyprogrammer "easy" problems.

You need to treat it as a conversation with the REPL and build up little parts.

Also, reading other people's solutions to problems you've solved yourself is enlightening.

Heh, I'm in a similar boat to you. I actually tweeted the other day[0]: "Ah, APL/J/K. Time for my annual crisis of thinking everything I've ever learned about programming is wrong...". It's so interesting to me that some people claim fantastic productivity with it, while others find it completely impenetrable. I've spent maybe a day or two trying to get over the initial learning curve, but have never made significant progress.

On HN, geocar and beagle3 are both names that come to mind as proponents of these types of languages and have very interesting comments. You could search their name for more info, probably. There's a couple good breakdowns of code here[1] and here[2].

[0] https://twitter.com/losvedir/status/636034419359289344 [1] https://news.ycombinator.com/item?id=9120246 [2] https://news.ycombinator.com/item?id=8476016

One thing that really helped me in the beginning was to pronounce K programs properly, i.e. know what the operators are called and read programs to myself. Incidentally that also was the way I approached math in the beginning.

For example, the column formatter from http://t3x.org/klong/klong-intro.txt.html:

(-|/{#$x}'x)$x

It is pronounced (Negate Max-Over (Size [of] Format [of] x)-Each x) Format2 x

Of course, doing this will not lead to instant enlightenment, but it really helped me understand K.

The example from Wikipedia is a bit more challenging. What also complicates things here is that K overloads operators, so it may not be obvious, for instance, that ! means Modulo and not Rotate in that program. That's why I started developing Klong in the first place.

Thanks to everyone for the great responses (and apologies for hijacking the comments a little here, which should have been about Klong) - much to delve into!

Feel free to borrow whatever you need! Note though, that Klong is based on the S9core toolkit[1] (included in the package), which might take some getting used to.

[1] http://www.t3x.org/s9fes/index.html

I've been thinking about this a lot myself, these are my main problems with them as well. I've starting messing around with an unholy abomination that is taking the worst features of Ruby, Perl, and J* and making such a postfix language. I'm taking the rest of the year off to work on this so hopefully it yields something fun and stupid.

* - I love the notation in J/K/APL but really want to see it written left to right, much like chaining together map/reduce/filter methods in Ruby with dot notation. I also want auto-vivification from Perl and the use of implicit variables for map/reduce/filter.

I look forward to messing with Klong.

Coincidentally, a stack-based concatenative array language is exactly what I'm working on right now.

It combines all the readability of K with... all the readability of Forth.

It's at https://github.com/alpha123/vio if you're interested, but very much WIP. The VM is rather simple if you feel like poking around.

Other notable features would be built-in parser combinators (with an unreadable postfix regex-like syntax). Concatenative parser combinators are pleasantly surprising to use.

What problems go away if you use a non-text IDE like http://peaker.github.io/lamdu/ ?

You may enjoy lang5, which is a fusion of forth and APL. I find it a fun language to play with and it is easy to read (though not as terse as APL/J/k, of course).

[home] http://lang5.sourceforge.net/tiki-index.php

[examples] http://lang5.sourceforge.net/tiki-index.php?page=About