bear8642

seems fixed

> we are really not that great thinking in higher dimensions.

Normally when you've hit 4d arrays, are you not dealing with a grid of grids?

That is say you've got a 2×3×4×5 array, another way to think about that is you've got a 2×3 matrix of 4×5 matrices. (APL example to show what I mean: https://tryapl.org/?clear&q=%7B%E2%8D%B5%2C%E2%8D%A5%E2%8A%8...)

Reading the abstract, it seems like a precursor of somekind

Probably, especially given the boom of GPU/Tensor computing.

You might find Stefan Kruger's book useful: https://xpqz.github.io/learnapl/intro.html or his write up of the APL Cultivations (https://xpqz.github.io/cultivations/Intro.html)

Not sure where best to start with J, although finding it interesting reading through the Dictionary (https://www.jsoftware.com/help/dictionary/contents.htm) and seeing how it compares to APL

and dd is data destroyer

The about section has links to other things he's written/presented.

> And I've never heard of anyone running it without an OS.

kOS is in development though current status is unknown.

(https://gist.github.com/chrispsn/da00835bb122c42f429a084df83...)

> [1]: https://shakti.com/ -> Compare -> h2o.k

You can link to the subsections: https://shakti.com/compare/h2o.k

K is a fast vector language, used (primarily) for time series data analysis.

>What does a K program look like?

You might want to check out https://news.ycombinator.com/item?id=40335921

beagle3 and geocar both have various comments you might want to search for.

huh?

Svn can branch and merge - maybe bit more clunky but still works

Because that's what APL does: https://www.jsoftware.com/papers/EvalOrder.htm

It also simplifies things as no need to implement BIDMAS

Feel it would be interesting trying a chording keyboard with a glyph based language - thinking APL, BQN and the like…

There you could match the chords to glyphs rather than require the auto complete functionality others have suggested.

Whilst more the personality side, found https://www.folklore.org a fun read of the early times at Apple.

Oh, yet another option - first thought was U+0085 NEXT LINE as above

> Decide upon on new UTF-8 code point.

Unicode have already done so - (NEL) https://www.compart.com/en/unicode/U+0085

> What could you do with that?

Just a couple quick ideas:

    fns ← f g h         ⍝ array of function

    fns[condition] args ⍝ select function to run
    (3 0 0⌿fns)    args ⍝ f f f args

Tryapl.org exists if want to play with APL - John Scholes' Game of Life and other excellent videos (https://www.youtube.com/watch?v=a9xAKttWgP4) might spark your interest

Other newer array languages exist too - https://aplwiki.com/wiki/Running_APL if want to explore the current space.

Russ has indeed been involved, he's done various videos solving advent of code using Ivy.

Russ has also got a pull request to add an operator, see https://github.com/robpike/ivy/pull/83

> I'm not a fan of Unix man page section numbers in parentheses.

Why not? Confusion if function call with section number as argument?

>probably more obscure ones.

Apl/BQN worth adding for the recent CUDA/vector language explosion, and has it's fair share of extraordinary programmers!

Forth an interesting one too look, although never properly used.

miniKanren/Prolog another vein to branch down (unification/logic programming)

>pronouncing "Ethernet" with a short e, as though it were to rhyme with "meth"

Well it's a network across the ether (æther) right? :-D

Well it's often said lisp and forth are very close…

With mac, is that m series? Thinking would be faster given unified memory reducing copy overhead.

Remember exploring the simd fizz-buzz solution[0] and forgot just how fast computers can be

[0] https://codegolf.stackexchange.com/questions/215216/high-thr...

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: https://www.youtube.com/watch?v=a9xAKttWgP4

Not sure I'd call APL an esolang - it's just an old language focused on array manipulation like you'd find in numpy

You can give them names if you want, and Q does so.

However doing so looses the ease of recognition and the malleablity the symbols provide.

Equivalently in APL:

  ⎕io←0               ⍝ to match J
  test ← (× = ∨ × ∧) ∘ ?
  ∧⌿ test⍨ 1000⍴100

> I can't type them in on my keyboard without...

You mean like how you've got to find out how to type accented characters - á or ö for example?

The glyphs are available as a keyboard layer which you can easily find and install, or simply enable on Linux.

Yes there is an initial hurdle when you're learning, but the same applies with +-×÷, and any languague with a different alphabet/symbol set! Once learnt however, the ~50 odd symbols are all the primitive functions, and then have speed and ability like maths to write and play with expressions.

>I think their impact on code history is negligible in the case of every legacy system I've worked on. The code history just isn't there.

Not sure if I agree here or not - whilst yes, the history isn't there, if it's a small enough team you'll have a good guess at who wrote it.

Definitely found I've learnt the style of colleages so know who to ask just from the code outline.