1:03 AM
I'm always curious if I can get sharpplot as a separated product, for macOS

1:52 AM
@AidenChow Same. I tried joining, but fell asleep halfway through at like 2am. Was looking forward to the post-discussion!

2 hours later…
3:59 AM

2 hours later…
5:59 AM
@LdBeth You mean for use with other programming languages?

1 hour later…
7:01 AM
@Adám Will the videos from APL seeds be available to stream?

7:13 AM
@sloorush Yes, we just need a little time to cut and trim the single long recording into individual talks. After that, you'll find them on Dyalog TV and on YouTube.

whats dyalog tv

Maybe this could be a bit of a show-off for APLers? fluxkeyboard.com

7:52 AM
guys... i search on aplcart for how to interweave two lists and get `Xv(,,⍤0)Yv`, but how does it work??

@AidenChow Are you familiar with the Atop construct (2-train, in this case)?

its like f(g x) right

Yes, indeed, but here, it is dyadic, so `x(f g)y` is `f x g y`
Let's unpack the entry: `Xv(,,⍤0)Yv` is `,Xv(,⍤0)Yv`

what
how u take out the comma like that

There are two functions in the parenthesis: `f←,` and `g←,⍤0`
`x (f g) y` is `f x g y` so `Xv (, ,⍤0) Yv` is `, Xv (,⍤0) Yv`
(we still need the parenthesis around `,⍤0` so `0` and `Yv` don't strand)

7:58 AM
ok wait f x g y is a list or what

`f` and `g` are functions. `x` and `y` are arguments (arrays)

oh so f take argument x g y?

Yes.
Maybe clearer if we write it as `f(x g y)`

yep thats clearer, i never really work with trains with two argument before lol

Anyway, that's just the structure. Do you understand what `,⍤0` and `,` actually do?

8:01 AM
comma is concatenate right

and also ravel

ravel??

Yes, reshape into a vector.

ya ok i never see that before

```      a←2 3⍴⎕A ⋄ ,a
ABCDEF```

8:03 AM
so its like flattening into a list?

Yes, that is exactly what it does.
So `,⍤0` concatenates each pair of scalar-from-Xv with scalar-from-Yv, keeping the outer (vector, rank 1) shape, but since the major cells (which were scalars, rank 0) are now vectors (rank 1), the entire shape becomes a matrix with 2 columns.

isnt there also enlist or whatever its called, i usually use that to flatten to list...

Yes, but that one opens all structure too. Ravel only manipulates the outer shape.
```      a←⍳2 3
a
┌───┬───┬───┐
│1 1│1 2│1 3│
├───┼───┼───┤
│2 1│2 2│2 3│
└───┴───┴───┘
,a
┌───┬───┬───┬───┬───┬───┐
│1 1│1 2│1 3│2 1│2 2│2 3│
└───┴───┴───┴───┴───┴───┘
∊a
1 1 1 2 1 3 2 1 2 2 2 3```

Do you understand how we end up with the 2-column matrix?
```      'ABCD'(,⍤0)'abcd'
Aa
Bb
Cc
Dd```

8:08 AM
wait what, the comma is zipping them together??

Here the `,` only ever sees a scalar on the left and a scalar on the right, because `⍤0` restricts it to see arguments of rank 0 (scalars). The `⍤` then collects these results together to form one array.
Compare:
```      'ABCD'({⊂⍺⍵}⍤0)'abcd'
┌──┬──┬──┬──┐
│Aa│Bb│Cc│Dd│
└──┴──┴──┴──┘```

wat the hell i thought ⍤ mean atop
so confusing lol

That too, `function⍤function` is atop, but `function⍤array` is Rank.

whats rank????

I suggest having a look there, and at the "Publications" at the bottom. I've got to go, but I'll be back later.

8:13 AM
i certainly would not be able to figure this out on my own... i was reading the commas as concatenate and the ⍤ as atop lmao

any particular reason why phase 2 solutions cannot be tacit? first tasks of the bioinformatics one as dfns is just wasted glyphs
or maybe I misunderstood "any combination of tradfns or dfns"

what, solution cant be in tacit??

phase 1 yes
phase 2 I think not

hmmm thats interesting choice... i wonder what the rationale behind that could be
good thing idk anything about trains anyways lol

9:02 AM
IIUC, Phase 2 is intended to test your broader programming skills with APL, not just how well you grok the primitives. Forcing dfns/tradfns is perhaps a way of encouraging us to add comments, error handling, and all that jazz.

I guess that kind of makes sense, but 2:1:1 is basically impossible to comment without just restating exactly what the code does, which is probably easier to understand by just reading the code than the comment

Yeah, the happy-path solution is just a few characters, but what happens with unexpected input? Maybe you think that's not particularly relevant, in which case you could talk to the judges with a comment saying something to that effect.
In my opinion, one of the interesting things about APL is that the primitives can take on salient domain-specific meaning when you restrict their use to a particular problem. Adding a comment that explicates something like that might be reasonable.

hmm, I understood the problem statement as "assume the input is valid", maybe that's not the case

9:30 AM
@AidenChow I think it's just that 2⎕FIX - the mechanism used to import phase 2 solutions - cannot ingest raw tacit definitions

1 hour later…
10:31 AM
@RubenVerg @AidenChow @RikedyP We cannot safely analyse tacit functions to do the syntax sanity check.
@dzaima Fixed in 19.0. We're considering backporting.

10:58 AM
Say `m` is some mask, is there any reason to prefer either `(m/A)←blah` or `A[⍸m]←blah`?

11:21 AM
Aw... Selective Assignment doesn't support Mix and Split: `(m/↓⍉↑A B C)←a b c`. Trying to bulk-update records in an inverted table where columns are stored in variables, e.g. `A`, `B`, and `C` above.

@B.Wilson `m/A` can be faster if it works, as it doesn't have to build the intermediate list of indices. However, `A[⍸m]` works on non-vectors.
@B.Wilson Why are you using inverted tables? Probably for performance. If so, you shouldn't `↓⍉↑` them, as that'll be very costly.

@Adám Ah, okay. Seems kind of obvious when you put it that way ;D Cheers.

This works:
```      A←↑'Ann' 'Bob' 'Carl'
B←3 14 15
C←'XYZ'
m←1 0 1
((⊂m)⌿¨A B C)←(↑'Ann' 'Carl')(2 71)'xz'
SYNTAX ERROR
((⊂m)⌿¨A B C)←(↑'Ann' 'Carl')(2 71)'xz'
∧
ABC←A B C ⋄ ((⊂m)⌿¨ABC)←(↑'Ann' 'Carl')(2 71)'xz' ⋄ A B C←ABC```

Ah. Okay. So wrapping into and then unwrapping from a single token. Nice.

Of course, this will double your memory consumption too. Best is probably to keep it all in a single variable.

11:35 AM
You mean avoid storing the columns separately in the first place?

Yes.

Okay. Note to self: learn good idioms for handling inverted tables.

@B.Wilson Did you APLcart them?

That would be cheating! :P
First dumb-headed idea: `∆←my table` and `A B C←1 2 3` are my column indices, so then where we would previously write `(m/A)←blah`, we can now write (m/A⌷∆)←blah`.

11:53 AM
@B.Wilson That's pretty clever. Or even `(m⌿∆[A B])←` as then you can modify multiple columns at once. That said, be careful about modifying "cells" rather than entire records.

@Adám oh ok so it's not a deliberate choice, more a side effect of how the challenge is implemented. makes sense, kinda sad tho

Well, it is deliberate, but a necessary cost for automated sanity checks. Btw, you can easily circumvent the restriction by wrapping your tacit functions (and don't worry; we'll not count that against you):
```∇Avg←Avg
Avg←+⌿÷≢
∇```

yeah I did that it's just kinda sad to have to do so :)

@Adám That needs to be `((⊂m)/¨∆[A B])←`, right? Meaning that your `∆` is actually a vector of vectors? Also, are you using first-axis Replicate just because first-axis Rulz™ or is there a deeper reason?
Apologies for the firehose of questions.

Yes, your version is correct. I used `⌿` because otherwise it'll fail on fixed-width text columns.
(Now I want to make a First-Axis Rulz t-shirt.)

12:13 PM
What's the relationship between `⎕DMX.DM` and `⎕DMX.(EM Message)`?

@B.Wilson See here:
```      ÷0
DOMAIN ERROR: Divide by zero
÷0
∧
⎕DMX.DM
┌────────────┬────────┬───────┐
│DOMAIN ERROR│      ÷0│      ∧│
└────────────┴────────┴───────┘
⎕DMX.(EM Message)
┌────────────┬──────────────┐
│DOMAIN ERROR│Divide by zero│
└────────────┴──────────────┘```

As far as I can tell, the only way to get at the full error message we usually see in the session is with the former. Is that right? Looks like `Message` doesn't contain the info about problematic source line and location.
`InternalLocation` is fun :D Feel like I'm looking at classified information here.

No, unfortunately, there's no good way to get the full message you see in the session. The best I've come up with is this piece of pornography:
`⎕DMX.((⊂OSError{⍵,2⌽(×≢⊃⍬⍴2⌽⍺,⊂'')/'") ("',⊃⍬⍴2⌽⊆⍺}Message{⍵,⍺,⍨': '/⍨×≢⍺}⊃⍬⍴DM,⊂''),1↓DM)`
(Note that it is a bit more complex than you necessarily need, as it is `⎕IO` and `⎕ML` agnostic.)
I'd really want `⊂OSError{⍵,2⌽(×≢⊃⍬⍴2⌽⍺,⊂'')/'") ("',⊃⍬⍴2⌽⊆⍺}Message{⍵,⍺,⍨': '/⍨×≢⍺}⊃⍬⍴DM,⊂''` to be called `⎕DMX.EMX`
Should I add `⍪` and `,`?

12:58 PM
Is this beauty in aplcart? :P
@Adám Yeeeaaahhh! Definitely need `⍪` a and `,`.
The second one also has a nice reflection-esque symmetry which I find pleasing.

Yeah, the second one is nice. Might want to raise the `⍪` a bit, but it is close.

1:13 PM
Has the diamond separator always been a feature of APL?

No.

Which flava APL introduced it?

2 hours later…
3:15 PM
Past midnight. Everyone's gone to bed. Time for some pre-sleep APL!

@xpqz Not sure. It was an obvious thing to add, because people kept writing things like `…b,0⍴a←…`

Haha. That's cute. What's the timeline? A Dictionary of APL already has it, so I assume it came about much earlier?
Man, I want a little hand-held Dyalog APL calculator.
Throwing something together with a Pi might work, though battery life would be atrocious.

we should have a phone/tablet app

3:30 PM
That would significantly lower one barrier to entry, indeed.

@B.Wilson Do you have an Android phone?

@Adám Actually, I got rid of my phone a couple years back :|

3:46 PM
I tend to use a stupidphone.

Stupid is definitely the new smart.

Anyway, this Android app can either use its own Dyalog-alike interpreter, or use TryAPL as backend, or connect to a remote Dyalog APL.
@B.Wilson @xpqz APL/700 added `;` as a right-to-left `⋄` in 1971.

@B.Wilson I find the mobile version J-902 handy, although I'm not very used to J's notation, doing some finance calculation with J is definitely fun
at least I don't need to figure out how to get an APL keyboard on iphone

@Adám Ah, Dzaima APL. Neat. I actually have Dzaima installed on my laptop as well. Though, I have a Pinephone laying around, which might just need to get Dyalogified.
@LdBeth That's probably pretty good in a pinch. There's even a J keyboard installed with the Android app, right?

4:03 PM
right, although the newer version of the iOS app uses just the system keyboard

4:31 PM
`⎕XT` looks nifty. Wonder what the competition judges would think of this: `⍎⎕UCS 39 115 109 105 108 101 39 9109 120 116 39 115 109 105 108 101 39 32 8900 32 115 109 105 108 101 8592 9075 53 101 57 9076 52 50`

Probably not very well given WS FULLs for default workspace size

Point is that it won't trigger a WS FULL and instead thrash the filesystem.

5:16 PM
Is there a problem with "excessive" comments in phase 2 solutions? I write my solutions in a custom half-implementation half-tool of thought dialect which I then port over to Dyalog, but for ease of maintaining I've been leaving both the original code as well as extensive documentation comments, which I guess are mostly useless for judging, but I'd guess they won't harm either? Just checking in case I make my life harder for no reason :)

5:27 PM
I don't speak for Dyalog, but if you look at the source for some of the functions in the dfns workspace you can see the level of documentation some masters of the art include with their code.

5:43 PM
0

I'm looking for an APL interpreter running native on Apple silicon, namely MacBook Pro, M1 Max, 64G, Mac OS 13.2.1. I only found Dyalog (working fine) but Rosetta mediated. Any idea, anyone ? (didn't try to build GNU APL yet)

2 hours later…
7:28 PM
@B.Wilson you would need a xor code obfuscation
@RubenVerg I didn't write a single line of comment for phase 2 yet except for one sub question I have not yet find a feasible solution.
I think this time most of my code are self-explanatory and short enough :D
for that question I start with 30 lines of comment to explain what my idea is without more than a line of code, and the code isn't even working yet

2 hours later…
9:05 PM
@LdBeth lmao my bioinformatics solution (only did 1, 2, and 3 rn) has 75 comments to 25 lines of code