The APL Orchard

1:30 AM

Hi! This is pretty basic, but I've been trying to port some APL examples I've found to BQN, and was wondering if someone had advice on improving this FizzBuzz example I've been playing with. I know the APL solution managed to avoid map, but haven't figured out the BQN version that does the same.

(⊐{0=15‿3‿5‿50 | 𝕩}¨(1+↕100))⊏⟨".", "Fizz", "Buzz", "FizzBuzz", "."⟩

Jeff Zeitlin

1:49 AM

What's the channel name on FreeNode that the 'bot bridges to?

(/me has an IRC client that 'lives' on FreeNode, so I can join there, too...)

Dyalog APL

<moon-child> #apl

Moonchild

@Adám working on it now

Jeff Zeitlin

2:09 AM

Thank you, moon-child!

Marshall

2:19 AM

@LukasHermann (Is there a reason today's BQN question day?) Hm, I definitely wouldn't want to use Classify in my ultimate solution. If things change a little, the ordering could break completely. But the way I'd get rid of Each is to use Table, replacing {0=15‿3‿5‿50 | 𝕩}¨ with {0=⍉15‿3‿5‿50|⌜𝕩}. That gives you a shape 100‿4 array instead of a list of lists.

You can remove 15 from the list of divisors since 15|𝕩 is determined by 3|𝕩 and 5|𝕩 (the Chinese remainder theorem). 50 can't be removed without changing the behavior, but what it's doing is to change the result entries for 50 and 100 from "Buzz" to ".", which isn't standard FizzBuzz. I don't know if that's intended.

Lukas Hermann

@Marshall Thanks! The reason I'm asking is partially because I've managed to get BQN running in Observable notebooks and was looking for example problems to throw at it

Marshall

@LukasHermann Oh, that's pretty cool. Share a link if/when you can!

Lukas Hermann

@Marshall Will do! I'm hoping to release the notebook by the end of the weekend. It's fun to mix the HTML parts of JS with BQN's goodness. (example) snpy.in/T1djCR

Marshall

2:41 AM

@LukasHermann Why the backslash encoding? Definitely nice to have everything working together seamlessly. I spent a short while thinking about how I might expose back and forth interop with BQN before realizing that closures are all you'll ever need. Pass a JS function to BQN, or make a BQN function and call it wherever you want, it should all just work.

The one medium-sized annoyance being that functions with two arguments take 𝕩,𝕨 in JS. Consistent with the one-argument form but easy to confuse.

Lukas Hermann

@Marshall It was mainly as a way to avoid using the bookmarklet when I use observable on my phone, hahaha

I should note it's literally the parser script from bqn.js completely unchanged, so whatever works with that will work with this

Marshall

@LukasHermann Oh, that's understandable.

Lukas Hermann

@Marshall Just to see if I understand (since I haven't delved too deeply into it), does that mean that BQN can consume the outputs of other bqn functions?

for example my hacky mapping to string vs being able to directly feed it

I also made a formatter method that converts backslash notation to BQN strings in the notebook for when I want to write something quickly and see it pretty printed

Marshall

@LukasHermann The way to pass in a value is to call bqn and get a function out, then call that function on arguments. So (bqn`{2+𝕩}`)(3) or something like that.

Lukas Hermann

@Marshall Oh! That will be fun to use in a notebook context for sure

Marshall

2:51 AM

There's no verification that the arguments are valid BQN values, so you'll have to pass in outputs from other BQN computations, or know how BQN values are encoded in JS, which is pretty simple.

Numbers are numbers, characters are one-character strings, arrays have the elements in index/Deshape order as a JS list plus a sh property giving the shape, and functions are JS functions with one or two arguments, 𝕩 first.

Modifiers are also functions (taking 𝕗 first, so it does follow BQN order), but with the .m property set to 1 for a 1-modifier and 2 for a 2-modifier.

I should probably just make a page on this in the documentation.

Lukas Hermann

Ah I see, thanks for the tips! I'm having a blast playing around with this stuff

AviFS

8:51 AM

@Adám So funny that you mentioned that video, I just stumbled across it a couple of days ago. Lately I’ve been really impressed with the expressivity that Haskell’s algebraic types and extensive type classes allow. Especially for math, it makes working with all sorts of structures from abstract algebra, and occasionally even from category theory, lots of fun.

I haven't had a chance to watch the video end-to-end, so maybe a piece of it was addressed there. But my sense was that it addresses boring old type systems for boring old reasons, eg. compiling & correctness. Does anyone have any thoughts on a dialect of APL with a type system a la Haskell focused solely on expressivity? (With any other benefits being happy accidents.)

I’m really curious as to how one deals with those abstractions in APL. So the other prong to the question is whether there any papers, dfns, libraries, or other resources I could look over for to see how those things might be done as is. (I know it’s a bit vague, I’ll be happy to give some concrete examples.)

@Marshall This is all yours, too! Any ideas/plans for how BQN might handle abstractions?

Dyalog APL

<moon-child> @AviFS haskell's type system isn't less about compilation and correctness than other language's type systems, it just lets you express more in the type system and get more performance and correctness guarantees than you would from other languages

<moon-child> wrt apl, I recommend looking into dependent types

AviFS

@DyalogAPL Absolutely. And many, if not most, Haskellers care about it for what I'll call the 'boring' reasons that I mentioned. But the expressiveness is why I like it and am thinking about a dialect in the family that would focus on a type system with nothing more than enhancing APL's notation as tool of thought motto in mind.

@DyalogAPL Definitely! There's all sorts of even more expressive and sophisticated type systems. Dependent types would be even cooler

Is there a reason you recommend them specifically for APL?

@ngn Hey! Long time no see. Having put together an APL from scratch (not forgetting dzaima), do you have any thoughts?

Elias Mårtenson

9:06 AM

I know this comparison is a bit unfair, and I'm cherry picking here, but dfns are really slow in Dyalog.

The following runs in 4 seconds on my machine on Dyalog: {⍺+⍵}/⍳10000000

Plain KAP with everything boxed (before my optimisation work to support types arrays), the same took: 0.847 seconds.

When I try it in the version of KAP with specialised arrays, the same takes 0.01 seconds.

Why is it so slow in Dyalog?

Dyalog APL

<moon-child> @AviFS you need dependent types to describe array shapes, and relationships between array indices and the arrays they index

ngn

@AviFS i like haskell a lot, but i'm sceptical about the practical value of static typing in apl

@AviFS have you seen anders' talk?

ngn

9:34 AM

@EliasMårtenson don't say that in this chat or else someone from dyalog may start feeling personally attacked again :)

Elias Mårtenson

9:52 AM

@ngn Well, I did prefix my question with the point that I'm cherry picking.

Also, I do think I know why it's slow, and that there may be less opportunities to make it fast in Dyalog's case. I personally think it's because dfns needs to be re-parsed for ever call.

KAP gets away with this because it doesn't allow redefinitions of functions inside a statement.

But I'm wondering if there is any other reason.

ngn

@EliasMårtenson you mean re-tokenized for every call? (apl can't be parsed statically) i think that's done only once

ktye

@EliasMårtenson where is KAP? can we try it?

AviFS

@DyalogAPL You do? You mean that, for instance given m←2 2⍴⍳4 then a⌹m yields a valid type iff ⍴a=2?

ngn

@ktye github.com/lokedhs/array

Dyalog APL

<moon-child> @AviFS yeah, except that ⍴a and ⍴m don't have to be known at compile time. Dependent typing lets you prove that the relationship between the two shapes will be such that a⌹m is valid

ktye

10:04 AM

@ngn did you try it? is it complicated to build?

dzaima

@ktye there's also this at the bottom of the readme

AviFS

@ngn Not even sure about the level to which it'd need to be enforced, or anything. And certainly not sure it has to be static. My interest is in making it more expressive and more natural to do some fun things. Not making large codebases more maintainable, correct or fast.

ngn

@ktye i haven't tried to build it but there's the "try online" link dzaima mentioned

ktye

@dzaima thanks. i've seen it. but thought a native version is better suited to check it's speed.

AviFS

I'm appealing to the zany, experimental, childlike side. Not the pragmatic adult side ; )

Dyalog APL

10:08 AM

<moon-child> @ngn doesn't ngn/apl do static parsing? ;) It should be possible in the absence of ⍎, if you force name classes to be static

dzaima

@ktye for building, iirc it was just the ./gradlew build in the readme, with java 8

AviFS

@DyalogAPL The second sentence makes me think we're on the same page. But the 'except' bit implies we're not. Mind clarifying the first sentence for me?

ngn

@DyalogAPL <moon-child> ngn/apl doesn't exist anymore but yes, it used to impose certain restrictions in order to be able to parse statically

@DyalogAPL <moon-child> if ⍎ executes in the global scope and never returns functions, it should be ok too

dzaima

@ngn no, KAP is properly statically parsed, just like ngn/apl

Dyalog APL

<moon-child> @AviFS say I have vectors X and Y (ignoring rank poly for the moment to keep things simple). The expression X⍳Y has shape ⍴Y and its elements are integers refined by the condition <∘(1+⍴X). That means that (X,0)[X⍳Y] is known at compile time to be type safe, and we can have no idea what the actual shapes of X and Y are until runtime

Elias Mårtenson

10:17 AM

@ngn Well, that's my point. I believe the speed difference comes from the fact that Dyalog (being APL) cannot be parsed statically, while KAP can, and can therefore benefit in this particular case.

dzaima

@EliasMårtenson For some reason I remember Dyalog's dfns being 100x+ faster than dzaima/APLs, but dzaima/APL is only ~2x slower than Dyalog for that (7x for {-⍵}¨⍳1000000, but still not 100x)

Elias Mårtenson

@ktye There are three versions: JVM, native and JS. Native is roughly 10-20 times slower than JVM. JS is about 100 times slower than JVM.

ktye

@EliasMårtenson is native a distinct implementation, or generated by kotlin?

Elias Mårtenson

@ktye It's compiled using Kotlin Native.

And Kotlin Native is kinda slow.

AviFS

@DyalogAPL Sorry, that took me a moment to parse! Understood. The 'yeah, except' wasn't undoing what I said; you were extending it. In other words, dynamic typing does take care of ⌹ when we know ⍴m=2... but it doesn't even have to know that at compile time. It can infer the validity without knowing the precise dimensions at compile time. Did I follow?

Sorry for my slowness. Today was the Putnam and it's past 2 AM on top of it! Be back tomorrow

Dyalog APL

10:23 AM

<moon-child> heh, past 2am for me too. SHould go to bed...

AviFS

But did you take the Putnam : p

Dyalog APL

<moon-child> well, no

AviFS

I win! We should still go to bed, though ⍥/

Elias Mårtenson

Wait where is it 02:00 now?

Dyalog APL

<moon-child> pst

Elias Mårtenson

10:26 AM

I have no idea what PST is... Which probably means it's in the US :-)

Adám

Pacific Standard Time. UTC-8, iirc.

dzaima

@dzaima hm, now it's complaining about some jansson.h file not existing. ./gradlew gui:run works fine though

Elias Mårtenson

@dzaima You only need the native libraries if you build the native version.

The JVM version should run without any dependencies, just run gradlew gui:run

@dzaima On debian or ubuntu you need to install these packages to get the native version to run: libicu-dev libcurl4-openssl-dev libjansson-dev

dzaima

what's the way to time things in KAP?

Elias Mårtenson

@dzaima time:measureTime { ... }

The version is master doesn't have support for specialised arrays. That's still in a separate branch as it's still pretty broken.

measureTime is just a library function by the way, it's implemented in terms of time:timeMillis: github.com/lokedhs/array/blob/master/array/standard-lib/…

dzaima

10:47 AM

ForcedElementTypeArray is apparently the only things that complains about making APLValue a class, with its : APLValue by inner

Elias Mårtenson

@dzaima Yes. I changed that, and tested it today actually.

There was no measurable performance difference.

ForcedElementTypeArray however is part of the specialised-arrays branch, it shouldn't be in master.

dzaima

well, back to master, where it apparently compiles

Elias Mårtenson

In any case ForcedElementTypeArray is only used by test cases (to ensure that an array is specialised or not). So you could just remove it :-)

It's just an array that overrides the specialisation

In fact, now that I think about it, that class probably belongs in the test module instead of the main code.

dzaima

@dzaima i see no performance difference for {+/{+/{÷-⍵}¨⍳1000000}¨⍳10}, and am too lazy to find anything better to test. ¯\_(ツ)_/¯

i guess the jvm really is just pure magic

well, back to work on singeli (and killing the few gigabyte RAM usage of gradle)

ngn

11:03 AM

hah, java

Elias Mårtenson

@dzaima Thanks for the experimentation. :-)

@ngn The JVM has given me some reparakable performance in some cases where I would never have expected it.

However, primitive types are a nightmare, and without a macro system in Kotlin, implementation of specialised arrays is very, very ugly.

ngn

@RGS touches c at a low level. wait what..

dzaima

@dzaima (no clue how gradle manages to use so much RAM for cache apparently and still compile KAP slower than dzaima/BQN does (both are of roughly the same size))

ngn

@EliasMårtenson but you have no control over how things are laid out in memory, when they are gc-ed, which loops are vectorized..

dzaima

@ngn i mean, you don't have control over which loops are vectorized in C too

ngn

11:12 AM

@dzaima right, but there are language extensions for that

Martin Janiczek

11:34 AM

@MortenKromberg SE.Link.Version says 2.0.3

      ]link.import # .
INDEX ERROR
Run[25] ⎕SE.SALTUtils.c.Link.(RSLT←OPTS(⎕SE.Link⍎CMD)ARGS) ⍝ dot our way home
                                       ∧

Elias Mårtenson

@ngn True, but even if I did, with lazy evaluation it'd be hard to take advantage of it.

And if I wanted to, with specialised arrays I could do specific memory layout by usin gnative arrays.

It's not really part of my todo-list though.

@dzaima Well, first and foremost: Gradle is absolute garbage.

Secondly, Kotlin compiles slower than Java.

Thirdly, it used to be a lot worse. Now it compiles and runs the GUI in 10 seconds with a clean build.

Kamila Szewczyk

@EliasMårtenson maven gang :)?

Elias Mårtenson

@KamilaSzewczyk Maven was my most hated piece of Java technology together with Spring. Well, until I discovered Gradle that is.

Kamila Szewczyk

11:50 AM

i feel you, i hate computers too.

RGS

Watching these discussions is soo entertaining 🍿🍿

Transcript for