mshook's Feed

Mobile phone app programming with functional Scheme; Scheme, XML & XSLT; Flapjax (Javascript) | http://tinyurl.com/yd77c5j

mshook — Fri, 02 Oct 2009 12:32:00 -0400

One page: http://www.google.com/notebook/public/17894154587286929730/BDV0B5goQxvPDrcEk

Moby
My take on how Moby Works ...
The Moby Scheme Compiler for Smartphones ...
1.2Simulations and Animations: "world.ss" ...
How to Design Worlds: Imagi...
Shriram Krishnamurthi: Talk...
YouTube - Handbells for the...
Handbells for the 21st Century
InfoQ: Javascript as Compil...
Another language that compiles to Javascript is...
examples/bell-choir.ss at m...
The CONTINUE Server Shriram Krishnamurthi Sy...
How to Design Programs: An ...
Contents Preface IProcessing ...
XML
Transformation-by-Example for XML Shriram Kri...
SXSLT: Manipulation Language for XML Oleg Kis...
Flapjax Demos Catch Up Delicious Dra...
Papers
Shriram Krishnamurthi: Publ...
Chronological List of All Papers These papers...

Tagged by mshook under cool, interesting, eclectic, brown, javascript, scheme, lisp, functional, declarative, xml, xslt, mobile, application, gnb, pdafriendly,

A simple Scheme program for Android | http://tinyurl.com/cctauy

mshook — Thu, 01 Oct 2009 04:40:00 -0400

via
http://twitter.com/programmingjoy
Javascript as Compiler Target: Clamato, GWT Smalltalk, Python, Scheme
http://www.infoq.com/news/2009/09/javascript-compilation-target

(require moby/stub/world)

(define WIDTH 320)
(define HEIGHT 480)

(define (render w)
  (place-image 
   (text "Hello World" 10 "Black")
   20
   20
   (empty-scene WIDTH HEIGHT)))

(big-bang WIDTH HEIGHT 10 0)
(on-redraw render)

After a few minutes of poking around, I was able to compile this to Java and then run it on the Android Emulator:

Tagged by mshook under scheme, android, javascript, compiler, lisp, java, mobile, example, code, interesting,

Amorphous Medium Language | Programming reliable behavior on a big mesh network http://web.mit.edu/jakebeal/www/Publications/lsm

mshook — Thu, 01 Oct 2009 03:01:00 -0400

(defprocess root (fuzziness)
 (defvariable blobs #’union)
 (always
  (when (eq (read-sensor ’image) ’black)
   (subprocess (measure-blob) :gradient fuzziness)
   (setf blobs
    (list (get-from-sub (measure-blob) blob)))))
 (avoid
  (read-sensor ’query)
  (let ((q (first (read-sensor ’query))))
   (cond
    ((eq q ’blobs)
     (actuate ’response (regional blobs)))
    ((eq q ’area)
     (actuate ’response
      (fold #’+ (mapcar #’second
       (regional blobs)))))))))
(defprocess measure-blob ()
 (defvariable uid #’max :atomic :base 0 :init (random 1))
 (defvariable area #’sum :reduction :base 0 :init 1)
 (defvariable blob :local)
 (always
  (setf blob (list uid area))))

Code to find a set of fuzzy blobs and their areas in a binary image. Each contiguous black area of the image runs a connected measure-blob pro- cess that names it and calculates its area. The set of blobs is collected by the root process and made accessible to the user on the response actuator...

Tagged by mshook under saved, gmail, sensor, language, lisp, scheme, mit, pdf, mesh, network,

XML and Scheme - an annotated list of resources | http://okmij.org/ftp/Scheme/xml.html

mshook — Sat, 01 Aug 2009 12:07:00 -0400

1. XML and Scheme
 1. Tools: SSAX, SXML, SXPath, SXSLT
 2. Applications, Examples, Sample Code
 3. Papers and Presentations
 4. SSAX-SXML Mailing list  SSAX-SXML SourceForge Project
 5. Miscellanea
 6. Papers and Presentations
 7. Functional XML parsing framework SAX/DOM and SXML parsers with support for XML Namespaces and validation
 8. SXML specification
 9. SXPath -- SXML query language, XPath implementation
 10. SXML traversals and transformations
 11. HSXML: Typed SXML
 12. Applications, Examples, Sample Code
 13. HTML/XML authoring in Scheme
 14. Writing LaTeX/PDF mathematical papers with SXML
 15. Joint processing of two immutable SXML documents with update cursors
 16. Literate XML/DTD programming
 17. SXML as a normalized database
 18. Complete examples of practical (context-sensitive) SXML Transformations
 19. Complete examples of stream-wise (SAX) and DOM parsing
...
1. Last updated March 4, 2007

Tagged by mshook under lisp, scheme, xml, interesting, xslt, theory, academic, list, links, tex, literate, example, xpath, toc,

Following Hong Kong (& Vegas) put create new cities to absorb growing populations to try new technologies & rules http://tinyurl

mshook — Sun, 19 Jul 2009 04:25:00 -0400

http://foratv.vo.llnwd.net/o33/rss/Long_Now_Podcasts/podcast-2009-05-18-romer.mp3

Romer notes that business keeps evolving as new companies introduce new rule sets. The good ideas are copied, and workers migrate from failing companies to the new and old ones where the new rules are working well. The same goes for countries. Starting about 1970, China took some of the effective rules of Hong Kong (which was managed from afar by England) and set up four special economic zones along the coast operating as imitation Hong Kongs. They worked so well that China rolled out the scheme for the whole country, and its Gross Domestic Product took off. “Hong Kong was the most successful economic development program in history.

Tagged by mshook under future, longnow, logical, economics, politics, cities, interesting, mp3, podcast, audio, 2009,

@beagleboard For the mechanics of a real interpreter on arduino: http://bitlash.net/ | http://twitter.com/beagleboard/status/243

mshook — Thu, 02 Jul 2009 09:28:00 -0400

for AI programming on arduino, how about scheme language? http://cli.gs/Q5nqEP http://cli.gs/3bZ51M http://cli.gs/1XHEbQ and read SICP!about 4 hours ago from web

beagleboard

Kenzo Yoshida

Tagged by mshook under arduino, scheme, avr, interpreter, sicp,

Generate Bell 202 FSK tones (high->1200, low->2200 HZ) with a 6 pin PIC & an opamp low pass filter | http://tinyurl.com/mq6axz

mshook — Sun, 14 Jun 2009 07:27:00 -0400

This scheme produces a sampled sine waveform with 12 samples per cycle. In addition to the desired frequency component, f₀, this waveform contains higher-frequency components at (12k+1)f₀ and (12k−1)f₀, k=1,2,3, and so forth. The lowpass filter comprising IC_2B, R₇, R₈, C₃, and C₄ easily filters out these undesired components of smaller amplitude. Listing 1 is the assembly-program code that implements the Bell 202 FSK standard. When the control input Data In is high, the output frequency is 1200 Hz; when the control is low, the output frequency is 2200 Hz. The transition from one frequency to the other occurs in a manner that retains phase continuity.

Tagged by mshook under modulation, saved, fsk, modem, pic, how, circuit, code, schematic, pdf, audio, bell,

Little Schemer notes/index | http://tinyurl.com/l2pgee | http://mshook.appspot.com/z/d4m.htm?/mshook/5+june+2009+b

mshook — Fri, 05 Jun 2009 08:13:00 -0400

* http://mshook.appspot.com/z/d4m.htm?/mshook/scheme
* The Ten Commandments
   1. How to recur on a list of atoms, a number and an S-expression | 23 64 83
   2. Cons to build | 37
   3. Typical element, cons & recur | 45
   4. Change >= 1 arg closer to termination & test | 57 65 84
   5. +, X & cons; test 0,1,() | 67
   6. When to simplify | 94
   7. Subparts: sublists & subexpressions | 103
   8. Abstract reps w/ funcs | 107
   9. Abstract patterns w/ funcs | 134
  10. Funcs to collect > 1 value | 140
* The Five Rules
   1. Car 5
   2. Cdr 7
   3. Cons 9
   4. Null? 10
   5. Eq? 12
* Dimensions of functions
   o On lats (lists of atoms - flat), numbers or S-expression (hierarchy)
   o Test, insert (L/R), replace, remove
   o Straight/single function, abstracted/generalized
* Data types and structures
   o atom 3
   o number
   o list 3 & 4
   o S-expression 3 & 4
   o lat (list of atoms) 15
   o set 111
   o pair 117 & 118
   o rel 119
more at http://tinyurl.com/kll3de

Tagged by mshook under lisp, scheme, book, index, notes, good, 5, june, 2009, b, theory,

Recursive Functions of Symbolic Expressions and Their Computation by Machine + LaTeX source http://tinyurl.com/kuxscq

mshook — Sat, 30 May 2009 09:27:00 -0400

About this document ... Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I

This document was generated using the LaTeX2HTML translator Version 2002-2-1 (1.70)

The command line arguments were:
latex2html recursive.tex

The translation was initiated by John McCarthy on 2006-08-13

John McCarthy
2006-08-13 Tagged by mshook under classic, lisp, scheme, 1950s, history, latex, source, cool, theory,

tag-query - Scheme - http://tinyurl.com/tag-query-in-scheme

mshook — Fri, 22 May 2009 04:02:00 -0400

(define db (quote (
((content)(tags))
((here is an example of content) (example content))
((an entry is a list containing two lists. The first list is the content. The second list is tags) (explanation tags))
)))

(define get-content (lambda (entry) (car entry)))

(define get-tags (lambda (entry) (cadr entry)))

(define subset? (lambda (keys lat)
  (cond ((null? keys) #t)
        ((memq (car keys) lat) (subset? (cdr keys) lat))
        (#t #f))))

(define tag-query (lambda (tags db)
  (cond ((null? db) '())
        ((subset? tags (get-tags (car db))) (cons (car db) (tag-query tags (cdr db))))
        (#t (tag-query tags (cdr db))))))

Tagged by mshook under lisp, scheme, code, tags, example, short, query, search,

McCarthy's eval translated to Common Lisp by Paul Graham http://tinyurl.com/eval-mccarthy-graham

mshook — Wed, 20 May 2009 11:25:00 -0400

(defun eval. (e a)
  (cond
    ((atom e) (assoc. e a))
    ((atom (car e))
     (cond
       ((eq (car e) 'quote) (cadr e))
       ((eq (car e) 'atom) (atom (eval. (cadr e) a)))
       ((eq (car e) 'eq) (eq (eval. (cadr e) a)
                             (eval. (caddr e) a)))
       ((eq (car e) 'car) (car (eval. (cadr e) a)))
       ((eq (car e) 'cdr) (cdr (eval. (cadr e) a)))
       ((eq (car e) 'cons) (cons (eval. (cadr e) a)
                                 (eval. (caddr e) a)))
       ((eq (car e) 'cond) (evcon. (cdr e) a))
       ('t (eval. (cons (assoc. (car e) a)
                        (cdr e))
                  a))))
    ((eq (caar e) 'label)
     (eval. (cons (caddar e) (cdr e))
            (cons (list (cadar e) (car e)) a)))
    ((eq (caar e) 'lambda)
     (eval. (caddar e)
            (append. (pair. (cadar e) (evlis. (cdr e) a))
                     a)))))

http://www.paulgraham.com/rootsoflisp.html

Tagged by mshook under lisp, eval, beautiful, elegant, minimal, concise, 20, may, 2009, a, how, scheme,

Pico Lisp - the C source is 185KB in 10 files

mshook — Sun, 17 May 2009 07:45:00 -0400

For something even smaller, download miniPicoLisp.tgz. It is a minimal version, without support for databases, UTF-8, bignums, IPC, networking and other system-dependent functions. A kind of "pure" Pico Lisp (not "pure Lisp"!). It supports the full Pico Lisp language, but runs faster, and uses even less memory space. It should also not be restricted to Unix. In addition, it compiles and runs also on 64-bit systems.
Jon Kleiser wrote an OpenGL library gl.tgz, and a Chinese Checkers program running on top of it.

Tagged by mshook under lisp, c, small, tiny, scheme, up, how,

Scheme eval from Structure and Interpretation of Computer Programs http://tinyurl.com/sicp-eval

mshook — Sat, 16 May 2009 05:56:00 -0400

(define (eval exp env)
  (cond ((self-evaluating? exp) exp)
        ((variable? exp) (lookup-variable-value exp env))
        ((quoted? exp) (text-of-quotation exp))
        ((assignment? exp) (eval-assignment exp env))
        ((definition? exp) (eval-definition exp env))
        ((if? exp) (eval-if exp env))
        ((lambda? exp)
         (make-procedure (lambda-parameters exp)
                         (lambda-body exp)
                         env))
        ((begin? exp) 
         (eval-sequence (begin-actions exp) env))
        ((cond? exp) (eval (cond->if exp) env))
        ((application? exp)
         (apply (eval (operator exp) env)
                (list-of-values (operands exp) env)))
        (else
         (error "Unknown expression type -- EVAL" exp))))

http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-26.html

Tagged by mshook under sicp, eval, lisp, scheme, code, 16, may, 2009, b,

Don Clucas Stirling engine generator development

mshook — Sat, 16 May 2009 04:32:00 -0400

Tagged by mshook under saved, stirling, engine, design, pdf, via, scheme,

Accumulator generator in JavaScript & Scheme http://tinyurl.com/qcs9dg

mshook — Sat, 16 May 2009 02:30:00 -0400

We want to write a function that generates accumulators-- a function that takes a number n, and returns a function that takes another number i and returns n incremented by i.

JavaScript

function foo(n) { return function (i) { return n += i } }

Scheme

(define (foo n) (lambda (i) (set! n (+ n i)) n))

Try

JavaScript

function main() { function foo (n) { return function (i) { return n += i } } ; a = foo(5); print(a(1)); print("n"); print(a(4)); }

Scheme

(define (foo n) (lambda (i) (set! n (+ n i)) n)) (define a (foo 5)) (a 1) (a 4)

via Paul Graham's Revenge of the Nerds

Tagged by mshook under lisp, scheme, javascript, 16, may, 2009, a, example, code, theory, comparison, good, closure,

The Roots of Lisp | "the defining quality of Lisp-- is that it can be written in itself." | http://tinyurl.com/roots-of-lisp

mshook — Fri, 15 May 2009 10:59:00 -0400

(I wrote this article to help myself understand exactly what McCarthy discovered. You don't need to know this stuff to program in Lisp, but it should be helpful to anyone who wants to understand the essence of Lisp-- both in the sense of its origins and its semantic core. The fact that it has such a core is one of Lisp's distinguishing features, and the reason why, unlike other languages, Lisp has dialects.)

In 1960, John McCarthy published a remarkable paper in which he did for programming something like what Euclid did for geometry. He showed how, given a handful of simple operators and a notation for functions, you can build a whole programming language. He called this language Lisp, for "List Processing," because one of his key ideas was to use a simple data structure called a list for both code and data.

Tagged by mshook under lisp, why, theory, history, 1950s, scheme, recursion,

A multi-language (scheme, ruby, javascript &c.) web-based command line interface

mshook — Tue, 14 Apr 2009 02:31:00 -0400

Experimental, built on Google App Engine Tagged by mshook under scheme, ruby, gae, javascript, cli, experiment, viapopular,

The ur-game for computers — Adventure - adventure.pdf (application/pdf Object)

mshook — Sat, 19 Jan 2008 06:27:00 -0500

I urge everybody to play the game ﬁrst, at least ten times, before reading on. But you cannot fully appreciate the astonishing brilliance of its design until you have seen all of the surprises that have been built in. I believe this program is entirely faithful to the behavior of Adventure Version 1.0, except that I have slightly edited the computer messages (mostly so that they use both lowercase and uppercase letters). I have also omitted Woods’s elaborate machinery for closing the cave during the hours of prime-time computing; I believe John McCarthy insisted on this, when he saw the productivity of his AI Lab falling oﬀ dramatically (although it is rumored that he had a special version of the program that allowed him to play whenever he wanted). And I have not adopted the encryption scheme by which Woods made it diﬃcult for users to ﬁnd any important clues in the binary program ﬁle or core image; such modiﬁcations would best be done by making a special version of CTANGLE. All of the spelunking constraints and in Tagged by mshook under game, knuth, pdf, how, wishlist, if, interactive, fiction, literate, c,

» Why OLPC mesh wireless networking won’t work | George Ou | ZDNet.com

mshook — Sat, 19 Jan 2008 09:09:00 -0500

"it would take more than 400 OLPC laptops to cover the same area and they would all have to be spaced out perfectly. We also have the possibility of using 500mW radios and 16 dBi antennas for even longer range in rural areas. When we consider the fact that a single failure in one of the mesh nodes due to battery drainage, moving out of range, software hang will cause the entire mesh scheme to break, there simply is no way to get around the centralized architecture." Tagged by mshook under mesh, critique, wifi, how, why, comparison, via, robotwisdom, olpc, xo,

An Introduction to Scheme and its Implementation - Table of Contents

mshook — Thu, 27 May 2004 03:06:00 -0400

Tagged by mshook under fromdelicious,