Show HN: Persistent Group Chat in kdb+/k/q

Is q more readable to you?

  file:hopen`:index.txt                       / Open message log append-only
  history:("\n"sv read0`:index.txt),"\n"      / Load message history from log
  .z.po:{neg[.z.w]history}                    / On join, send full message history
  .z.ws:{s:(" "sv(string"du"$.z.Z))," ",x;    / On message, add server timestamp
         {neg[x]y}\:[key .z.W;s];             / Fan out to other connections
         history::(history,s,"\n");           / Update message history in memory
         (neg file)s}                         / Append to message log file
  .z.ph:{"\n"sv read0`:chat.htm}              / Serve static client app

Have you ever read any documentation, tutorials or explanations of K? It seems rather odd to expect to be able to understand a programming language without learning about it first.

All it's doing is opening a file, connecting to other clients and appending the messages between clients to the file.

What you're missing is that K automatically sets up an environment with the necessary pieces in place. A server, the sockets, a type of reactive/eventloopy environment.

Everything else is just function call/index/assignment and some mappy/foldy stuff

In some ways its the same reason Mathematica seems so magic sometimes.

Thanks for the feedback; I pushed your cleaned up version to Github (https://github.com/srpeck/kchat/commit/5669fcca67fa609a9128b...).

As for your comment in #5, I noticed that I can hot load new versions of the server and client without impacting the existing clients' web socket connections. A production change to chat.htm only requires me to \l chat.k; any existing connections still have the older client running without interruption until they refresh, but all new connections get the new client. However, I am not all that concerned about hot loading new versions, as this is only deployed for a small team on the intranet.

I was just tinkering with a tic tac toe game: https://github.com/JohnEarnest/ok/blob/gh-pages/examples/tic...

I think I can still make a number of simplifications and generalizations, and I'd like to have a stab at an alpha-beta AI opponent.

There's also a great deal of interesting code at No Stinking Loops: http://www.nsl.com

Have a look at Arthur's text editor in k5: http://kparc.com/edit.k

And of course the impending kOS operating system: http://kparc.com/ with HN discussion: https://news.ycombinator.com/item?id=8475809

There are also some good links here, though you may have to dig: http://www.reddit.com/r/apljk/

Every time these k folks show up on HN, it feels like Chuck Moore and Color Forth.

Don't dismiss things you don't understand: I think array programming is extremely useful for parsing, and I also think that with some untraining and some practice you would find it easy to read and write.

I have a new programmer- strong maths background, but no programming experience prior to K which she started about two weeks ago.

Today, she's working on taking strings that look like this:

    y:"http://host/path/to.a.swf,http://host/path/to/b.swf"

and finding out if the url-fragments are "claimed" by any any other user in a database, AND if the current user claims any url-fragments. So she has a database like this:

    d:`f`u!(("adap.tv";"adap.tv";"btrll.com";"btrll.com";"cbs.com";"cbsinter…
    l:?d`f

and in about thirty minutes of puzzling came up with this:

    |/#:'y ss/:l[&~|/d.f[&x=d.u]~/:\:l]

Since you don't know K I'll walk you through it:

    d.f[&x=d.u]~/:\:l

This returns a list of bitmaps, such as:

    (10000000000000000b;00000100000000000b)

What it's doing is taking all of the urls and indexing it by the where (&) address of each x (parameter to function: user id) is equal to the array of all of the users. That is, x=d.u returned: 01000001000000000000000000b and &x=d.u returned 1 7 (because the second and eighth element of that bitmap are ones). d.f[1 7] returns the second and eighth fragment.

Then, she &~|/ which ors- the bitmaps (|/) together, finds their complement (~), and takes the where of (&) them, so in this case 0 5. l[0 5] then returns the strings in the master list.

Note this is the list of all of the url fragments owned by other users:

    l[&~|/d.f[&x=d.u]~/:\:l]

In PHP you might try to write:

    $mine = array();
    $theirs = array();
    foreach($db as $row) {
      if($row->u === $x) $mine[$row->f]=0;
      else $thiers[$row->f]=0;
    }
    $list = array_diff(array_keys($thiers),array_keys($mine));

but there's a lot of syntax here, and a number of PHP function calls that a beginner might not be aware of. She's just using this:

    http://www.timestored.com/kdb-guides/files/kdb-cheat-sheet.pdf

So then on to y ss/: which basically does a `strpos()` of each of our urls against the list we're scanning (i.e. the thing that looks like "http://url,http://otherurl". She then counts each (#:') result, takes the max again (|/). This means if ANY of those match, return `1b` otherwise return `0b`.

I'm working on a algo-trading system and thinking of moving my tick data to kdb+, however I see no price on their site, care to enlight? Also, do you know what are the limits of the free evaluation/32-bit version? Thanks

Thanks, added.