Live Coding with Fluxus

Fluxus is a live coding system built on PLT Scheme.

Fluxus reads live audio or OSC network messages which can be used as a source of animation data for realtime performances or installations. Keyboard or mouse input can also be read for games development, and a physics engine is included for realtime simulations of rigid body dynamics.

Fluxus is a very cool system and the maintainer Dave is a very nice guy. Be sure to check it out!
Addendum: 8/14/8
Dave posted some links to videos of fluxus and the no copy paste jam.
(via PLT)

Lovable code

Today I ended up reading a particular post over at Black Grit, Inc. about their CafePress storefront.

Since mzscheme supports unicode, I would’ve done it like this (in R5RS code):

(define ♥
  (lambda xs
      (display "I ♥ ")
      (let loop ((xs xs))
        (display (car xs))
        (if (not (null? (cdr xs)))
              (display " ")
              (display "and ")
              (loop (cdr xs))))))))

so that you could write:

(♥ ’scheme)

How to Learn Scheme (was How to Learn Programming)

  1. The Scheme Programming Language Third Edition by R. Kent Dybvig
  2. How to Design Programs by Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, and Shriram Krishnamurthi
  3. Structure and Interpretation of Computer Programs by Harold Abelson and Gerald Jay Sussman with Julie Sussman

Addendum 6/26/8:
The difference between learning a programming language and learning how to program is now clear enough to me that I had to revise this post to clarify its intent and correct its content. As such, the title has been changed, and only one book has been recommended.

Composing Functions with Scheme

In the PLT thread [‘complement'[?] of map] Stephen de Gabriel asked if there was a function that would take any number of functions, and an argument, and then apply the first function to the argument, and apply the second function to the result of the first, and so on.
In PLT Scheme, the function is called ‘compose’. Compose:

Returns a procedure that composes the given functions, applying the last f first and the first f last. The composed functions can consume and produce any number of values, as long as each function produces as many values as the preceding function consumes.

I asked if this was typical FP style, and Noel replied that it is so common that compose is an infix operation in Haskell and ML, as far as he could recall.
Here is an example (from the thread) of how it works using the “Pretty Big” language:

(define pam
  (lambda (datum . proc-list)
    ((apply compose proc-list) datum)))
 (lambda (n) (/ n 7))
 (lambda (n) (- n 3))
 (lambda (n) (+ n 10))
 (lambda (n) (* n 7)))
> 3