Is this the lull before the storm?

I guess so.

We'll see...

Yesterday was intense too.

@Adám it was. Is it usually this quiet after an intense day?

I don't know. Hard to tell. I'm just busy with other things, and nobody is asking any questions or posting any challenges.

Would be a good time to review last APL Seeds.

CMC: implement gram-schmidt orthogonalization. That is, implement a function that accepts a matrix and returns a matrix M with the same shape, such that (⍉+.*⊢)M is a diagonal matrix and the input and output matrices have columns that generate the same space

(i.e every column of M is a linear combination of the columns of the input and vice-versa)

how much time left for apl seeds? 28 minutes or 1h28?

The latter.

@Adám uh, forgot it was also a scheduled event, thanks

@user9772759 Hej Fredrik. I'll get you write access to this room soon.

@Marshall Are you about to begin?

@Adám Yes. Hope there are some people here.

I'm not sure I feel like a people today, but... :)

I'll start with a recap from last time. We are doing some parsing of a BQN expression that has only functions, numbers, and parentheses.

x←'((-3)+√(3×3)-4×2×1)÷2×2'

So far we have found where the opening and closing parentheses are and reordered them so that matching pairs have the same location.

In BQN:

o←'('=x⋄c←')'=x⋄d←+`o-c⋄b←/o⋄e←/c

{(⍋𝕩⊏d)⊏𝕩}¨b‿e

In APL:

o←'('=x⋄c←')'=x⋄d←+⍀o-c⋄b←⍸o⋄e←⍸c

{⍵[⍋d[⍵]]}¨b e

So the idea is that b is the indices of opening parentheses and e is the indices of closed parentheses, and we can sort each of these lists of indices by their nesting depth to match them together.

What I'd like to do now is actually use this information. I want to convert my BQN code to reverse Polish notation (RPN), which is the format used by stack-based virtual machines like WebAssembly.

I don't think we'll get all the way through, but we should be able to make some progress.

The crucial idea is that all we need to do is move every function past its right argument. For example, -3 becomes 3- and 3×3 becomes 33×. But we can't just move functions over by one because sometimes the right argument is more than a single number.

For example, ÷ is the last operation performed and it needs to go all the way to the end.

In APL/BQN, this idea is captured by the idea of a "long right scope": the right argument of a function is everything to its right up to the next enclosing parenthesis. The parenthesis matching code we did earlier can help us find that enclosing parenthesis.

But first, I'm going to look a little at this "move a function right" operation. Let's say we have a flat expression such as 3+√2×8.

Because there are no parentheses, every function's right argument goes up to the end of the expression.

So we want to move every function "to the end", except not really because only one of them can actually go to the end of the expression. But nonetheless that's the idea I'm going to start with.

@Marshall going from right to left, can't we just take every function we find and move it to the end of what we currently have?

@RGS Yes, but that sounds very iterative.

To start with, I'm just going to identify the functions in the code.

x←"3+√2×8"

¬x∊•d now gives

[ 0 1 1 0 1 0 ]

I'm going to construct a permutation (as a list of indices) that will take us from BQN to RPN in one step. I'll start with the identity permutation.

↕≠x

[ 0 1 2 3 4 5 ]

Or ⍳⍴x in classic APL.

Let's assign f←¬x∊•d, indicating functions.

How far over do I need to move my functions? I can subtract the identity permutation from the last index to find this:

f×(¯1+≠x)-↕≠x

[ 0 4 3 0 1 0 ]

Adding this to our identity permutation gives us... not a permutation:

(↕≠x)+f×(¯1+≠x)-↕≠x

[ 0 5 5 3 5 5 ]

I need to not just add to the index of each function, but subtract one from the index of everything to its right. In other words, we want to subtract from each index the number of functions that appear before it.

That's a prefix sum!

+`f

[ 0 1 2 2 3 3 ]

Since this starts subtracting at the function itself, rather than after it, we should add one to the function offsets, giving f×(≠x)-↕≠x. That's actually simpler, since it uses the index one past the end rather than the last index. Similarly, with parentheses it will be the index of the parenthesis itself.

Add it all together now:

(↕≠x)+(f×(≠x)-↕≠x)-+`f

[ 0 5 4 1 3 2 ]

It's a permutation, at least. Let's set l←≠x since x is never used directly, just its length.

Quick Question: Why are we writing the interpreter in APL/BQN? I thought you'd said you didn't know very much about bootstrapping. And I'd have thought it'd be written in something like C...

@AviF.S. I like writing in BQN.

Also, Aaron's work on Co-dfns indicates that a compiler in BQN can be faster than one written in traditional C style, because array operations are very easy for CPUs or GPUs.

@AviF.S. - Also, sometimes it's easier to express a concept in the language you're implementing, and then, once you have fully analysed it, go back to the actual implementation language to code it.

So at this point I would think the BQN to RPN code is

x⊏˜(↕l)+(f×l-↕l)-+`f

@Marshall Of course; same! But if the purpose is to write an interpreter wouldn't it be more helpful to write it in the language we're using. Imperative OOP programming is a very different style...

[ 38×+2√ ]

But this isn't actually right...

Oh, the indices tell where each character goes, not where it comes from, so I need to reverse it with a Grade.

@JeffZeitlin Agreed when it's something like Python → Java/C. But not from one domain to another IMO. It's like implementing Prolog or Haskell in itself instead of in C, no?

x⊏˜⍋(↕l)+(f×l-↕l)-+`f

[ 328×√+ ]

Probably the code golfers who are familiar with stack languages can verify that this is equivalent to the BQN 3+√2×8.

The algorithms we're using are a million percent unrelated to the way they'd be done with a C-like lang. For instance the parentheses bit is completely array-oriented. There's surely well-established and very different algorithms for C-like parsing

@AviF.S. GHC is implemented mostly in Haskell. Did I miss the point?

@Marshall Not the core of it though... it doesn't make sense to parse Haskell with Haskell

@AviF.S. Yes, and the APL algorithms are faster because they make use of vector instructions or run on the GPU.

Actually, I think it should be 28×√3+ for a stack language

@Marshall Do you mean to say then that you'll be writing the BQN interpreter in Dyalog?

Because if so, that makes sense!

@JeffZeitlin It's the same result since + is commutative. If you replace + with - it doesn't match anymore.

@JeffZeitlin +←1

...

@JeffZeitlin Wait, actually they're equivalent. The order doesn't matter:

OK, yeah, that's right.

Assuming that - subtracts the left argument (deeper on the stack) from the right. That's how WebAssembly works, at least.

I was reading the stack backward, initially.

@AviF.S. No, I'll be using BQN. I will be working to make BQN's functions fast.

@JeffZeitlin Ah!

@Marshall So you are bootstrapping?

Could I butt in with a bit of a stupid question? What is BQN? I did some googling but found nothing.

@AviF.S. Yes, currently with BQN2NGN and I plan to switch to dzaima/BQN. I never said I didn't know much about bootstrapping.

@user9772759 It's @Marshall's APL dialect

@user9772759 github.com/mlochbaum/BQN

APL-like language, I mean!

@user9772759 "Big Questions Notation". A new language created with all the lessons learned from over half a century of APL.

Thanks for the link!

@Marshall Ah!

Since I am currently doing my work in BQN, I find it easier to do these things mainly with BQN. But I should also provide an APL translation of that last part now...

Should be:

f←~x∊⎕d

l←≢x

x[⍋(⍳l)+(f×l-⍳l)-+⍀f]

So, the problem we're currently working on... is translating a "math" expression to reverse polish. Or did I miss something?

@user9772759 Essentially. We're using APL/BQN (same grammar) for the "math", so there are some differences. Don't know how familiar you are with APL.

@user9772759 This is episode 2 of the "APL Seeds" series on implementing APL-like languages. The language in focus is BQN, but it all applies to any similar language.

The main thing to know is just that "long right scope" thing I mentioned here.

Heh... have been using it for multiple days now... so not quite fluent of all symbols. But I do understand the concept of "long right scope" (and I agree that it's quite key)

That is probably enough code for today, so I'll answer questions and talk a little about our general strategy going forward.

If anyone's following along in the current "BQN" (tiny subset) compiler, we're right in the middle of Parse.

@Marshall Was/is the point of this discussion that you want to translate "math" into reverse polish for the purpose of efficient implementation of it in BQN?

The thing we just did is a little like ⍋(fe⌈↕l)-ia when sel is being computed. fe are the function endpoints, and ia are index adjustments for the things we move them past.

@Marshall Is that sort of our reference/textbook? Will you be going through that whole file?

@user9772759 The most direct purpose is to generate WebAssembly code: you just replace each number and each function with the right sequence of bytes and you have the body of a Wasm function.

@Marshall and what are the "right" bytes to replace each number/function with?

Ah, to make a BQN to WASM compiler.

Of course the reason Wasm uses this format is that it's more generally a good intermediate representation for compiling. You can do various optimization passes on it and also turn it into x86 or some other machine code by allocating registers.

@RGS Functions in the Wasm docs. They're just arbitrary numbers.

@Marshall ah ok, thanks

So we are converting BQN to wasm so that.... we can run the code in a browser? is that it?

@user9772759 Which does work. I am currently doing automated tests in Node since the BQN2NGN prototype is Javascript. It runs BQN2NGN to compile the test cases into numeric arrays and then turns these into JS byte arrays to run as Wasm.

Nice

@RGS Yes, I'd like it to run in the browser so people can use it right away. Wasm can also be run natively anywhere so it's nice for portability, and it's a reasonably easy format to target.

@Marshall Ok, I think I understand.

A little frustrating that you can't run Wasm bytecode directly from Wasm and have to compile it first by calling out to a Javascript helper. With machine code you can just write and jump.

@Marshall wdym?

@RGS For a lot of reasons it's useful to compile or recompile code as the program is running (JIT compilation). But WebAssembly's not really designed for this, so while you can generate the Wasm code, that is, an array of bytes, from a Wasm program (such as a running BQN program), you have to do a lot of work to turn that code into a function you can call. And subject yourself to overhead from whatever is compiling your Wasm to native code.

I think that ends our APL Seeds session. I'm still here for questions, though.

@Marshall how long have you been working on BQN?

@Marshall Thanks, Marshall. I wasn't able to participate actively as much as I wanted to, due to other obligations, but I've been following along.

@Marshall so what you are saying is that there is an extra step (a costly step) between generating the bytecode for a BQN program and then executing said bytecode?

@Marshall Thanks for your time!

@user9772759 We had some discussions about new array language ideas within Dyalog starting in February or March. I made a prototype interpreter in May after giving notice to leave Dyalog and started on the real thing when I left about three weeks ago.

@RGS Assuming a Wasm backend. I plan to work on other backends as well, although of course they won't be usable on the web.

@Marshall "assuming a Wasm backend"..? if the whole thing is running in Wasm?

@Marshall (Take my feedback for what it's worth, i.e. probably not much. As I said, I have several days of APL experience now, and a few weeks of K about 15-20 years ago).

@Marshall That said, reading your github repo now... some of the fundamental ideas of BQN sounds really interesting and appealing. OTOH, can't say that I like the idea of "typing" based on names (feels ... Fortranish?) or the glyph patterns (e.g. superscripts are modifiers). The latter is probably just something to get used to though...

@RGS Nearly everything will be written in BQN, and the parts that generate Wasm code will be fairly small, so it should be possible to replace them and target another architecture easily. You would choose the appropriate BQN implementation or backend based on where you want to run it, like most software.

@user9772759 The way names are written describes how they are being used at the moment, not what the value is. It's more like the way func in C is a pointer except func(... is a function call.

@Marshall No... I get that. Not sure that I buy the comparison to C though. "func" is a pointer and "func()" is how you call a function pointer, but I digress.

@Marshall Also, you have 6 types, 3 of them have naming requirements. I.e. naming something F is declaring it to have the type "function".

@Marshall So it's half typed by naming, and half untyped?

Yay... I got a name now :)

@FredrikNiemelä No, the point is that a value named F doesn't have to have a function type. You can also use characters, numbers, or arrays, which return themselves when applied, and modifiers or compositions, although these will give an error when applied.

The syntactic role tells you which things apply to which other things, but it has no semantic value. It's discarded after parsing.

"although these will give an error when applied" wouldn't that mean that you can't in fact have F be a modifier or composition?

@FredrikNiemelä You can, you just can't call it. Obviously it won't usually happen in programs.

I'm a bit confused here. You say that (what I call) the type information has not semantic value and will be discarded after parsing. But... if you apply a ... thing (is value the correct term) of the wrong type you will get a parse error, right?

The following would be valid:

_m←{𝔽𝕩}

F←M

_n←_f

Oh... so a value "x" could "contain" anything, including a function, but you would have to assign it to something like "X" to actually be able to use it?

Then _m, _f, and _n are all ways to use that modifier.

@FredrikNiemelä You have to spell it like X. The spellings x, X, _x, and _x_ are all the same name, with a different syntactic role.

AAaaaaaaah

Wow

First reaction: Don't like it!

...but that makes much more sense :)!

Thanks for explaining (and deducing what it was I didn't get)

@Marshall ahhhh, I also hadn't understood [is this correct English??] this!

So... "_" basically becomes a "binding" operator (with "infinite" precedence)?

It's definitely annoying to have something that's so far from a programmer's normal expectations, but as you see the actual concept isn't too hard. The good thing is it seems I will get a lot of practice explaining it!

So... if I use a function as an argument to a modifier or composition, should it be uppercased?

@FredrikNiemelä Sort of? You definitely have the right idea, but I don't know whether that is a good way to think about it (not saying it's bad, I'm genuinely unsure).

since I'm not calling the function (where I'm writing it), I'm using it as a value

@Marshall Yeah... don't think it's a good way of thinking about it, but it helped me conceptualize

Similarly... since functions are not fully first class (right?) if I give a function to a function it should be lowercased, right?

@FredrikNiemelä Value and function roles are identical as operands, and the role you use will disappear (this is in some ways a problem).

If that function takes the function as a parameter, say "p", can and should it then simply call it as "P"?

@FredrikNiemelä Yes to the second half. For the first half, that is what makes functions first class, since you can write any variable lowercased.

@Marshall Yeah... the problem you linked to is kinda what was getting at. I think this is a bit of a fundamental problem (and IMHO a sign that this is maybe not great?)

Now I understand your comparison to C earlier :).

Basically uppercasing is exactly the same thing as appending ().

And _ and case is not actually part of the "name" of the value.

@FredrikNiemelä It's a third of the way down the list, which is getting into pretty tolerable territory. It's the only way I know of to have something that looks like APL and is context-free, so I'd be okay with a lot worse. And it makes functions first class as a bonus!

Mmm

So... "F f" is calling the function f with parameter f. Is "f F" simply an error? What about "F F"?

@FredrikNiemelä Per the tokenizing rules, yes. You don't have to draw the line between scanning and parsing there, but I think it makes a lot more sense that way.

Ok... I dislike it a lot less after understanding it :)

@FredrikNiemelä f F with nothing to the right is an error. F F forms a 2-train, which is equivalent to F∘F.

Ah... so this also makes ∘ un-needed?

(the dot above was supposed to be Jot)

...that's a very nice side effect

(maybe it's not a side effect? Maybe that was one of the reasons for doing this?)

@FredrikNiemelä Needed is a weird word (after all, you can simply define ∘ as {𝔽𝕨𝔾𝕩}), but yes, you could use 2-trains instead of ∘ everywhere if you wanted.

True

@FredrikNiemelä Trains can be included in ordinary APL and are in most actively developed APLs (GNU is the only exception I can think of). The real benefit is not the 2-train, which is redundant as you note, but the 3-train, which lets you call several functions on the same set of arguments in a very natural way.

@Marshall Thanks for all you patience with my (in retrospect) not so insightful questions. :)

@Marshall I'll definitely read up more on BQN, maybe I can offer some more intelligent comments next time.

@FredrikNiemelä Thanks for asking! One of the most important things in programming language work I think is figuring out how people do/can/should relate to programming ideas or paradigms, so this sort of discussion is actually really valuable.

@RGS Did you make any progress with the 18.0-changes to APLcart?

@Adám nope, I made literally no progress at all

but actually now is a good time to work on it

is it a good time for you as well or are you doing something with ⊆⌈?

I know I said no rush, but then I remembered that I'm giving a webinar basically on "APLcart News" in a week. I've pushed a few things, but nothing major.

@Adám I'll work on it *now* and ping you when I done with this timeslot

thx

@Adám TIO links that use the new 18.0 features will be deferred for now, right?

@RGS You don't have to create new TIOs, but if you're updating an existing entry that already has one, then it should be updated.

@Adám I mean entries that use e.g. atop ⍤ or over ⍥ or constant ⍨

TIO already supports those?

@RGS Oh, good point, no of course not. So right, every affected TIO link needs to go. Sorry.

All of these changes will use new features not on TIO.

@Adám yup, of course... :D

@Adám is the final version of this in the docs already?

@RGS No :-(

@Adám too bad :/ I would link a lot to it rn in the (?) of these new entries :)

@RGS They just need to link to their respective doc pages. If we ever add the diagram, it'll appear there.

@Adám +← 1

However, we should have an APL Wiki article on compositions, and there, we can put whatever we want.

@Adám but would APLCart link to it?

also, in smth like this {Xs}⎕C Y is the {Xs} indicating some sort of shy-ness?

@RGS No, it is an optional argument. Maybe that should be split into two entries, monadic and dyadic.

you have entries for ⎕C Y and then {Xs}⎕C Y

maybe the second one should be Xs ⎕C Y removing the {}

@RGS Or maybe just 3 entries:

with +1 and -1 as left args?

yup

on it ○/

@RGS Those are traditional names for the symbols. See here.

@Adám should I do 1∘⎕C and ¯1∘⎕C or without jot suffices?

also, you are dangerous when you do copy&pasta

^ cf. lines 12 and 13

@RGS Hm, with, I guess, but put 1⎕C and ¯1⎕C in the keywords.

@RGS Yup, it was put together in a hurry, me fully intending to go over it carefully later.

@Adám :D

@RGS I've changed the dyadic operators' list to say "Compositions (Compose, Reverse Compose, Beside, Atop, Over) ∙ Inner Product ∙ Power …" so there's now room for a general compositions page.

@Adám +← 1

You have used both Text and System with ⎕C entries

which one should I go with?

@RGS Text.

System is for things like files and settings and meta-programming.

CMC: Which APL built-in has the most names? :-D

@Adám another question: what is the rationale for adding DOC links? for something like (¯1∘⎕C≠⊢)D does it still make sense to link to the page about ⎕C? I would say so, but not sure what your standard is

(why do you have ¯1∘⎕C≠⊢ instead of 1∘⎕C=⊢ to check for lower-case-ness?)

@RGS I only add doc links for built-ins themselves, and built-ins with bound arguments (like 3∘○). People can easily look up any built-in.

@RGS Because ¯1∘⎕C=⊢ will claim "5" is lowercase, while 1∘⎕C≠⊢ won't.

(You switched them, didn't you?)

@Adám (yup I mixed up the behaviour here in chat)

"5" is neither upper nor lowercase.

1∘⎕C≠⊢ will actually fail on 4 characters, but I can live with that.

@Adám which weird characters are those? ⍥

(maybe all entries with ⍥ should also have "surprisedface" in the keywords)

@RGS Lj and Nj and Dz and Dž

ok, I can also live with those characters failing

why do they fail, though? why do natural languages have to be so weird?

To exclude those, we'd have to write (1∘⎕C≠⊢)∧(¯1∘⎕C=⊢)

@RGS They fail because the do change when uppercased, but they are not lowercase, since they also change when lowercased. They are true titlecase characters, and are only in Unicode for historical reasons.

Notice e.g. that dzaima doesn't use "dz" but rather "dz" even though he considers those two glyphs as forming a single letter (a Latin substitute for a single Cyrillic letter).

@Adám that's beyond my knowledge of natural languages

@Adám is it possible that some of the <<<Insert lines were already inserted by you?

@RGS Yes, that's possible. It is an old list.

Ok, then all is good.

@Adám you have two different entries for "Number of days in months I of years J", one is a dfn and the other one is tacit

can I delete the dfn one?

@RGS Yes. Probably stem from two idiom collections.

ok

when I'm done with this I will PR -- into the 18.0 branch?

Make sure to merge the keywords to be their union, if there is a difference.

@RGS Sure.

@Adám ofc

@Adám done; I created the PR against master because I started working on top of it and didn't notice you had already some (minor) progress on the 18.0 branch. If you review the PR and conclude all is good, then merging my PR means you can delete your branch (if I understood everything correctly)

@RGS Looking good so far. What do you think is better 1⍳⍨⊃⍤¯1⍤⍷ or ⊃⍤¯1⍤⍷⍳1⍨ ?

@Adám hmm, no idea, really

btw that entry has a typo

Oh, here's a mistake (mine, I assume): ⊢⊢⍤/2∨/1,≠ should be ⊢⊢⍤/⍨2∨/1,≠

Y (...) Y instead of X (...) Y

are you correcting things or can I correct them and push again, in the end?

Go ahead and correct them.

@Adám +← 1

@RGS I'd add dashed versions of case-fold, upper-case, lower-case as keywords.

Also, you can delete 18changes.txt now.

@RGS Oh, it is called Beside not Besides. (The name might not have been finalised yet when I created the file!)

Now I'm done.

@Adám whoops

@RGS I think I wrote it like that.

@RGS A start.

@Adám Nice! Can't you/won't you make the image bigger, though?

@RGS Done.

@Adám much better imo!

@Adám done as well

@RGS Hm, your PR is against master. It should be against 18.0 so the changes made there are included.

@Adám that is what I told you about before; I also included those changes. I just did work you had already done.

@RGS Ah, now I understand. I shouldn't be worried then.

it's good you are careful

is this a WIP?

Announcement: Thanks to @RGS, APLcart is now officially an 18.0 resource.

@RGS No, it is basically done. I could clean up and refactor the code a bit, though. Did you find an issue?

@RGS look what I just got:

What's wrong with that? Pure luck that you got one of yours. :-)

@Adám nothing wrong with it, just dumb luck, as you point out

@Adám no issues, just noticed this exists by noticing the what folder in your abrudz/aplcart repo

So why did you think it was a WIP?

@Adám because I didn't notice you publicizing it, so I thought it wasn't ready yet

Ah, well, I didn't make a big deal out of it. I'll show it off during my BAA webinar next week.

How can people find about the /challenge and /what pages? I can't seem to find them linked from the main page; is this something you considered doing? maybe linking to them from the footer?

@Adám sure, good idea!

@RGS Maybe I'll do that, but I'm really trying to keep the UI clean. They are mentioned here.

...but it's /task not /challenge, right?

@Adám yup, clutter is annoying. Maybe two suitable icons on the bottom right, next to "sponsor" and the colour changer

@FredrikNiemelä Yes, I changed that. It was /challenge originally.

Cool idea!

@FredrikNiemelä yes, I just think of them as challenges and keep thinking the path is /challenge

TBH. I like the "challenge" name better

But both /task and /what are challenges. /task gives you a programming task. /what asks you what some code does.

@RGS or maybe not, just an idea... but the only link being on GH makes it hard to discover the pages IMO

task feels like doing my chores :). OTOH, challenges is much easier to misspell

Hm, maybe I should put them on one page… They don't take much screen space anyway.

btw. the bottom is cut off for me (Chrome on Mac)

..otherwise it would easily fit there?

@FredrikNiemelä Bottom of the main APLcart page?

@Adám correct

Oh, I can see that with Chrome on Windows too. Grr, these browsers are moving targets.

@FredrikNiemelä So you probably also have (#) below ⊆⌈ instead of too the right of (×) ?

yup

I was wondering about that :)

@FredrikNiemelä How about now?

@Adám same

The css may be cached. Try opening the devtools and then press Ctrl+F5

You could also inspect the input field element and make sure it says 15.1em and not 15em.

Hard reload fixed it

Looks good now

@Adám isn't ctrl+f5 enough? I'm pretty sure I have been using it to "force reload" pages

@RGS I've found that it sometimes isn't enough, and only actually clears everything with the devtools open.

@RGS ctr-shift-R is the hard reload I did (on Mac)

@Adám oh ok... I was wondering if you would say that '⊆⌈/task'≡'⊆⌈/what'⍣¯1 ?

@Adám on an unrelated note. Are gotos not allowed when running with -script ?

@FredrikNiemelä They are, but they are only meaningful inside functions.

Ah.... I was looking at an old code golf solution for codegolf.stackexchange.com/questions/62230/simple-cat-program

...which it turned out you wrote :)

@FredrikNiemelä The scripting and multi-line functionality is still experimental, but this should work (and put your interpreter into a tight loop you can't easily get out of, so save your work and be ready to kill the process):

:if 1
'hello'
→2
:endif

Yes, that's essentially what happens behind the covers when you use the multi-line feature.

That does not require a sentinel on the input

@FredrikNiemelä Why are you doing +i← and not simply ⍞ by itself? You never use i again.

Eh... just because I'm already tryng to solve the "different" problem we discussed earlier. After pasting I saw the errors of my way :)

Point being... no EOF needed

@FredrikNiemelä Sure, if you can process each input line separately. However, now write a reverse cat!

:)

I.e. output the last line first, then the second-to-last, etc.

But that's not really a well defined task on a stream

(which is why we would have an EOF to begin with)

@matt Hi. Interested in APL?

i guess so. don't know much about it

@matt I'll be happy to introduce you to APL. Do you have a few minutes?

uh sure

also is "APL orchard" a play on words?

It is. We tend to make puns pretending APL is pronounced like "apple".

heh ok

@matt you have no idea of the rabbit hole you are getting into hehe

Is APLcart also a pun?

@RGS is that good? bad?

@matt good

@matt APL is a mathematical notation that generalises and harmonises concepts from Traditional Mathematical Notation (TMN) so it becomes unambiguous and therefore machine executable. It can then also be used as A Programming Language.

what

english please

@matt I found it awesome ⍥

@FredrikNiemelä Yes. I was intending to disrupt the APL documentation scene, so compare to the phrase "upset the applecart".

@matt Sorry. Do you mind telling me a little about our own background, so I can adapt to that?

I was just googling for idioms containing applecart. Found that one, but had never heard it before, so that went completely over my head

future data scientist maybe, idk

@matt Aha, then you're exactly the target audience for APL!

dun dun dun!

is this supposed to feel like an interview?

No, not at all :-)

ok good :D

APL is a programming language that removes much of the usual burden of programming from the programmer and gives it to the computer to deal with. It is especially well suited for domain experts who can then write their own programs instead of having to communicate their needs to a professional programmer for implementation.

so basically "thing that kinda does stuff for you"

"but not entirely"

Yup.

yes i have a very simplistic view of things lol

It is great for handling and mangling large amounts of data processing, while keeping the "feel" of just writing mathematical formulas.