Author: grant

What you do

We no longer care what you say.
We care a great deal about what you do.
If you charge for hand raking but use a leaf blower when the client isn’t home
If you sneak into an exercise class because you were on the wait list and it isn’t fair cause you never get a bike
If you snicker behind the boss’s back
If you don’t pay attention in meetings
If you argue with a customer instead of delighting them
If you copy work and pass it off as your own
If you shade the truth a little
If you lobby to preserve the unsustainable status quo
If you network to get, not to give
If you do as little as you can get away with
…then we already know who you are.

(via Seth)

Decentralized Scheme Code Tracker

Aaron posted here here about Descot; a scheme to manage Scheme libraries. This is the alpha version. Based on his explanation, my impression is that the goal is to simplify the management and distribution of libraries without being a package manager itself like PLT and Chicken Scheme include. Those managers, though, might use Descot as a source of libraries.

Why there is not restart exception handling in PLT Scheme

YC asked here[1]:

Is it possible to handle exceptions like Common Lisp, specifically restarts?
Scenario: undefined variables – handling by defining the variable, and continue past the exception.

Matthew explained what is and is not possible in the following threads here, here, and here.
[1]: PLT Scheme Mailing list, “restart exception handling?”, Thu Jul 10 17:35:57 EDT 2008

Two sids of the same coin: coroutines and streams

Jos asked here:

It seems to me that in many cases the same problem can be solved (for an eager evaluater) both by coroutines and by streams. Both solutions very well show the structure of the principal algorithm as might have been written with a lazy evaluator in mind. Which approach would be preferred in terms of efficiency (time and memory). May be you would like to address other aspects as well. One reason that makes me tend to choose streams, is that the latter seem better suited to automatic code generation from purely lazy code.

To which Matthais replied here:

It is indeed a well-known fact that streams and coroutines are two sides of the same coin. Talcott’s 1986 dissertation is the earliest theoretical treatment that I know.

Which Jim clarified here:

I believe the reference is to Carolyn Talcott’s dissertation “The essence of Rum: A theory of intensional and extensional aspects of Lisp-type computation”. Stanford, 1986. Unfortunately this is not available online, as far as I know.

Hacking PLT to add a range syntax

Here is a post demonstrating how to add an infix range syntax to PLT Scheme.

[a .. b]  => (interval a b)
(... expr1 [expr2] ...) => (... (vector-ref expr1 expr2) ...)

Addendum: 04/20/09
Here is the final version of the code, with additional interesting syntax:

That includes:
[1 .. 4] short interval (1 to 3)
[1 … 4] long interval (1 to 4)
Curry with {}:
{+ _ 3} => (lambda (x) (+ x 3)
{+ _ (* 2 _)} => (lambda (x y) (+ x (* 2 y)))
This is convenient with map and filter:
(map {+ _ 3} [1 … 3]) => ‘(4 5 6)
Iota from SRFI 1:
[5] => (iota 5) => (0 1 2 3 4)
[5 3] => (iota 5 3) => (3 4 5 6 7)
[5 3 2] => (iota 5 3 2) => (3 5 7 9 11)
Lambdas:
{n -> (+ n 1)} is (lambda (n) (+ n 1)
And a very simple comprehension:
> [(+ n 3) : n is (< n 10) (even? n)] (3 5 7 9 11) > [(+ n 3) : n is (< n 10)] (3 4 5 6 7 8 9 10 11 12) > [(* n n) : n is (< n 10) (odd? n)] (1 9 25 49 81)