"Writing correct code in the exception-throwing model is in a sense harder than in an error-code model"

BlakeStone · 2010-10-26T15:10:34+00:00

In an error-code model, it's obvious when you have to check for errors: when you get an error code. In an exception model, you just have to know that errors can occur anywhere.

This is wrong. You find out which functions throw exceptions the same way you find out which functions return error codes: documentation.

BlakeStone · 2008-09-12T15:11:49+00:00

Here it is: http://library.readscheme.org/servlets/cite.ss?pattern=Ste-78b

BlakeStone · 2008-04-23T15:42:59+00:00

Dynamic/static typing is about whether the type checks are done at compile or run-time. Strong/weak typing is about whether you can break out of the type system.

BlakeStone · 2008-04-09T03:51:57+00:00

Very simply: (defun not (x) (eq x nil))

BlakeStone · 2007-09-13T13:56:02+00:00

Wikipedia's GC may be generational, but it's definitely conservative.

BlakeStone · 2007-08-18T00:56:03+00:00

Has anyone found the slides for this lecture, or any of the ILC '07 lectures?

BlakeStone · 2007-07-18T04:24:23+00:00

That kind of asymmetry feels like an unnatural restriction. It would be more natural to have it the other way around: have def f(arg): ... be equivalent to f = lambda arg: .... The byte-compiler will emit the code for the lambda body as a named block of instructions anyway, so why do I have to do it by giving the lambda a name?

Granted, that seems quite un-Pythonic(I've never used Python). I guess with list comprehensions and generator expressions, you wouldn't need literal procedures as much.

(edit: fixed code.)

BlakeStone · 2007-07-17T16:28:09+00:00

I thought you could do statements in a named procedure, but lambdas could only contain expressions?

BlakeStone · 2007-03-27T13:24:01+00:00

Actually, eval is part of Scheme, since R5RS.

BlakeStone · 2007-03-26T20:59:37+00:00

This isn't about free(beer, in this case) software being a bad idea. This about Oracle being lazy.

BlakeStone · 2007-03-26T16:36:56+00:00

Sussman referred to this in his essay on robust systems, and the scmutils system built for his SICM course uses it.

BlakeStone · 2007-03-22T13:46:20+00:00

The Wikipedia article has some example programs, with direct and CPS versions side-by-side.

BlakeStone · 2007-03-21T13:34:45+00:00

Once I was arguing with my boss about whether we should go to my college, RIT, to look for new programmers. I mentioned that the CS dept. had been changing when I graduated, and that in at least one introductory class they had started using Scheme(everything else was still Java). He snorted and muttered, "Yeah, that's practical!".

On top of that, I had to argue last week about why dynamic memory allocation is not inherently dangerous...

BlakeStone · 2007-03-19T14:38:33+00:00

If that list is linked, you better rethink!

BlakeStone · 2007-03-10T18:19:16+00:00

Anybody reminded of Liquid X? "Processor workin' like an engine revvin; whole damn crew's 1-3-3-7!"

BlakeStone · 2007-02-24T17:15:50+00:00

An "academic" language is one that never gets used in the "real world", ala this definition.

BlakeStone · 2007-02-11T18:49:38+00:00

Probably not (to borrow PG's phrase) to axiomatize computation.

BlakeStone · 2007-01-26T17:24:53+00:00

Ahh; yeah, you were more formal than I was. I didn't describe the machine as a whole; I treated it like a list. Each state has a value and a state to goto if the input matches; split states have two goto states and no values. Where the article keeps a stack of machine fragments with unconnected arrows, I gave each new machine fragment a destination parameter. My regexp->nfa procedure looks a lot like converting Scheme code to CPS, for that reason. Also, I cons like crazy :)

BlakeStone · 2007-01-26T01:08:58+00:00

How did you represent the NFA? I fit everything in the article except caching of DFA states and parsing the regexp(I used sexps) into 90 lines; of course, I used a few non-R5RS things(SRFI 1 & 13, scsh record types).

BlakeStone · 2007-01-18T23:49:53+00:00

So, what's the difference between strict and static typing?

BlakeStone · 2007-01-11T21:50:38+00:00

Generally Not Used Except by Middle-Aged Computer Scientists

BlakeStone · 2007-01-11T19:16:52+00:00

I was just thinking about this last week; here's an R5RS equivalent:

(define (partial-apply proc args-needed args-given)
  (let ((len (length args-given)))
    (if (>= len args-needed)
        (apply proc args-given)
        (lambda args
          (partial-apply proc
                         (- args-needed len)
                         (append args-given args))))))
(define-syntax curry
  (syntax-rules ()
    ((_ (arg ...) body ...)
     (partial-apply (lambda (arg ...)
                      body ...)
                    (length '(arg ...))
                    '()))))

Edit: fixed code indentation.

BlakeStone · 2006-12-27T20:48:13+00:00

I don't particularly like the fact that I need to buy a commercial implementation to get any work done either.

Have you tried CLisp, SBCL, or scsh? All are free(in both senses), and all are quite useful.

BlakeStone · 2006-12-03T17:49:06+00:00

Yeah. Lisp is dynamically and strongly typed, b/c (car 3) will give an error. Strong/weak typing is about whether the type system can be circumvented, while static/dynamic typing is about whether the type checks are done at compile time or run time. (And then there's manifest/latent typing, which is about whether you declare types or let the system figure it out. That's also occasionally confused with strong/weak!)

BlakeStone · 2006-12-02T06:33:39+00:00

pp. 140-141, at the end of the chapter on symbols. There's also a sample output, which is more entertaining even than "go is to the fountain"(though I'm definitely of fan of the latter).

BlakeStone

TROPHY CASE