skrishnamurthi
Joined 13 years ago
Karma
528
Submissions
250
Member since
Nov 9
Shriram Krishnamurthi
Professor of Computer Science
Brown University
https://cs.brown.edu/~sk/
View on Hacker NewsRecent submissions
Comment · 10 months ago
Proof-of-work was originally proposed precisely for email (specifically spam), by Dwork and Naor back in 1993!
Comment · 10 months ago
Author here. That's not true.
GTD asks you to figure out now the action for each thing, think about how long that will take, figure out if it will take more than 2 (or N) minutes, and if ≤ that, do it now. The "do it now"s can add up to a lot of time and distraction. DBTC is the sorting step but without the "figure out the action" step or (most critically) the "do it now" step. And there's no reflection step, either.
So it's not "literally reinvented", not even "almost".
Comment · 10 months ago
I'm the author of the original article, I'm a tenured professor, and none of these things is optional for me. Indeed, I wrote this article several years into being a full professor, because my obligations had only grown, not reduced, by virtue of all the promotions. Of course different people have different senses of how "obliged" they are or should be.
Comment · 1 year ago
Ah, I didn't know there was a HOPL paper! Some day I will have time to run a course reading HOPL papers. Some day I will have the time to read HOPL papers myself (-:. Thanks for the pointer.
Comment · 1 year ago
Thanks for the pointers. Trampolining is an old idea for obtaining tail-calls. It's a kind of folk-wisdom that has been rediscovered many times, as the related work here shows:
https://dl.acm.org/doi/pdf/10.1145/317636.317779
Usually the trampoline is implemented automatically by the language rather than forcing the author to confront it, though I can see why Clojure might have chosen to put the burden on the user.
Comment · 1 year ago
It's not the same thing. `recur` in Clojure must be in tail-position. This program
https://news.ycombinator.com/item?id=45154253
would therefore not work.
Comment · 1 year ago
Tails calls are especially useful in languages with macros. You don't know what context you are in, you just generate the call that makes sense. If the call happens to be in tail-position, you get the benefit of it.
Moreover, you can design cooperating macros that induce and take advantage of tail-position calls.
Here's a simple example that motivates tail-calls that are not tail-recursive:
https://cs.brown.edu/~sk/Publications/Papers/Published/sk-au...
Comment · 1 year ago
Thanks for the suggestion to replace the reference to MzLib with SRFI-31. I've done that now.
https://github.com/shriram/anonymous-recursive-function/comm...
Comment · 1 year ago
The correlation is likely causal in both directions.
They're niche because they're doing weird, interesting things. Like creating their own VMs to support funky features. So nobody wants to depend on them: low bus-factor.
They can do weird, interesting things because they don't have a large user-base that will yell at them about how they're breaking prod.
Comment · 1 year ago
Aaah, thanks Neil!
Comment · 1 year ago
This isn't the Y-combinator.
Comment · 1 year ago
1. This isn't the same. `rec` names the function. This does not name the function. The point is to illustrate how the name-capture works.
2. The README literally says "Don't Use This Macro!" and references `rec` to use instead:
https://github.com/shriram/anonymous-recursive-function?tab=...
Comment · 1 year ago
Neat! Will see if I can make it (though I'll probably have to be dealing with OOPSLA stuff at the same time )-:).
Comment · 1 year ago
These are great questions!
Yes, what you're describing is the "extreme" version of LOP. Of course you don't have to do it that aggressively to get working code.
Two references I like to point to:
https://www.hashcollision.org/brainfudge/
They will give you a sense of how one uses LOP productively.
You do not need to write a "web server language"! To the contrary, the Web server provides several languages to give you a trade-off between ease and power in writing server-side Web applications. So you can just write regular Racket code and serve it through the server. The server also comes with some really neat, powerful primitives (orthogonal to LOP) — like `send/suspend` — that make it much easier to write server-based code.
Comment · 1 year ago
This isn't meant to be a good programming mechanism, it's meant to be an illustration of how to use the macro system.
But also, if you're processing non-linear data, you're going to want to do with a recursive function anyway. E.g., when dealing with a tree. Code below; can't seem to get multi-line code-formatting so it looks hideous:
#lang racket
(require "anon-rec.rkt") (require rackunit)
(struct mt ()) (struct node (v l r))
(define sum-tree (lam/anon (t) (cond [(mt? t) 0] [(node? t) (+ (node-v t) ($MyInvocation (node-l t)) ($MyInvocation (node-r t)))])))
(define t (node 5 (node 3 (mt) (mt)) (node 7 (node 9 (mt) (mt)) (mt))))
(check-equal? (sum-tree t) 24)