[fainpul]

I assume this is the same as this?

  # python
  [127 * sin(x * tau * freq / samplerate) for x in range(samplerate)]

[zahlman]

For that matter,

  # python
  from numpy import sin, arange, pi
  127 * sin(arange(samplerate) * 2 * pi * freq / samplerate)

[kelas]

for that matter, i always wonder how people mistake python for numpy :) they have surprisingly little in common.

but enough talking about languages that suck. let's talk about python!

i'm not some braniac on a nerd patrol, i'm a simple guy and i write simple programs, so i need simple things. let's say i want an identity matrix of order x*x.

nothing simpler. i just chose one of 6 versions of python found on my system, create a venv, activate it, pip install numpy (and a terabyte of its dependencies), and that's it - i got my matrix straight away. i absolutely love it:

  np.tile(np.concatenate([[1],x*[0]]),x)[:x*x].reshape(*2*[x])

and now lets see just how obscure and unreadable exactly the same thing looks in k:

  (2#x)#1,x#0

no wonder innocent people end up with brain aneurisms and nervous breakdowns.

[seanhunter]

That is wildly disingenuous. Assuming you've imported numpy as np, you get an nxn identity matrix by doing

   np.identity(n)

http://numpy.org/doc/stable/reference/generated/numpy.identi...

[kelas]

> That is wildly disingenuous.

assuming you're referring to numpy as to have anything to do with python spec, i totally agree with you. only it doesn't. so don't pytorch and pandas (and good so, poor python doesn't need any extra help to be completely f).

> you get an nxn identity matrix by...

no, man, that's how you get it. really advanced technique, kudos!

i get it by:

   id:{...}     /there are many ways to implement identity in k, and it's fun!
   id 3
  +1.00 +0.00 +0.00
  +0.00 +1.00 +0.00
  +0.00 +0.00 +1.00

but if you can keep a secret, more recently we've gotten so lazy and disingenuous in k land, and because we need them bloody matrices so often now, we just do it like so:

   &3
  +1.00 +1.00 +1.00
  +1.00 +1.00 +1.00
  +1.00 +1.00 +1.00

   =3
  +1.00 +0.00 +0.00
  +0.00 +1.00 +0.00
  +0.00 +0.00 +1.00

(but of course before we do that we first install python4, numpy, pytorch, pandas and polars - not because we need them, just to feel like seasoned professionals who know what they're doing)

[RodgerTheGreat]

i'm a fan of

    t=\:t:!x

[kelas]

> t=\:t:!x

this is of course obvious first idea, but the recipe from above is actually from the official k4 cookbook. t=t is less innocent than it seems, i'm afraid.

in k7/k9, we can:

  10^@[100#0.;11*!10;1.]    /just for more lulz

there's also a way to mutate it in place!

[kelas]

nice :) also see here:

https://news.ycombinator.com/item?id=45603661

HN is such a sweetheart. i should check in more often.

[thristian]

Pretty much, yeah! The difference is that in Python the function that calculates a single value looks like:

    foo(x)

...while the function that calculates a batch of values looks like:

    [foo(x) for x in somelist]

Meanwhile in Lil (and I'd guess APL and K), the one function works in both situations.

You can get some nice speed-ups in Python by pushing iteration into a list comprehension, because it's more specialised in the byte-code than a for loop. It's a lot easier in Lil, since it often Just Works.

[RodgerTheGreat]

A few more examples in K and Lil where pervasive implicit iteration is useful, and why their conforming behavior is not equivalent to a simple .map() or a flat comprehension: http://beyondloom.com/blog/conforming.html

[leephillips]

And in Julia it’s foo.(x).

[kelas]

julia is cool, hands down.

only typical k binary will be less than 200kb and doesn't need stdlib. it still needs a few syscalls, but we're working on that.

and julia has this small and insignificant dependency called llvm. i bullshit you not:

  kelas@prng ~ % cd /opt/llvm-project
  kelas@prng llvm-project % du -hd0
   14G .
  kelas@prng llvm-project %