It was the first dialect of Lisp to choose lexical scope and the first to require implementations to perform tail-call optimization, giving stronger support for functional programming and associated techniques such as recursive algorithms.

The current name resulted from the authors' use of the ITS operating system, which limited filenames to two components of at most six characters each.

Syntax-rules has been replaced with a more expressive syntactic abstraction facility (syntax-case) which allows the use of all of Scheme at macro expansion time.

[12][13] In August 2009, the Scheme Steering Committee, which oversees the standardization process, announced its intention to recommend splitting Scheme into two languages: a large modern programming language for programmers; and a small version, a subset of the large version retaining the minimalism praised by educators and casual implementors.

The Scheme Reports Process site has links to the working groups' charters, public discussions and issue tracking system.

[15] A vote ratifying this draft closed on May 20, 2013,[16] and the final report has been available since August 6, 2013, describing "the 'small' language of that effort: therefore it cannot be considered in isolation as the successor to R6RS".

Scheme inherits a rich set of list-processing primitives such as cons, car and cdr from its Lisp progenitors.

"We were actually trying to build something complicated and discovered, serendipitously, that we had accidentally designed something that met all our goals but was much simpler than we had intended....we realized that the lambda calculus—a small, simple formalism—could serve as the core of a powerful and expressive programming language.

He suggested that ALGOL-like lexical scoping mechanisms would help to realize their initial goal of implementing Hewitt's Actor model in Lisp.

[7] The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus",[18] where they adopted the concept of the lexical closure (on page 21), which had been described in an AI Memo in 1970 by Joel Moses, who attributed the idea to Peter J.

The syntax of lambda calculus follows the recursive expressions from x, y, z, ...,parentheses, spaces, the period and the symbol λ.

[20] The function of lambda calculation includes: First, serve as a starting point of powerful mathematical logic.

[21] The introduction of lexical scope resolved the problem by making an equivalence between some forms of lambda notation and their practical expression in a working programming language.

Sussman and Steele showed that the new language could be used to elegantly derive all the imperative and declarative semantics of other programming languages including ALGOL and Fortran, and the dynamic scope of other Lisps, by using lambda expressions not as simple procedure instantiations but as "control structures and environment modifiers".

The use of block structuring to create local bindings alleviates the risk of namespace collision that can otherwise occur.

6.4)[4] First-class continuations enable the programmer to create non-local control constructs such as iterators, coroutines, and backtracking.

The following example, a traditional programmer's puzzle, shows that Scheme can handle continuations as first-class objects, binding them to variables and passing them as arguments to procedures.

These primitives, which produce or handle values known as promises, can be used to implement advanced lazy evaluation constructs such as streams.

For example, this is a definition of the Fibonacci sequence using the functions defined in SRFI 41:[24] Most Lisps specify an order of evaluation for procedure arguments.

The R5RS standard introduced a powerful hygienic macro system that allows the programmer to add new syntactic constructs to the language using a simple pattern matching sublanguage (R5RS sec 4.3).

[25] Implementations of the hygienic macro system, also called syntax-rules, are required to respect the lexical scoping of the rest of the language.

When the compiler encounters an s-expression in the program, it first checks to see if the symbol is defined as a syntactic keyword within the current lexical scope.

Only one of the following predicates can be true of any Scheme object: boolean?, pair?, symbol?, number?, char?, string?, vector?, port?, procedure?.

On a read operation, the result returned is the end-of-file object if the input port has reached the end of the file, and this can be tested using the predicate eof-object?.

At R5RS the language standard formally mandated that programs may change the variable bindings of built-in procedures, effectively redefining them.

SRFIs with fairly wide support in different implementations include:[33] The elegant, minimalist design has made Scheme a popular target for language designers, hobbyists, and educators, and because of its small size, that of a typical interpreter, it is also a popular choice for embedded systems and scripting.

[38] Likewise, the introductory class at UC Berkeley, CS 61A, was until 2011 taught entirely in Scheme, save minor diversions into Logo to demonstrate dynamic scope.

[39] The textbook How to Design Programs by Matthias Felleisen, currently at Northeastern University, is used by some institutes of higher education for their introductory computer science courses.

Both Northeastern University and Worcester Polytechnic Institute use Scheme exclusively for their introductory courses Fundamentals of Computer Science (CS2500) and Introduction to Program Design (CS1101), respectively.

[45] Programming Design Paradigms,[46] a mandatory course for the Computer science Graduate Students at Northeastern University, also extensively uses Scheme.