The talk details a number of improvements over R5RS and R6RS, and is
divided into two portions. The majority of the talk discuses the
status of the small language, with the last portion giving a quick
update on the future intent of the large language group.

First on the list of major new features is a mandatory library system
designed to be easily implemented atop existing module systems. R6RS's
library system proved to tackle too much at once and be incompatible
with everything already in a use (a persistent concern in the design
of the R7RS-Small language). The R7RS system, on the other hand, is
static, simple, and just powerful enough to promote implementation of
portable libraries.

Exceptions are stripped down from R6RS (which proved too incompatible
with existing implementations for practical use). guard
(similar to try...catch in other languages) andwith-exception-handler are supported: the latter runs the
handler in the context from which the error was triggered (permitting
recovery from the error like invoke-restart)
Unlike r6rs, exceptions lack a strictly defined hierarchy and can be
any object (you could e.g. throw 4 if you really felt
like it).

Dynamically scoped variables, in the form of parameters, are now part
of the standard. Unlike Common Lisp special variables, parameters are
first-class objects bound to expressions rather than symbols that are
declared dynamically scoped. For reasons of simplicity it was decided
to make parameters immutable (i.e. any "mutation" has to be done by
rebinding). This has the (intentional) side-effect of making
parameters play more nicely with threads (when mutation is permitted,
setting a parameter that has not been rebound in the current thread
requires synchronizing all threads and can have unexpected results).

As expected, R7RS includes bytevectors to complement strings. The
small language standard only permits accessing bytevectors as ordered
sets of unsigned 8-bit values (the large language standard will offer
more flexible access). Binary I/O is implemented via a set of parallel
procedures (open-binary-input-file vs.
open-input-file, etc.) in contrast to the incredibly
complicated dual
binary/text ports provided by R6RS. Additionally, string and
bytevector ports similar to SRFI-6 are provided instead of the
incompatible string ports provided by R6RS.

Taylor Campbell
noted that integer division in most languages is insufficiently
expressive, and so R7RS will provide Euclidean division and centered
division in addition to the usual suspects. Mathematicians rejoice!

As with R6RS, Unicode support is mandated. Unlike R6RS, the only
characters that must be supported are those present in ASCII. For
supported characters, Unicode case mapping and normalization are
mandatory. One interesting diversion from Unicode and R6RS is that
string order comparison is implementation-dependent: this gives
implementers latitude with the internal encoding of strings.

Any user of Scheme knows that the language strives for consistent
and obvious names for bindings. R7RS furthers this goal by resolving
the long-standing inconsistency with core data structure creation,
copying, mutation, mapping, etc. Lists, strings, and vectors now have
a consistent set of each: make-TYPE,
TYPE-copy, TYPE-set!, etc. Conversion
procedures between all three types are also provided.

Finally, number of minor improvements were made. Most notable: record
types are compatible with SRFI-6 (widely in use today); case
sensitivity is the default (with optional insensitivity via
include-ci); s-expression and nested block comments were
added; IEEE infinities and NaNs have read syntax; strings may contain
C-style escape sequences; Common Lisp circular list notation is
supported; and common extensions to syntax-rules were
standardized.

The final 20 minutes of the talk were about the status of
R7RS-Large.

The R7RS Large language is currently on hold, mostly because all the
small language members are on the large language committee as well, so
there is a lack of time to work on both simultaneously. Work is
planned to resume upon release of the final draft of the small
language. Some work, however, has been
completed.

The main focus of R7RS-Large is providing Scheme "with batteries
included." John Cowan started the process by looking beyond the Lisp
and Scheme communities (Python is mentioned) to figure out which
libraries modern programmers expect their language to include.

This resulted in a list of around 250 packages that was narrowed down
to around 80 packages through an initial voting process. It was
decided then than some desirable packages (e.g. a foreign function
interface) had to be omitted due to complexity. It is expected that
implementers will continue experimenting and gradually come to a
consensus on the larger packages using the existing SRFI process, and
perhaps another revision of the standard down the road.

Most will be optional; packages will only be made mandatory if a
number of the other packages require them. A compliant R7RS-Large
implementation will only have to either provide a package fully or not
at all (half implementations are forbidden).

Interestingly, R7RS large with all packages will be even larger than
Common Lisp.

To avoid getting bogged down in stylistic discussions, a decision was
made to focus on functionality above other concerns. The resulting
packages may not be aesthetically pleasing to everyone, but will
provide useful functionality. Users who disagree with naming, scope of
functionality, argument ordering, etc. will be free to use the library
system to import only the bindings they want, rename functions, wrap
things into the style they want, etc. Basically, a compromise between
the MIT approach and "Worse is
Better" is being sought.

Here a call for volunteers is made: Since the focus will be on
functionality over pure aesthetics, developers outside of the Lisp and
Scheme communities are actively encouraged to participate in the
R7RS-Large language process. No fixed time commitment would be
required; the goal is to get a lot of people involved with a few core
members maintaining momentum and guiding the process. The R7RS-Large
language is most definitely a language designed by and for
developers. So, make your voice heard!

Overall R7RS is shaping up to be the standard R6RS should have been
(which, of course, could not have happened without the lessons of
R6RS). The split between an elegant core language with each design
issue meticulously fretted over and voted upon and a looser library
standard should, hopefully, result in a core language that will stand
the test of time with a standard library that can be used to get
actual work done.

Don't. It's increasingly harder to be a polymath, even if you confine your domain to technology, perhaps even in CS.

You may have inferred that Scheme [wikipedia.org] is related to Lisp [wikipedia.org] ; they call it a "dialect", stretching a bit the analogy with human languages. Common Lisp [wikipedia.org] is another, and I had brief run-ins with both while peeking under the hood of two great projects: Maxima [wikipedia.org] and the gEDA suite [wikipedia.org]. They left me impressed and determined to learn the language, as soon as I had the mood/time to wrap my easily-distracted brain around it.