Conway's Game Of Life in APL

Would you prefer something like this numpy then? def life(x): y = np.array([np.roll(x, -1), np.roll(x, 0),np.roll(x, 1)]) y = np.array([np.roll(y, -1, 1), np.roll(y, 0, 1),np.roll(y, 1, 1)]) z = y.sum(1).sum(0) a = np.array([3 == z, 4==z]) c = np.logical_and(np.array([np.ones(x.shape), x]), a) return np.logical_or(c[0], c[1]) Video of Scholes building up the life APL expression can be seen here: ▶ this video

There is also the J language [1], which I understand to be a GPL reimplementation of APL. Since they went with pure ASCII, you presumably have to hold down modifier keys less. I never used either language, so can’t comment on how useful they are. But I’ve always been fascinated with APL as an idea, especially after watching this [2] person implement Game of Life as a compact one-liner in APL! (With that compact code, maybe you press modifiers less overall than when writing more traditional/verbose languages?) [1]: link [2]: ▶ this video

> that you consider a failure It isn't a failure. It simply isn't optimal. Just my opinion, of course. Which means I could be very wrong. > "the pointer returned by this function must be freed by the caller" or "the pointer returned by this function must NEVER be freed by the caller." Those two are examples of bad programming. Both constraints are almost guaranteed to create, at a minimum, an unmanageable mess and, at worst, very dangerous software (think embedded controller for a robot or a rocket). While I have not looked, I would be very surprised if something like that existed in the Linux codebase, which is C. > that doesn't mean C has to be the absolute last systems language ever in the history of computing. I don't think I have suggested this at all in this conversation. My position is very simple: Don't blame the language for bad programming. This is rarely the problem. The fact that someone can cause a mess using pointers does not mean pointers are the problem. They simply don't know what they are doing. The Linux codebase uses pointers everywhere, right? Is it a mess? No. Maybe that's because they are using the language correctly. I am also not saying that all work in evolving programming languages should stop because C is perfect. Not the case I have made at all. What I will say is that --again, my opinion-- quite a few of the modern paradigms are complete nonsense in support of lazy programmers. The question to ask might be something like: Would you have been able

Contrarian answer: Conway's Game of Life in Dyalog APL ▶ this video It feels like the logical end state of "clever" code, for better or for worse. Or, alternatively, what happens when a standard library is gigantic but each keyword is 1-2 characters.

I’m adding SNOBOL to my list of modernist languages. “Everything is pattern-matching” fits the modernist ethos. On the other hand, what about APL? Although the syntax looks just as much like line noise as Perl’s syntax, it is actually a very elegant language. Is APL also a modernist language? ▶ this video

Seems then you'll probably dislike apl - here's the full implementation of Conway's Game of Life in 53 characters: life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +⌿ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵} And the explanatory video behind it (quite approachable!) ▶ this video

> Here's a video that really illustrates the power of this paradigm: ▶ this video Amazing game of life code!

> My point was that general programming usually looks more like writing the sorting algorithm than simply calling it. Thus, I would be more interested in seeing real examples of how the properties of J allow you to write algorithms more concisely or otherwise better. Ah - I see. Here[1] is quicksort in j. John scholes's videos are excellent and very illustrative, though they deal with apl rather than j; conway's game of life[2] and sudoku[3]. > The article showed how J solves some mathematical problems with built in functions or their built-in modifiers. But in general programming, you won't find a function that does exactly what you wanted, maybe with a little adverb. You'll usually have to write that function yourself, to describe how it works in terms of some of those pre-existing functions. Right. This is true, but you generally stay much closer to the builtins in j than you do in other language. > Note that your second example could be expressed as something like > x.OrderBy(y => y[1]) > In C#, assuming x is int[N][M]. I understand that J's version can work with many other shapes of X, but that is hard to appreciate without seeing example of how that comes in handy when writing some other (hopefully well known) algorithm. Right; you mentioned sort predicates, so I was giving an example of a way in which you could sort according to another relation. My point is: being able to change the layout of your data so easily can obviate sort predicates. (Though I do think a sort a

APL (and I assume J) uses a large range of special graphic symbols as part of its syntax, which can be difficult to internalize for folks coming from other languages. It can be easily construed as mysterious or magical lettering (arcane rune). My favorite video to illustrate this is Conway's Game of Life written in APL: ▶ this video

Try watching this video; it will only take you 8 minutes, but within 3 minutes you should have an idea of why array languages are different from having an ndarray library available in Rust or having typeclasses in Haskell: ▶ this video After you watch that you will of course suspect that APL and other array languages like J are a sort of DSL for things like numerical linear algebra, which is of course what Numpy and Octave are. (Even though the Game of Life isn't linear algebra, it's very clearly matrix-based, so it doesn't seem that far off.) Dyalog has posted some other videos demonstrating the use of their proprietary APL for different things, but I think a more interesting one is link , by J inventor Roger Hui. This is an hour and a half, but it demonstrates some approaches to reducing different problems to multidimensional arrays, of pointers ("boxes") in some cases. This ought to be enough to convince you that there's an alien kind of thinking here, quite different from the Haskell and Rust approaches, that can be applied to a wide variety of problems. Now, I'm not Stevan Apter, so I'm not going to try to convince you that this alien kind of thinking is better . But it's clearly different , and different ways of thinking work best in different situations.

I think the key to understanding APL is realizing that it’s not built for Programmers; it’s built for Mathematicians. Here’s a fine half-hour introduction to APL in action: link 1:00-2:00 is the motivation for APL—or any DSL—in a nutshell. (“conversational computing”, “users who are [not] professional programmers”) Or, if you’re happy to sit back and see math magic happen: ▶ this video For all its mechanical advances over the last 40 years, it’s shocking how far our technology has regressed philosophically.

I always liked this example: Conway's Game of Life in One Line of APL ▶ this video It's esoteric as one-liners tend to be, but I think it's a fascinating glimpse.

The following video is probably reasonably well known, and I wish that I had a more intelligent commentary than to say that it blows my mind, but it does I think bear out the point of expressivity rather well. ▶ this video Conway's Game of Life in some 50 characters of APL.

For an infinitely more relaxing experience of life in APL, may I recommend: ▶ this video I've watched it many times but I still expect him to mention happy little trees :)

While we wait for the site to come back up please enjoy this amazing video showing Conway's Game of Life in APL: ▶ this video

life←{ ⍝ John Conway's "Game of Life". ↑1 ⍵∨.^3 4=+/,¯1 0 1∘.⊖¯1 0 1∘.⌽⊂⍵ ⍝ Expression for next generation. } ▶ this video

I've always found APL really intriguing. A professor of mine told me about how one of his students used to be able to solve ACM competition problems incredibly fast by simply not having to type very much. There are some insane videos on youtube of people solving problems in APL [1]. But, you know - it's write once, read.. never again. [1] ▶ this video

It has an incredible amount of elegant power for some things (see ▶ this video if you want to immediately fall in love). But I've found that trying to use it for most things just isn't worthwhile. It feels like cheating every time I have to escape from its array programming core to the more familiar flow control structures that only came along in later versions of APL. I think it makes a good puzzle language (i.e. the fun comes from figuring out _how_ to say something rather that just raw getting stuff done), but unfortunately, it's even more of a puzzle to figure out how code that someone else wrote works. For full context: I've spent more time using J than APL itself.

"Notation as a Tool of Thought" by Kenneth E. Iverson in his 1979 ACM Turing Award Lecture. link "Language as an Intellectual Tool: From Hieroglyphics to APL" by Donald B. McIntyre in IBM Systems Journal Vol.30, No.4 1991, p.554-581. link Conway's Game of Life in one line of APL link Conway's Game Of Life in APL ▶ this video

Heh. The traditional snippet associated with that argument is the Game of Life in APL. ▶ this video And yes, this is specifically why I opted to redefine "power" in my post; the standard definition leaves out some points that I've found to be essential.