#lang scribble/manual

@section{Introduction}

In the field of computer science, we have various model of computation
(such as turing machine and lambda calculus), and we have various
programing languages. In the real word, we have all sorts of computing
machine. So the basic question is: whether our programing language
(all model of computation can be seem as a programing language) models
the physical machine appropriately? Surprisingly, the answer for most
programing language/model of computation is no: the mismatch is
resources, for example, number of memory. All physical computing
machine, already build or to be build/designed, only had/has/will have
a limit amount of memory. But most of the programming language/model
of computation give a false illusion of unlimited resource (there's a
few exceptions, which we will talk in the related work part): Turning
machine requires an infinite tape; Cellular automaton assume an
unlimited space; On the programming language side, the stack might
overflow, but it's not part of the language specification; for
language without automatic memory management, e.g. C, a malloc call
might fail, but most of the time programmers are not aware of that;
for garbage collected language, e.g. PLT Scheme, there's even less
information for a user when an underlining (inside) call to malloc
fails.

Here I implemented a resource limited version of Scheme. The philosophy
is that, the programmer, when coding, should be aware of resource usage,
and is forced to explicitly express that.