(Note that we're skipping the 8.x version numbers because long ago
there was an 8.x series that we never released.)

In the past my (CPH) policy for a stable release
was that the documentation had to be updated for the release before it
went out. In practice, this has meant that there have been no stable
releases in recent years. As of this release, we will no longer
consider updated documentation a prerequisite for a stable release.

Major changes

The compiler has been ported to the x86-64 architecture, allowing
Scheme programs to take advantage of very large address spaces and
improved performance (due to additional registers) on that
architecture.

The compiler's C back end has been resurrected, allowing the system to
be run on most computer architectures (under unix-like systems only).

A new virtual machine has been designed and partially implemented.
When finished, it will provide additional system portability.

The system now runs on OS X with native-code
compilation.

The empty list and #f are now distinct objects.

The garbage collector has been completely rewritten. The new design
uses a single heap and a temporary memory region, which doubles the
largest available heap space. The now-unavailable
bchscheme was similar except that its temporary region
was a file.

There's new support for HTTP messages, and a simple HTTP client.
Unfortunately none of this is yet documented.

Incompatibilities with previous releases

Support for SRFI 1 has forced a change in the behavior of
the procedure reduce; code using the old
reduce should adapt to the new behavior, or use
reduce-left which implements the old behavior.

The procedure record-type-default-inits now returns a
list, not a vector.

The load-noisily and load-latest procedures
are now just aliases for load.

System usage changes

The default configuration has been changed to reflect modern usage.
Many command-line options and environment variables have been
eliminated or are ignored. Specifically:

The all.com band is now used by default, meaning that the
compiler and Edwin are both loaded. In order to use the smaller
runtime.com band, it must be explicitly specified with
the --band option. The --compiler and
--edwin options are now accepted but ignored. The env
vars MITSCHEME_COMPILER_BAND,
MITSCHEME_EDWIN_BAND, and MITSCHEME_ALL_BAND
are now ignored.

The default heap size is now set at 4 megawords, much larger than our
previous large size, and adequate for general use.

The --large option is now ignored, and all difference
between large and small memory sizes is eliminated.
The old MITSCHEME_LARGE_foo and
MITSCHEME_SMALL_foo environment variables are
ignored, replaced by two new vars MITSCHEME_HEAP_SIZE and
MITSCHEME_STACK_SIZE. (There's no var for constant size
since it's rarely necessary to specify it.)

The compiler now generates type and range checks by default, in order
to make compiled code more robust. The runtime system is now compiled
this way as well. New declarations (no-type-checks) and
(no-range-checks) allow these defaults to be overridden.
This change will cause some performance degredation; we're interested
in hearing about situations in which this is a significant problem.

The compiler's verbosity has been significantly reduced.

The system will now run on Windows XP SP2 when the no-execute
permissions are enabled.

Platform support for Cygwin has been added. This was a donation and
hasn't been tested by us.

The file specified by environment variable
MITSCHEME_LOAD_OPTIONS is now considered optional rather
than required.

The --eval and --load command-line options
have been changed so that their actions are queued to be evaluated by
the REPL rather than being processed outside of the
REPL context. This fixes various problems with the use of
these options.

Several problems have been fixed in the use of modifier keys under
Windows and X11.

Changes to the runtime

Defaulted optional arguments have a new value that is a
self-evaluating constant. Previously such arguments were filled with
a value that made them "unassigned".

cond-expand now recognizes mit and
mit/gnu as features, to assist porting programs.

The port abstraction has been completely rewritten to support
character coding and a wider variety of line endings.

There's a new operation to unread a character.

Port encapsulation has been eliminated.

discard-char is now an alias for read-char.

open-tcp-stream-socket now takes only two arguments.

Hash tables have been reimplemented for improved speed. In the
process some less useful operations were removed. There are new
procedures make-strong-eq-hash-table and
make-strong-eqv-hash-table.

The new procedure symbol provides an easy way to build
new (interned) symbols.

A new quoting syntax for symbols simplifies writing arbitrary symbols.

The new procedures smallest-fixnum and
largest-fixnum provide the limits on the fixnum
representation.

The new procedure channel-file-truncate can truncate an
open file.

Symbol names are now encoded in UTF-8.
string->symbol accepts an ISO 8859-1 string
and converts it, while symbol->string returns an
ISO 8859-1 string (or signals an error if conversion
impossible). New procedures utf8-string->symbol and
symbol->utf8-string provide support for UTF-8 strings.

string->number now accepts an optional argument; if
given and true, and the input string isn't a number's representation,
an error is signalled.

The read procedure now accepts an optional second
argument, an environment in which to look up control variables such as
*parser-radix*. This allows these variables to be scoped
rather than dynamically bound, which in turn makes them much safer to
use. Numerous callers of read have been changed to pass
an appropriate environment here.

There are new procedures flo:rounding-modes,
flo:rounding-mode, flo:set-rounding-mode!,
and flo:with-rounding-mode that provide control over the
floating-point rounding mode on systems that support it. Currently
this is known to work on recent versions of GNU/Linux and
OS X.

The random-number generator has been changed to provide reasonable
output for large moduli. The previous implementation limited the
amount of randomness in that case.

The procedure random-source-pseudo-randomize! from
SRFI 27 has not been implemented. While I agree that this
could be useful, it effectively mandates a particular
PRNG, and I don't want to be forced to use it.

The procedure hash from SRFI 69 has not been
implemented, as it's a name conflict with a pre-existing procedure.

Changes to IMAIL

As of this release, MIT Scheme is a part of the GNU project and has been renamed MIT/GNU Scheme. The project
is now hosted on Savannah. License text in the source files
has been changed, and a license/warranty statement is now emitted
during boot, to conform to the GNU coding standards.

This is the first testing release of MIT/GNU Scheme.
I had originally planned to do a stable 7.8.0 release, but time
pressures have made it difficult to bring the documentation up to
date, so this release comes with out-of-date documentation.
Additionally, there will be binaries only for GNU/Linux;
users of other systems will have to wait for the stable release.

Incompatibilities with previous releases

In releases 7.7.0 and 7.7.1, variable definitions (i.e. instances
of the define special form) appearing inside let-syntax modified the environment outside of the let-syntax, while syntax definitions (instances of the define-syntax special form) modified the environment corresponding
to the let-syntax form. However, according to R5RS
this is incorrect: all definitions should modify the environment
corresponding to the let-syntax form. The syntax has been
changed to conform to R5RS.

The record abstraction has received a major update. The primary
purpose of this update has been to improve the performance of
constructors, and to implement keyword constructors for records. As a
consequence, the representation of record types has been changed.
Because record types are constructed at load time, this has no effect
on previously-compiled code.

However, the define-structure macro was also changed to
use these new facilities. The interface between
define-structure and the record abstraction was changed
to increase performance, and consequently previously-compiled
instances of define-structure no longer work and must be
recompiled.

A further change to define-structure is that the
initial-value expressions are interpreted in a different way.
Previously, an undocumented feature of these expressions was that they
could refer to other supplied record field names as free variables.
This no longer works; instead these expressions are closed in the
environment in which the define-structure macro appears.

The default type-descriptor name for define-structure has
changed. Previously, for a structure defined as

(define-structure foo bar)

the type descriptor was named foo. Now, the type descriptor
is named rtd:foo. This change is useful primarily because it
is common to name variables that hold objects of this type foo, and when the type descriptor has the same name, it causes
confusion between references to the descriptor and unintended free
references to an object. (After making this change, several such free
references were found in the MIT/GNU Scheme code.)

Finally, define-structure now defines a type descriptor
for every structure definition, including structures without tags.
Previously this was done only for tagged structures.

The representation of character objects has been changed to provide
direct support for Unicode. Previously, the representation
had 16 bits of code and 5 bucky bits. The new representation has 21
bits of code and 4 bucky bits (the "top" bucky bit has been
eliminated). This allows direct representation of the entire Unicode space.

In addition, the syntax of characters has been extended to allow
arbitrary Unicode characters to be represented. The new
syntax is #\U+XXXX, where XXXX is a
sequence of hexadecimal digits specifying a Unicode code
point. This supersedes an undocumented syntax
#\<codeXXXX>.

The runtime library's support for Unicode has been
completely rewritten, and now has support for UTF-8,
UTF-16, and UTF-32 encodings, as well as support
for wide strings. The UTF-8 codec has been fixed
to signal errors for overlong coding sequences.

The special form define-syntax has been changed so that the
right-hand side may be a keyword. This can be used to make aliases
for existing keywords, such as

(define-syntax sequence begin)

In pre-7.7 versions of MIT/GNU Scheme, the right-hand side of
the special form define-syntax was a procedure, such as

(define-syntax foo (lambda ...))

This behavior was preserved in the 7.7 versions by a kludge that made
the above equivalent to

(define-syntax foo
(non-hygienic-macro-transformer
(lambda ...)))

With this release, the old syntax has been eliminated. It is now
necessary to use the non-hygienic-macro-transformer special
form in these cases. (Note, however, that non-hygienic-macro-transformer is also a kludge and is not
guaranteed to produce working macros. You should rewrite your macros
in hygienic form to guarantee proper operation.)

Command-line options now start with -- rather than
-, again for compliance with GNU
coding standards. The older - prefix still works but may
eventually be dropped.

The external representation of symbols has been extended to support
the quoting mechanisms of Common Lisp. This means that there is a
standard external representation for every interned symbol. For
example, the notations |abcDEF|,
foo|BAR|baz, and abc\ def respectively
represent the symbols whose names are "abcDEF",
"fooBARbaz", and "abc def".

This change introduces an incompatibility in the way that symbols are
printed. Previously, (write symbol) was equivalent to
(write-string (symbol->string symbol)). Now,
(write symbol) always writes the symbol out with
appropriate quoting so that it will read back in as the same symbol.

Changes to the runtime system

A new command-line option --batch-mode disables output of
banners, prompts, and values. This is intended for use with shell
scripts, where the Scheme program writes to standard output and the
author doesn't want the output cluttered by the interactivity cues.
Note that the effect of this option applies only to the top-level
REPL; if an error occurs, all the interactivity
cues are re-enabled in the error REPL.

The tcp-server-connection-accept procedure now accepts an
optional argument line-translation, which sets the line
translation to be used for newly-accepted sockets. (Thanks to Arthur
Gleckler)

Output ports now track the current column. This is simple minded but
should work for ASCII, at least.

The URI support procedures, formerly a part of IMAIL, are now in the runtime library.

Changes to Edwin

HTML mode is now used for ".xml" files, and
PHP mode for ".inc" files.

VC mode has a new editor variable vc-cvs-stay-local that
implements a small subset of the corresponding functionality in
GNU Emacs.

The debug-on-*-error editor variables can now be set to
'ask, which causes the user to be prompted for the debugger
when the corresponding error occurs. The default settings of these
variables have been changed to be more appropriate for typical users.

Support for XML namespaces has been implemented. One
consequence of this is that the representation of XML names
has been changed. It is no longer the case that XML names
can be compared with eq?; instead one must use the new xml-name=?. Additionally, xml-intern now takes an optional
second argument, which is the URI of the namespace. XML names that don't have an associated namespace URI are
now ordinary interned symbols, which greatly simplifies reference to
such names.

Comments are preserved by the parser.

The parser now distinguishes between
<foo></foo> and <foo/> in
its output. The former has a contents list of (""),
while the latter has a contents list of ().

Optional indentation is supported for DTD and attributes
during output.

The parser now supports handlers for processing instructions, which
are invoked during parsing. A handler maps the text of a processing
instruction to a list of XML items, which are inserted into the
resulting XML structure in place of the processing instruction.

The following new procedures are available to make XML input
and output more convenient:

This release provides hygienic macro support, as
defined in R4RS and R5RS. This is a complete
rewrite of the syntax engine, so any program that uses macros should
be rewritten to use the new engine. A subset of the old
macro-definition syntax is still supported, but this will eventually
be removed. Note that the new syntax engine has no effect on the
compiled-code format; most binaries compiled by release 7.6.x should
continue to work.

User-visible consequences to this change

The syntactic keyword the-environment has been restricted to
use in top-level environments. It is no longer allowed in the body of
any binding form (e.g. lambda, let).

Syntactic keywords are now stored in environments, rather than in a
separate syntax-table structure. The environment abstraction has been
enhanced to support this, as well as to make it more general. The
changes are documented in the reference manual.

The syntax-table abstraction has been eliminated, and most procedures
and arguments involving syntax tables have been removed. One
exception is the load procedure, which still accepts a
syntax-table argument, but ignores it.

Other notable changes in this release

Although the 7.6.1 release had a workaround for problems with certain
AMD Athlon processors, the workaround was
ineffective on machines running Windows operating systems (and
possibly OS/2 systems as well). This version fixes that problem.

The hash-table abstraction is now always loaded. It's not necessary
to call load-option prior to use of hash tables. For upwards
compatibility, calling (load-option 'hash-table) is still
permitted but does nothing.