lumen

can properly highlight atstrings: https://i.imgur.com/wO4f742.png It's probably hard to tell, but the "@(hexrep border-color*)" would normally be highlighted as if it were a string. Arc has a feature called atstrings, where you can use @foo to reference the enclosing variable "foo". It can also call functions, e.g. "The value of 1 plus 2 is @(+ 1 2)" will become "The value of 1 plus 2 is 3".

t also revealing the purpose of those sensitive areas. Abuse detection is possibly the mildest example, but I imagine the standard deviation on surprise is extraordinarily high for a random HN feature. Those two things (esoteric knowledge requirements + {competent,trustworthy,motivated}) means that Dan and his team are often short-handed. I am speaking from ignorance here, but it would be remarkable if they somehow weren't. The YC software team also covers a huge amount of territory as of today, from maintaining ycombinator.com's Rails codebase to keeping "Work at a Startup" infrastructure running smoothly. Some of it needs HN integration, like the ability for the YC application to cross-reference the HN usernames of each founder, which seems to use some sort of oauth token that I'm sure wasn't effortless to get working in Arc. The most well-placed person to do all of this work is Dan, but Dan himself has to spend a majority of his time moderating HN. Yet through all that work, he still finds the time to create megathread indexes like this one. So, knowing what I know, when I see that, I can't help but take off my hat for a moment and say something. Apologies for the confusion. Dan also helped design Lumen, a Lisp that bootstraps itself entirely in Javascript or Lua: http://github.com/sctb/lumen I fell in love with it around... five years ago? Something like that. And to this day I still write code in it all the time: https://news.ycombinator.com/item?id=26804484 (I've been meaning to ship a Tensorflow/Pytorch code generator, one of these days.) The last aspect of it is that I once had an opportunity to work on getting him some desperately-needed tooling back in 2016, but I totally blew it. The first thing he asked for was an Arc indentation plugin for Emacs, which I had never touched till then. Unfortunately my life was in complete chaos at the time (https://gist.github.com/shawwn/3110ab62fa027c7811578f167fa5a...) and various things were happening that made me turn bitter, to say the least. ("Crazy-seeming dickhead" might be a better phrasing, depending on who you ask.) I ended up delivering nothing, when I could have improved his workflow substantially. (I myself have been using some Arc vim indentation plugin I found somewhere around a decade ago, and god bless whoever wrote that; it's been so lovely. So I know how important that kind of thing can be.) Once I got my life in order, and have had several years to reflect, I realized what a unique and cool opportunity it was that I squandered, and I've regretted it ever since. So that was the middle paragraph talking. But! I had my shot, and you might be able to get one too. If you (or whoever's reading this) happens to have a unique combination of skills, a lot of free time, and are willing to work extremely hard, then I encourage you to email hn@ycombinator.com and tell 'em you're willing to lend a hand with whatever odd jobs they need. They'll probably appreciate it. Or maybe they don't need anything. That was 2016, this is 2021, and HN has been running fantastically well all this time. That's why I shall settle for the cheerleader role. :) Anyway, this is all entirely off-topic, so if it's inappropriate then please feel free to collapse or detach it, of course. But in my opinion that whole infrastructure hemisphere is one of the more interesting places in the world, a bit like Hogwarts, so I wanted to ramble a little bit. Back to ML!

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) As you can see, macros do an incredible amount of work under the hood. This code is reminiscent of the parent comment's try.then.then.catch example, yet the source code is wonderfully readable. Thus, lisp's power. If you want to play around with it: git clone https://github.com/shawwn/pymen cd pymen git checkout ml # optionally, brew install rlwrap rlwrap bin/pymen > (load "lib/onlisp.l") > (choose-bind-test) 0123456 Note, I didn't invent this technique. This is courtesy of Scott Bell's Lumen lisp: https://github.com/sctb/lumen I "merely" ported it to Python, and a few billion other things over the years. The specific example listed in the tweet was made using this: (=defun path (node1 node2) (if (null? (neighbors node1)) (fail) (in node2 (neighbors node1)) (=values (list node2)) (=bind (n) (choose (neighbors node1)) (=bind (m) (path n node2) (=values `(,n ,@m)))))) (defconst nodes* (obj a: '(b d) b: '(c) c: '(a) d: '(e) e: '())) (def neighbors (n) (get nodes* n)) Which you can run like this: > (print (str (path 'a 'e))) ("d" "e") > (print (str (fail))) ("b" "c" "a" "d" "e") > (print (str (fail))) ("b" "c" "a" "b" "c" "a" "d" "e") > (print (str (fail))) ("b" "c" "a" "b" "c" "a" "b" "c" "a" "d" "e") The (print (str ...)) stuff is because otherwise it would pretty-print the actual python objects, which are dictionaries. It's a bit harder to read. > (fail) {0: 'b', 1: 'c', 2: 'a', 3: 'b', 4: 'c', 5: 'a', 6: 'b', 7: 'c', 8: 'a', 9: 'b', 10: 'c', 11: 'a', 12: 'd', 13: 'e'} As you can see, lists are represented as dicts, not cons cells. So, to sum up, Lisp is so powerful that I was able to port pg's On Lisp examples with almost no modification whatsoever, directly into Python. These examples are almost verbatim from the book. (There are more in the github links above.) Since this will be my last chance to demonstrate this for some time, I close with an example of the "ballet" from On Lisp, where multiple processes are collaborating together to reach some goal: (program ballet () (fork (visitor 'door1) 1) (fork (host 'door1) 1) (fork (visitor 'door2) 1) (fork (host 'door2) 1)) expands into: setenv("ballet", macro=__ballet__macro1) def L_61ballet(L_42cont42=None): global L_42procs42 L_42procs42 = None ____x179 = ["visitor", ["quote", "door1"]] def __f60(__id39=None): L_61visitor(L_42cont42, "door1") return pick_process() L_42procs42 = join([make_proc(state=__f60, pri=1)], L_42procs42) ____x183 = ["host", ["quote", "door1"]] def __f61(__id40=None): L_61host(L_42cont42, "door1") return pick_process() L_42procs42 = join([make_proc(state=__f61, pri=1)], L_42procs42) ____x187 = ["visitor", ["quote", "door2"]] def __f62(__id41=None): L_61visitor(L_42cont42, "door2") return pick_process() L_42procs42 = join([make_proc(state=__f62, pri=1)], L_42procs42) ____x191 = ["host", ["quote", "door2"]] def __f63(__id42=None): L_61host(L_42cont42, "door2") return pick_process() L_42procs42 = join([make_proc(state=__f63, pri=1)], L_42procs42) while True: L_print("looping") time.sleep(0.5) if not is63(pick_process()): break return catch(L_42halt42) Notice the incredible amount of leverage you get from macros. Most programmers simply go ahead and write that kind of callback-hell-style code in other languages. Bugs become very difficult to spot. Here, you don't need to.