update NEWS
[bpt/guile.git] / NEWS
diff --git a/NEWS b/NEWS
index 75d1987..ad0910c 100644 (file)
--- a/NEWS
+++ b/NEWS
 Guile NEWS --- history of user-visible changes.
-Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright (C) 1996-2012 Free Software Foundation, Inc.
 See the end for copying conditions.
 
 Please send Guile bug reports to bug-guile@gnu.org.
 
+
+Changes in 2.0.4 (since 2.0.3):
+
+* Notable changes
+
+** Better debuggability for interpreted procedures.
+    
+Guile 2.0 came with a great debugging experience for compiled
+procedures, but the story for interpreted procedures was terrible.  Now,
+at least, interpreted procedures have names, and the `arity' procedure
+property is always correct (or, as correct as it can be, in the presence
+of `case-lambda').
+
+** Support for cross-compilation.
+    
+One can now use a native Guile to cross-compile `.go' files for a
+different architecture.  See the documentation for `--target' in the
+"Compilation" section of the manual, for information on how to use the
+cross-compiler.  See the "Cross building Guile" section of the README,
+for more on how to cross-compile Guile itself.
+
+** The return of `local-eval'.
+
+Back by popular demand, `the-environment' and `local-eval' allow the
+user to capture a lexical environment, and then evaluate arbitrary
+expressions in that context.  There is also a new `local-compile'
+command.  See "Local Evaluation" in the manual, for more.  Special
+thanks to Mark Weaver for an initial implementation of this feature.
+
+** Fluids can now have default values.
+
+Fluids are used for dynamic and thread-local binding.  They have always
+inherited their values from the context or thread that created them.
+However, there was a case in which a new thread would enter Guile, and
+the default values of all the fluids would be `#f' for that thread.
+
+This has now been fixed so that `make-fluid' has an optional default
+value for fluids in unrelated dynamic roots, which defaults to `#f'.
+
+** Garbage collector tuning.
+
+The garbage collector has now been tuned to run more often under some
+circumstances.
+
+*** Unmanaged allocation
+
+The new `scm_gc_register_allocation' function will notify the collector
+of unmanaged allocation.  This will cause the collector to run sooner.
+Guile's `scm_malloc', `scm_calloc', and `scm_realloc' unmanaged
+allocators eventually call this function.  This leads to better
+performance under steady-state unmanaged allocation.
+
+*** Transient allocation
+    
+When the collector runs, it will try to record the total memory
+footprint of a process, if the platform supports this information.  If
+the memory footprint is growing, the collector will run more frequently.
+This reduces the increase of the resident size of a process in response
+to a transient increase in allocation.
+
+*** Management of threads, bignums
+
+Creating a thread will allocate a fair amount of memory.  Guile now does
+some GC work (using `GC_collect_a_little') when allocating a thread.
+This leads to a better memory footprint when creating many short-lived
+threads.
+    
+Similarly, bignums can occupy a lot of memory.  Guile now offers hooks
+to enable custom GMP allocators that end up calling
+`scm_gc_register_allocation'.  These allocators are enabled by default
+when running Guile from the command-line.  To enable them in libraries,
+set the `scm_install_gmp_memory_functions' variable to a nonzero value
+before loading Guile.
+
+** SRFI-39 parameters are available by default.
+    
+Guile now includes support for parameters, as defined by SRFI-39, in the
+default environment.  See "Parameters" in the manual, for more
+information.  `current-input-port', `current-output-port', and
+`current-error-port' are now parameters.
+    
+** Add `current-warning-port'.
+    
+Guile now outputs warnings on a separate port, `current-warning-port',
+initialized to the value that `current-error-port' has on startup.
+
+** Syntax parameters.
+
+Following Racket's lead, Guile now supports syntax parameters.  See
+"Syntax parameters" in the manual, for more.
+
+Also see Barzilay, Culpepper, and Flatt's 2011 SFP workshop paper,
+"Keeping it Clean with syntax-parameterize".
+    
+** Parse command-line arguments from the locale encoding.
+    
+Guile now attempts to parse command-line arguments using the user's
+locale.  However for backwards compatibility with other 2.0.x releases,
+it does so without actually calling `setlocale'.  Please report any bugs
+in this facility to bug-guile@gnu.org.
+
+** One-armed conditionals: `when' and `unless'
+
+Guile finally has `when' and `unless' in the default environment.  Use
+them whenever you would use an `if' with only one branch.  See
+"Conditionals" in the manual, for more.
+
+** `current-filename', `add-to-load-path'
+
+There is a new form, `(current-filename)', which expands out to the
+source file in which it occurs.  Combined with the new
+`add-to-load-path', this allows simple scripts to easily add nearby
+directories to the load path.  See "Load Paths" in the manual, for more.
+
+** `random-state-from-platform'
+
+This procedure initializes a random seed using good random sources
+available on your platform, such as /dev/urandom.  See "Random Number
+Generation" in the manual, for more.
+
+* New interfaces
+
+** (ice-9 session): `apropos-hook'
+** New print option: `escape-newlines', defaults to #t.
+** (ice-9 ftw): `file-system-fold', `file-system-tree', `scandir'
+** `scm_c_value_ref': access to multiple returned values from C
+** Some new syntax helpers in (system syntax)
+
+Search the manual for these identifiers and modules, for more.
+
+* Build fixes
+
+** FreeBSD build fixes.
+** OpenBSD compilation fixes.
+** Solaris 2.10 test suite fixes.
+** IA64 compilation fix.
+** MinGW build fixes.
+** Work around instruction reordering on SPARC and HPPA in the VM.
+** Gnulib updates: added `dirfd', `setenv' modules.
+
+* Bug fixes
+
+** Add a deprecated alias for $expt.
+** Add an exception printer for `getaddrinfo-error'.
+** Add deprecated shim for `scm_display_error' with stack as first argument.
+** Add warnings for unsupported `simple-format' options.
+** Allow overlapping regions to be passed to `bytevector-copy!'.
+** Avoid calling `u32_conv_from_encoding' on the null string.
+** Better function prologue disassembly
+** Compiler: fix miscompilation of (values foo ...) in some contexts.
+** Compiler: fix serialization of #nil-terminated lists.
+** Compiler: allow values bound in non-tail let expressions to be collected.
+** Deprecate SCM_ASRTGO.
+** Document invalidity of (begin) as expression; add back-compat shim.
+** Don't leak file descriptors when mmaping objcode.
+** Empty substrings no longer reference the original stringbuf.
+** FFI: Fix `set-pointer-finalizer!' to leave the type cell unchanged.
+** FFI: Fix signed/unsigned pointer mismatches in implementation.
+** FFI: Hold a weak reference to the CIF made by `procedure->pointer'.
+** FFI: Hold a weak reference to the procedure passed to `procedure->pointer'.
+** FFI: Properly unpack small integer return values in closure call.
+** Fix R6RS `fold-left' so the accumulator is the first argument.
+** Fix `validate-target' in (system base target).
+** Fix bit-set*! bug from 2005.
+** Fix bug in `make-repl' when `lang' is actually a <language>.
+** Fix bugs related to mutation, the null string, and shared substrings.
+** Fix <dynwind> serialization.
+** Fix erroneous check in `set-procedure-properties!'.
+** Fix generalized-vector-{ref,set!} for slices.
+** HTTP: Extend handling of "Cache-Control" header.
+** HTTP: Fix qstring writing of cache-extension values
+** HTTP: Fix validators for various list-style headers.
+** HTTP: Permit non-date values for Expires header.
+** HTTP: `write-request-line' writes absolute paths, not absolute URIs.
+** Hack the port-column of current-output-port after printing a prompt.
+** Have `cpu-word-size' error out on unknown CPUs; add support for MIPSEL.
+** Make sure `regexp-quote' tests use Unicode-capable string ports.
+** Peval: Fix bugs in the new optimizer.
+** Peval: fold (values FOO) to FOO in more cases
+** Statistically unique marks and labels, for robust hygiene across sessions.
+** Web: Allow URIs with empty authorities, like "file:///etc/hosts".
+** `,language' at REPL sets the current-language fluid.
+** `primitive-load' returns the value(s) of the last expression.
+** `scm_from_stringn' always returns unique strings.
+** `scm_i_substring_copy' tries to narrow the substring.
+** guile-readline: Clean `.go' files.
+** i18n: Fix gc_malloc/free mismatch on non-GNU systems.
+
+Changes in 2.0.3 (since 2.0.2):
+
+* Speed improvements
+
+** Guile has a new optimizer, `peval'.
+
+`Peval' is a partial evaluator that performs constant folding, dead code
+elimination, copy propagation, and inlining.  By default it runs on
+every piece of code that Guile compiles, to fold computations that can
+happen at compile-time, so they don't have to happen at runtime.
+
+If we did our job right, the only impact you would see would be your
+programs getting faster.  But if you notice slowdowns or bloated code,
+please send a mail to bug-guile@gnu.org with details.
+
+Thanks to William R. Cook, Oscar Waddell, and Kent Dybvig for inspiring
+peval and its implementation.
+
+You can see what peval does on a given piece of code by running the new
+`,optimize' REPL meta-command, and comparing it to the output of
+`,expand'.  See "Compile Commands" in the manual, for more.
+
+** Fewer calls to `stat'.
+
+Guile now stats only the .go file and the .scm file when loading a fresh
+compiled file.
+
+* Notable changes
+
+** New module: `(web client)', a simple synchronous web client.
+
+See "Web Client" in the manual, for more.
+
+** Users can now install compiled `.go' files.
+
+See "Installing Site Packages" in the manual.
+
+** Remove Front-Cover and Back-Cover text from the manual.
+    
+The manual is still under the GNU Free Documentation License, but no
+longer has any invariant sections.
+
+** More helpful `guild help'.
+    
+`guild' is Guile's multi-tool, for use in shell scripting.  Now it has a
+nicer interface for querying the set of existing commands, and getting
+help on those commands.  Try it out and see!
+
+** New macro: `define-syntax-rule'
+
+`define-syntax-rule' is a shorthand to make a `syntax-rules' macro with
+one clause.  See "Syntax Rules" in the manual, for more.
+
+** The `,time' REPL meta-command now has more precision.
+
+The output of this command now has microsecond precision, instead of
+10-millisecond precision.
+
+** `(ice-9 match)' can now match records.
+    
+See "Pattern Matching" in the manual, for more on matching records.
+
+** New module: `(language tree-il debug)'.
+
+This module provides a tree-il verifier.  This is useful for people that
+generate tree-il, usually as part of a language compiler.
+
+** New functions: `scm_is_exact', `scm_is_inexact'.
+    
+These provide a nice C interface for Scheme's `exact?' and `inexact?',
+respectively.
+
+* Bugs fixed
+
+See the git log (or the ChangeLog) for more details on these bugs.
+
+** Fix order of importing modules and resolving duplicates handlers.
+** Fix a number of bugs involving extended (merged) generics.
+** Fix invocation of merge-generics duplicate handler.
+** Fix write beyond array end in arrays.c.
+** Fix read beyond end of hashtable size array in hashtab.c.
+** (web http): Locale-independent parsing and serialization of dates.
+** Ensure presence of Host header in HTTP/1.1 requests.
+** Fix take-right and drop-right for improper lists.
+** Fix leak in get_current_locale().
+** Fix recursive define-inlinable expansions.
+** Check that srfi-1 procedure arguments are procedures.
+** Fix r6rs `map' for multiple returns.
+** Fix scm_tmpfile leak on POSIX platforms.
+** Fix a couple of leaks (objcode->bytecode, make-boot-program).
+** Fix guile-lib back-compatibility for module-stexi-documentation.
+** Fix --listen option to allow other ports.
+** Fix scm_to_latin1_stringn for substrings.
+** Fix compilation of untyped arrays of rank not 1.
+** Fix unparse-tree-il of <dynset>.
+** Fix reading of #||||#.
+** Fix segfault in GOOPS when class fields are redefined.
+** Prefer poll(2) over select(2) to allow file descriptors above FD_SETSIZE.
+
 \f
-(During the 1.9 series, we will keep an incremental NEWS for the latest
-prerelease, and a full NEWS corresponding to 1.8 -> 2.0.)
+Changes in 2.0.2 (since 2.0.1):
+
+* Notable changes
+
+** `guile-tools' renamed to `guild'
+    
+The new name is shorter.  Its intended future use is for a CPAN-like
+system for Guile wizards and journeyfolk to band together to share code;
+hence the name.  `guile-tools' is provided as a backward-compatible
+symbolic link.  See "Using Guile Tools" in the manual, for more.
+
+** New control operators: `shift' and `reset'
+    
+See "Shift and Reset" in the manual, for more information.
+
+** `while' as an expression
+    
+Previously the return value of `while' was unspecified.  Now its
+values are specified both in the case of normal termination, and via
+termination by invoking `break', possibly with arguments.  See "while
+do" in the manual for more.
+
+** Disallow access to handles of weak hash tables
+    
+`hash-get-handle' and `hash-create-handle!' are no longer permitted to
+be called on weak hash tables, because the fields in a weak handle could
+be nulled out by the garbage collector at any time, but yet they are
+otherwise indistinguishable from pairs.  Use `hash-ref' and `hash-set!'
+instead.
 
-Changes in 1.9.5 (since the 1.9.4 prerelease):
+** More precision for `get-internal-run-time', `get-internal-real-time'
+    
+On 64-bit systems which support POSIX clocks, Guile's internal timing
+procedures offer nanosecond resolution instead of the 10-millisecond
+resolution previously available.  32-bit systems now use 1-millisecond
+timers.
 
-** Compiled procedures may now have more than one arity.
+** Guile now measures time spent in GC
+    
+`gc-stats' now returns a meaningful value for `gc-time-taken'.
 
-This can be the case, for example, in case-lambda procedures. The
-arities of compiled procedures may be accessed via procedures from the
-`(system vm program)' module; see "Compiled Procedures", "Optional
-Arguments", and "Case-lambda" in the manual. 
+** Add `gcprof'
+    
+The statprof profiler now exports a `gcprof' procedure, driven by the
+`after-gc-hook', to see which parts of your program are causing GC.  Let
+us know if you find it useful.
 
-** `case-lambda' is now available in the default environment.
+** `map', `for-each' and some others now implemented in Scheme
 
-The binding in the default environment is equivalent to the one from the
-`(srfi srfi-16)' module. Use the srfi-16 module explicitly if you wish
-to maintain compatibility with Guile 1.8 and earlier.
+We would not mention this in NEWS, as it is not a user-visible change,
+if it were not for one thing: `map' and `for-each' are no longer
+primitive generics.  Instead they are normal bindings, which can be
+wrapped by normal generics.  This fixes some modularity issues between
+core `map', SRFI-1 `map', and GOOPS.
 
-** VM calling convention change: callee-parsed arguments
+Also it's pretty cool that we can do this without a performance impact.
 
-As an internal implementation detail, compiled procedures are now
-responsible for parsing their own arguments, which they receive on the
-stack.
+** Add `scm_peek_byte_or_eof'.
+    
+This helper is like `scm_peek_char_or_eof', but for bytes instead of
+full characters.
 
-** VM support for multiple-arity dispatch
+** Implement #:stop-at-first-non-option option for getopt-long
+    
+See "getopt-long Reference" in the manual, for more information.
 
-Calls to procedures with multiple arities, for example those made be
-`case-lambda', now dispatch via special opcodes, without the need to
-cons a rest list.
+** Improve R6RS conformance for conditions in the I/O libraries
+    
+The `(rnrs io simple)' module now raises the correct R6RS conditions in
+error cases.  `(rnrs io ports)' is also more correct now, though it is
+still a work in progress.
 
-** Intermediate language support for multiple-arity procedures.
+** All deprecated routines emit warnings
+    
+A few deprecated routines were lacking deprecation warnings.  This has
+been fixed now.
 
-In the intermediate language, tree-il, all procedures may have one or
-more arities. This allows all Guile languages to have multiple arities.
-It is, however, an incompatible change, and anyone maintaining a
-compiler out-of-tree would be advised to get it into Guile soon :)
+* Speed improvements
 
-** `lambda*' and `define*' are now available in the default environment
+** Constants in compiled code now share state better
 
-As with `case-lambda', `(ice-9 optargs)' continues to be supported, for
-compatibility purposes. No semantic change has been made (we hope).
-Optional and keyword arguments now dispatch via special VM operations,
-without the need to cons rest arguments, making them very fast.
+Constants with shared state, like `("foo")' and `"foo"', now share state
+as much as possible, in the entire compilation unit.  This cuts compiled
+`.go' file sizes in half, generally, and speeds startup.
 
-** Better support for Lisp `nil'.
+** VLists: optimize `vlist-fold-right', and add `vhash-fold-right'
 
-The bit representation of `nil' has been tweaked so that it is now very
-efficient to check e.g. if a value is equal to Scheme's end-of-list or
-Lisp's nil. Additionally there are a heap of new, specific predicates
-like scm_is_null_or_nil. Probably in the future we will #define
-scm_is_null to scm_is_null_or_nil.
+These procedures are now twice as fast as they were.
 
-** No future.
+** UTF-8 ports to bypass `iconv' entirely
+    
+This reduces memory usage in a very common case.
 
-Actually the future is still in the state that it was, is, and ever
-shall be, Amen, except that `futures.c' and `futures.h' are no longer a
-part of it. These files were experimental, never compiled, and would be
-better implemented in Scheme anyway. In the future, that is.
+** Compiler speedups
 
-** Support for static allocation of strings, symbols, and subrs.
+The compiler is now about 40% faster.  (Note that this is only the case
+once the compiler is itself compiled, so the build still takes as long
+as it did before.)
 
-Calls to snarfing CPP macros like SCM_DEFINE macro will now allocate
-much of their associated data as static variables, reducing Guile's
-memory footprint.
+** VM speed tuning
+    
+Some assertions that were mostly useful for sanity-checks on the
+bytecode compiler are now off for both "regular" and "debug" engines.
+This together with a fix to cache a TLS access and some other tweaks
+improve the VM's performance by about 20%.
 
-** Inline vector allocation
+** SRFI-1 list-set optimizations
 
-Instead of having vectors point out into the heap for their data, their
-data is now allocated inline to the vector object itself. The same is
-true for bytevectors, by default, though there is an indirection
-available which should allow for making a bytevector from an existing
-memory region.
+lset-adjoin and lset-union now have fast paths for eq? sets.
 
-** New syntax: include-from-path.
+** `memq', `memv' optimizations
 
-`include-from-path' is like `include', except it looks for its file in
-the load path. It can be used to compile other files into a file.
+These procedures are now at least twice as fast than in 2.0.1.
 
-** New syntax: quasisyntax.
+* Deprecations
 
-`quasisyntax' is to `syntax' as `quasiquote' is to `quote'. See the R6RS
-documentation for more information. Thanks to Andre van Tonder for the
-implementation.
+** Deprecate scm_whash API
+    
+`scm_whash_get_handle', `SCM_WHASHFOUNDP', `SCM_WHASHREF',
+`SCM_WHASHSET', `scm_whash_create_handle', `scm_whash_lookup', and
+`scm_whash_insert' are now deprecated.  Use the normal hash table API
+instead.
 
-** Cleanups to Guile's primitive object system.
+** Deprecate scm_struct_table
+    
+`SCM_STRUCT_TABLE_NAME', `SCM_SET_STRUCT_TABLE_NAME',
+`SCM_STRUCT_TABLE_CLASS', `SCM_SET_STRUCT_TABLE_CLASS',
+`scm_struct_table', and `scm_struct_create_handle' are now deprecated.
+These routines formed part of the internals of the map between structs
+and classes.
 
-There were a number of pieces in `objects.[ch]' that tried to be a
-minimal object system, but were never documented, and were quickly
-obseleted by GOOPS' merge into Guile proper. So `scm_make_class_object',
-`scm_make_subclass_object', `scm_metaclass_standard', and like symbols
-from objects.h are no more. In the very unlikely case in which these
-were useful to you, we urge you to contact guile-devel.
+** Deprecate scm_internal_dynamic_wind
+    
+The `scm_t_inner' type and `scm_internal_dynamic_wind' are deprecated,
+as the `scm_dynwind' API is better, and this API encourages users to
+stuff SCM values into pointers.
 
-** GOOPS cleanups.
+** Deprecate scm_immutable_cell, scm_immutable_double_cell
+    
+These routines are deprecated, as the GC_STUBBORN API doesn't do
+anything any more.
 
-GOOPS had a number of concepts that were relevant to the days of Tcl,
-but not any more: operators and entities, mainly. These objects were
-never documented, and it is unlikely that they were ever used. Operators
-were a kind of generic specific to the Tcl support. Entities were
-applicable structures, but were unusable; entities will come back in the
-next alpha release, but with a less stupid name.
+* Manual updates
 
-** Faster bit operations.
+Andreas Rottman kindly transcribed the missing parts of the `(rnrs io
+ports)' documentation from the R6RS documentation.  Thanks Andreas!
 
-The bit-twiddling operations `ash', `logand', `logior', and `logxor' now
-have dedicated bytecodes. Guile is not just for symbolic computation,
-it's for number crunching too.
+* Bugs fixed
 
-** `inet-ntop' and `inet-pton' are always available.
+** Fix double-loading of script in -ds case
+** -x error message fix
+** iconveh-related cross-compilation fixes
+** Fix small integer return value packing on big endian machines.
+** Fix hash-set! in weak-value table from non-immediate to immediate
+** Fix call-with-input-file & relatives for multiple values
+** Fix `hash' for inf and nan
+** Fix libguile internal type errors caught by typing-strictness==2
+** Fix compile error in MinGW fstat socket detection
+** Fix generation of auto-compiled file names on MinGW
+** Fix multithreaded access to internal hash tables
+** Emit a 1-based line number in error messages
+** Fix define-module ordering
+** Fix several POSIX functions to use the locale encoding
+** Add type and range checks to the complex generalized vector accessors
+** Fix unaligned accesses for bytevectors of complex numbers
+** Fix '(a #{.} b)
+** Fix erroneous VM stack overflow for canceled threads
+    
+\f
+Changes in 2.0.1 (since 2.0.0):
+
+* Notable changes
+
+** guile.m4 supports linking with rpath
+    
+The GUILE_FLAGS macro now sets GUILE_LIBS and GUILE_LTLIBS, which
+include appropriate directives to the linker to include libguile-2.0.so
+in the runtime library lookup path.
+
+** `begin' expands macros in its body before other expressions
+
+This enables support for programs like the following:
+
+    (begin
+      (define even?
+        (lambda (x)
+          (or (= x 0) (odd? (- x 1)))))
+      (define-syntax odd?
+        (syntax-rules ()
+          ((odd? x) (not (even? x)))))
+      (even? 10))
+
+** REPL reader usability enhancements
+
+The REPL now flushes input after a read error, which should prevent one
+error from causing other errors.  The REPL also now interprets comments
+as whitespace.
+
+** REPL output has configurable width
+
+The REPL now defaults to output with the current terminal's width, in
+columns.  See "Debug Commands" in the manual for more information on
+the ,width command.
 
-Guile now use a portable implementation of `inet_pton'/`inet_ntop', so
-there is no more need to use `inet-aton'/`inet-ntoa'. The latter
-functions are deprecated.
+** Better C access to the module system
 
-** R6RS block comment support
+Guile now has convenient C accessors to look up variables or values in
+modules and their public interfaces.  See `scm_c_public_ref' and friends
+in "Accessing Modules from C" in the manual.
 
-Guile now supports R6RS nested block comments. The start of a comment is
-marked with `#|', and the end with `|#'.
+** Added `scm_call_5', `scm_call_6'
+    
+See "Fly Evaluation" in the manual.
 
-** `guile-2' cond-expand feature
+** Added `scm_from_latin1_keyword', `scm_from_utf8_keyword'
+    
+See "Keyword Procedures" in the manual, for more.  Note that
+`scm_from_locale_keyword' should not be used when the name is a C string
+constant.
 
-To test if your code is running under Guile 2.0 (or its alpha releases),
-test for the `guile-2' cond-expand feature. Like this:
+** R6RS unicode and string I/O work
 
-     (cond-expand (guile-2 (eval-when (compile)
-                             ;; This must be evaluated at compile time.
-                             (fluid-set! current-reader my-reader)))
-                  (guile
-                           ;; Earlier versions of Guile do not have a
-                           ;; separate compilation phase.
-                           (fluid-set! current-reader my-reader)))
+Added efficient implementations of `get-string-n' and `get-string-n!'
+for binary ports.  Exported `current-input-port', `current-output-port'
+and `current-error-port' from `(rnrs io ports)', and enhanced support
+for transcoders.
 
-** ABI harmonization
+** Added `pointer->scm', `scm->pointer' to `(system foreign)'
+    
+These procedure are useful if one needs to pass and receive SCM values
+to and from foreign functions.  See "Foreign Variables" in the manual,
+for more.
+    
+** Added `heap-allocated-since-gc' to `(gc-stats)'
 
-`scm_search_path' now has the signature it did in 1.8, reverting an
-incompatible change made in 1.9.0.
+Also fixed the long-standing bug in the REPL `,stat' command.
+    
+** Add `on-error' REPL option
+    
+This option controls what happens when an error occurs at the REPL, and
+defaults to `debug', indicating that Guile should enter the debugger.
+Other values include `report', which will simply print a backtrace
+without entering the debugger.  See "System Commands" in the manual.
 
-** Compile-time warnings: -Warity-mismatch
+** Enforce immutability of string literals
 
-Guile can warn when you pass the wrong number of arguments to a
-procedure. Pass the -Warity-mismatch on the `guile-tools compile'
-command line, or add `#:warnings '(arity-mismatch)' to your `compile'
-or `compile-file' invocation.
+Attempting to mutate a string literal now causes a runtime error.
+    
+** Fix pthread redirection
 
-** And of course, the usual collection of bugfixes
-Interested users should see the ChangeLog for more information.
+Guile 2.0.0 shipped with headers that, if configured with pthread
+support, would re-define `pthread_create', `pthread_join', and other API
+to redirect to the BDW-GC wrappers, `GC_pthread_create', etc.  This was
+unintended, and not necessary: because threads must enter Guile with
+`scm_with_guile', Guile can handle thread registration itself, without
+needing to make the GC aware of all threads.  This oversight has been
+fixed.
+
+** `with-continuation-barrier' now unwinds on `quit'
+
+A throw to `quit' in a continuation barrier will cause Guile to exit.
+Before, it would do so before unwinding to the barrier, which would
+prevent cleanup handlers from running.  This has been fixed so that it
+exits only after unwinding.
+    
+** `string->pointer' and `pointer->string' have optional encoding arg
+    
+This allows users of the FFI to more easily deal in strings with
+particular (non-locale) encodings, like "utf-8".  See "Void Pointers and
+Byte Access" in the manual, for more.
+
+** R6RS fixnum arithmetic optimizations
+    
+R6RS fixnum operations are are still slower than generic arithmetic,
+however.
+
+** New procedure: `define-inlinable'
+    
+See "Inlinable Procedures" in the manual, for more.
+
+** New procedure: `exact-integer-sqrt'
+
+See "Integer Operations" in the manual, for more.
+    
+** "Extended read syntax" for symbols parses better
+
+In #{foo}# symbols, backslashes are now treated as escapes, as the
+symbol-printing code intended.  Additionally, "\x" within #{foo}# is now
+interpreted as starting an R6RS hex escape.  This is backward compatible
+because the symbol printer would never produce a "\x" before.  The
+printer also works better too.
+
+** Added `--fresh-auto-compile' option
+
+This allows a user to invalidate the auto-compilation cache.  It's
+usually not needed.  See "Compilation" in the manual, for a discussion.
+
+* Manual updates
+
+** GOOPS documentation updates
+
+** New man page
+
+Thanks to Mark Harig for improvements to guile.1.
+
+** SRFI-23 documented
+
+The humble `error' SRFI now has an entry in the manual.
+
+* New modules
+
+** `(ice-9 binary-ports)': "R6RS I/O Ports", in the manual
+** `(ice-9 eval-string)': "Fly Evaluation", in the manual
+** `(ice-9 command-line)', not documented yet
+    
+* Bugs fixed
+
+** Fixed `iconv_t' memory leak on close-port
+** Fixed some leaks with weak hash tables
+** Export `vhash-delq' and `vhash-delv' from `(ice-9 vlist)'
+** `after-gc-hook' works again
+** `define-record-type' now allowed in nested contexts
+** `exact-integer-sqrt' now handles large integers correctly
+** Fixed C extension examples in manual
+** `vhash-delete' honors HASH argument
+** Make `locale-digit-grouping' more robust
+** Default exception printer robustness fixes
+** Fix presence of non-I CPPFLAGS in `guile-2.0.pc'
+** `read' updates line/column numbers when reading SCSH block comments
+** Fix imports of multiple custom interfaces of same module
+** Fix encoding scanning for non-seekable ports
+** Fix `setter' when called with a non-setter generic
+** Fix f32 and f64 bytevectors to not accept rationals
+** Fix description of the R6RS `finite?' in manual
+** Quotient, remainder and modulo accept inexact integers again
+** Fix `continue' within `while' to take zero arguments
+** Fix alignment for structures in FFI
+** Fix port-filename of stdin, stdout, stderr to match the docs
+** Fix weak hash table-related bug in `define-wrapped-pointer-type'
+** Fix partial continuation application with pending procedure calls
+** scm_{to,from}_locale_string use current locale, not current ports
+** Fix thread cleanup, by using a pthread_key destructor
+** Fix `quit' at the REPL
+** Fix a failure to sync regs in vm bytevector ops
+** Fix (texinfo reflection) to handle nested structures like syntax patterns
+** Fix stexi->html double translation
+** Fix tree-il->scheme fix for <prompt>
+** Fix compilation of <prompt> in <fix> in single-value context
+** Fix race condition in ensure-writable-dir
+** Fix error message on ,disassemble "non-procedure"
+** Fix prompt and abort with the boot evaluator
+** Fix `procedure->pointer' for functions returning `void'
+** Fix error reporting in dynamic-pointer
+** Fix problems detecting coding: in block comments
+** Fix duplicate load-path and load-compiled-path in compilation environment
+** Add fallback read(2) suppport for .go files if mmap(2) unavailable
+** Fix c32vector-set!, c64vector-set!
+** Fix mistakenly deprecated read syntax for uniform complex vectors
+** Fix parsing of exact numbers with negative exponents
+** Ignore SIGPIPE in (system repl server)
+** Fix optional second arg to R6RS log function
+** Fix R6RS `assert' to return true value.
+** Fix fencepost error when seeking in bytevector input ports
+** Gracefully handle `setlocale' errors when starting the REPL
+** Improve support of the `--disable-posix' configure option
+** Make sure R6RS binary ports pass `binary-port?' regardless of the locale
+** Gracefully handle unterminated UTF-8 sequences instead of hitting an `assert'
 
 
 \f
-Changes in 1.9.x (since the 1.8.x series):
+Changes in 2.0.0 (changes since the 1.8.x series):
 
 * New modules (see the manual for details)
 
 ** `(srfi srfi-18)', more sophisticated multithreading support
+** `(srfi srfi-27)', sources of random bits
+** `(srfi srfi-38)', External Representation for Data With Shared Structure
+** `(srfi srfi-42)', eager comprehensions
+** `(srfi srfi-45)', primitives for expressing iterative lazy algorithms
+** `(srfi srfi-67)', compare procedures
 ** `(ice-9 i18n)', internationalization support
-** `(rnrs bytevector)', the R6RS bytevector API
+** `(ice-9 futures)', fine-grain parallelism
+** `(rnrs bytevectors)', the R6RS bytevector API
 ** `(rnrs io ports)', a subset of the R6RS I/O port API
 ** `(system xref)', a cross-referencing facility (FIXME undocumented)
+** `(ice-9 vlist)', lists with constant-time random access; hash lists
+** `(system foreign)', foreign function interface
+** `(sxml match)', a pattern matcher for SXML
+** `(srfi srfi-9 gnu)', extensions to the SRFI-9 record library
+** `(system vm coverage)', a line-by-line code coverage library
+** `(web uri)', URI data type, parser, and unparser
+** `(web http)', HTTP header parsers and unparsers
+** `(web request)', HTTP request data type, reader, and writer
+** `(web response)', HTTP response data type, reader, and writer
+** `(web server)', Generic HTTP server
+** `(ice-9 poll)', a poll wrapper
+** `(web server http)', HTTP-over-TCP web server implementation
+
+** Replaced `(ice-9 match)' with Alex Shinn's compatible, hygienic matcher.
+    
+Guile's copy of Andrew K. Wright's `match' library has been replaced by
+a compatible hygienic implementation by Alex Shinn.  It is now
+documented, see "Pattern Matching" in the manual.
+
+Compared to Andrew K. Wright's `match', the new `match' lacks
+`match-define', `match:error-control', `match:set-error-control',
+`match:error', `match:set-error', and all structure-related procedures.
+
+** Imported statprof, SSAX, and texinfo modules from Guile-Lib
+    
+The statprof statistical profiler, the SSAX XML toolkit, and the texinfo
+toolkit from Guile-Lib have been imported into Guile proper. See
+"Standard Library" in the manual for more details.
+
+** Integration of lalr-scm, a parser generator
+
+Guile has included Dominique Boucher's fine `lalr-scm' parser generator
+as `(system base lalr)'. See "LALR(1) Parsing" in the manual, for more
+information.
 
 * Changes to the stand-alone interpreter
 
@@ -172,11 +719,11 @@ Changes in 1.9.x (since the 1.8.x series):
 Compiled code loads much faster than Scheme source code, and runs around
 3 or 4 times as fast, generating much less garbage in the process.
 
-** The stack limit is now initialized from the environment.
+** Evaluating Scheme code does not use the C stack.
 
-If getrlimit(2) is available and a stack limit is set, Guile will set
-its stack limit to 80% of the rlimit. Otherwise the limit is 160000
-words, a four-fold increase from the earlier default limit.
+Besides when compiling Guile itself, Guile no longer uses a recursive C
+function as an evaluator. This obviates the need to check the C stack
+pointer for overflow. Continuations still capture the C stack, however.
 
 ** New environment variables: GUILE_LOAD_COMPILED_PATH,
    GUILE_SYSTEM_LOAD_COMPILED_PATH
@@ -188,9 +735,71 @@ GUILE_SYSTEM_PATH.
 
 ** New read-eval-print loop (REPL) implementation
 
-Running Guile with no arguments drops the user into the new REPL. While
-it is self-documenting to an extent, the new REPL has not yet been
-documented in the manual. This will be fixed before 2.0.
+Running Guile with no arguments drops the user into the new REPL.  See
+"Using Guile Interactively" in the manual, for more information.
+
+** Remove old Emacs interface
+
+Guile had an unused `--emacs' command line argument that was supposed to
+help when running Guile inside Emacs. This option has been removed, and
+the helper functions `named-module-use!' and `load-emacs-interface' have
+been deprecated.
+    
+** Add `(system repl server)' module and `--listen' command-line argument
+    
+The `(system repl server)' module exposes procedures to listen on
+sockets for connections, and serve REPLs to those clients.  The --listen
+command-line argument allows any Guile program to thus be remotely
+debuggable.
+
+See "Invoking Guile" for more information on `--listen'.
+
+** Command line additions
+
+The guile binary now supports a new switch "-x", which can be used to
+extend the list of filename extensions tried when loading files
+(%load-extensions).
+
+** New reader options: `square-brackets', `r6rs-hex-escapes',
+   `hungry-eol-escapes'
+
+The reader supports a new option (changeable via `read-options'),
+`square-brackets', which instructs it to interpret square brackets as
+parentheses.  This option is on by default.
+
+When the new `r6rs-hex-escapes' reader option is enabled, the reader
+will recognize string escape sequences as defined in R6RS.  R6RS string
+escape sequences are incompatible with Guile's existing escapes, though,
+so this option is off by default.
+
+Additionally, Guile follows the R6RS newline escaping rules when the
+`hungry-eol-escapes' option is enabled.
+
+See "String Syntax" in the manual, for more information.
+
+** Function profiling and tracing at the REPL
+    
+The `,profile FORM' REPL meta-command can now be used to statistically
+profile execution of a form, to see which functions are taking the most
+time. See `,help profile' for more information.
+
+Similarly, `,trace FORM' traces all function applications that occur
+during the execution of `FORM'. See `,help trace' for more information.
+
+** Recursive debugging REPL on error
+
+When Guile sees an error at the REPL, instead of saving the stack, Guile
+will directly enter a recursive REPL in the dynamic context of the
+error. See "Error Handling" in the manual, for more information.
+
+A recursive REPL is the same as any other REPL, except that it
+has been augmented with debugging information, so that one can inspect
+the context of the error. The debugger has been integrated with the REPL
+via a set of debugging meta-commands.
+
+For example, one may access a backtrace with `,backtrace' (or
+`,bt'). See "Interactive Debugging" in the manual, for more
+information.
 
 ** New `guile-tools' commands: `compile', `disassemble'
 
@@ -208,68 +817,161 @@ include `/path/to/lib'.
 Backtraces may now be disclosed with the keyboard in addition to the
 mouse.
 
+** Load path change: search in version-specific paths before site paths
+    
+When looking for a module, Guile now searches first in Guile's
+version-specific path (the library path), *then* in the site dir. This
+allows Guile's copy of SSAX to override any Guile-Lib copy the user has
+installed. Also it should cut the number of `stat' system calls by half,
+in the common case.
+
+** Value history in the REPL on by default
+
+By default, the REPL will save computed values in variables like `$1',
+`$2', and the like. There are programmatic and interactive interfaces to
+control this. See "Value History" in the manual, for more information.
+
+** Readline tab completion for arguments
+
+When readline is enabled, tab completion works for arguments too, not
+just for the operator position.
+
+** Expression-oriented readline history
+    
+Guile's readline history now tries to operate on expressions instead of
+input lines.  Let us know what you think!
+
+** Interactive Guile follows GNU conventions
+
+As recommended by the GPL, Guile now shows a brief copyright and
+warranty disclaimer on startup, along with pointers to more information.
+
 * Changes to Scheme functions and syntax
 
+** Support for R6RS libraries
+
+The `library' and `import' forms from the latest Scheme report have been
+added to Guile, in such a way that R6RS libraries share a namespace with
+Guile modules. R6RS modules may import Guile modules, and are available
+for Guile modules to import via use-modules and all the rest. See "R6RS
+Libraries" in the manual for more information.
+
+** Implementations of R6RS libraries
+
+Guile now has implementations for all of the libraries defined in the
+R6RS. Thanks to Julian Graham for this excellent hack. See "R6RS
+Standard Libraries" in the manual for a full list of libraries.
+
+** Partial R6RS compatibility
+
+Guile now has enough support for R6RS to run a reasonably large subset
+of R6RS programs.
+
+Guile is not fully R6RS compatible. Many incompatibilities are simply
+bugs, though some parts of Guile will remain R6RS-incompatible for the
+foreseeable future. See "R6RS Incompatibilities" in the manual, for more
+information.
+
+Please contact bug-guile@gnu.org if you have found an issue not
+mentioned in that compatibility list.
+    
+** New implementation of `primitive-eval'
+
+Guile's `primitive-eval' is now implemented in Scheme. Actually there is
+still a C evaluator, used when building a fresh Guile to interpret the
+compiler, so we can compile eval.scm. Thereafter all calls to
+primitive-eval are implemented by VM-compiled code.
+
+This allows all of Guile's procedures, be they interpreted or compiled,
+to execute on the same stack, unifying multiple-value return semantics,
+providing for proper tail recursion between interpreted and compiled
+code, and simplifying debugging.
+
+As part of this change, the evaluator no longer mutates the internal
+representation of the code being evaluated in a thread-unsafe manner.
+
+There are two negative aspects of this change, however. First, Guile
+takes a lot longer to compile now. Also, there is less debugging
+information available for debugging interpreted code. We hope to improve
+both of these situations.
+
+There are many changes to the internal C evalator interface, but all
+public interfaces should be the same. See the ChangeLog for details. If
+we have inadvertantly changed an interface that you were using, please
+contact bug-guile@gnu.org.
+
 ** Procedure removed: `the-environment'
 
 This procedure was part of the interpreter's execution model, and does
 not apply to the compiler.
 
-** Files loaded with `primitive-load-path' will now be compiled
-   automatically.
+** No more `local-eval'
+
+`local-eval' used to exist so that one could evaluate code in the
+lexical context of a function. Since there is no way to get the lexical
+environment any more, as that concept has no meaning for the compiler,
+and a different meaning for the interpreter, we have removed the
+function.
+
+If you think you need `local-eval', you should probably implement your
+own metacircular evaluator. It will probably be as fast as Guile's
+anyway.
+
+** Scheme source files will now be compiled automatically.
 
 If a compiled .go file corresponding to a .scm file is not found or is
 not fresh, the .scm file will be compiled on the fly, and the resulting
 .go file stored away. An advisory note will be printed on the console.
 
-Note that this mechanism depends on preservation of the .scm and .go
-modification times; if the .scm or .go files are moved after
-installation, care should be taken to preserve their original
+Note that this mechanism depends on the timestamp of the .go file being
+newer than that of the .scm file; if the .scm or .go files are moved
+after installation, care should be taken to preserve their original
 timestamps.
 
-Autocompiled files will be stored in the $XDG_CACHE_HOME/guile/ccache
+Auto-compiled files will be stored in the $XDG_CACHE_HOME/guile/ccache
 directory, where $XDG_CACHE_HOME defaults to ~/.cache. This directory
 will be created if needed.
 
-To inhibit autocompilation, set the GUILE_AUTO_COMPILE environment
-variable to 0, or pass --no-autocompile on the Guile command line.
+To inhibit automatic compilation, set the GUILE_AUTO_COMPILE environment
+variable to 0, or pass --no-auto-compile on the Guile command line.
 
-Note that there is currently a bug here: automatic compilation will
-sometimes be attempted when it shouldn't.
+** New POSIX procedures: `getrlimit' and `setrlimit'
 
-For example, the old (lang elisp) modules are meant to be interpreted,
-not compiled. This bug will be fixed before 2.0. FIXME 2.0: Should say
-something here about module-transformer called for compile.
+Note however that the interface of these functions is likely to change
+in the next prerelease.
 
-** Files loaded with `load' will now be compiled automatically.
+** New POSIX procedure: `getsid'
 
-As with files loaded via `primitive-load-path', `load' will also compile
-its target if autocompilation is enabled, and a fresh compiled file is
-not found.
+Scheme binding for the `getsid' C library call.
 
-There are two points of difference to note, however. First, `load' does
-not search `GUILE_LOAD_COMPILED_PATH' for the file; it only looks in the
-autocompilation directory, normally a subdirectory of ~/.cache/guile.
+** New POSIX procedure: `getaddrinfo'
 
-Secondly, autocompilation also applies to files loaded via the -l
-command-line argument -- so the user may experience a slight slowdown
-the first time they run a Guile script, as the script is autocompiled.
+Scheme binding for the `getaddrinfo' C library function.
 
-** New POSIX procedures: `getrlimit' and `setrlimit'
+** Multicast socket options
 
-Note however that the interface of these functions is likely to change
-in the next prerelease.
+Support was added for the IP_MULTICAST_TTL and IP_MULTICAST_IF socket
+options.  See "Network Sockets and Communication" in the manual, for
+more information.
 
-** New procedure in `(oops goops)': `method-formals'
+** `recv!', `recvfrom!', `send', `sendto' now deal in bytevectors
+
+These socket procedures now take bytevectors as arguments, instead of
+strings.  There is some deprecated string support, however.
+
+** New GNU procedures: `setaffinity' and `getaffinity'.
+    
+See "Processes" in the manual, for more information.
+
+** New procedures: `compose', `negate', and `const'
 
-** BUG: (procedure-property func 'arity) does not work on compiled
-   procedures
+See "Higher-Order Functions" in the manual, for more information.
 
-This will be fixed one way or another before 2.0.
+** New procedure in `(oops goops)': `method-formals'
 
 ** New procedures in (ice-9 session): `add-value-help-handler!',
    `remove-value-help-handler!', `add-name-help-handler!'
-   `remove-name-help-handler!', `procedure-arguments',
+   `remove-name-help-handler!', `procedure-arguments'
 
 The value and name help handlers provide some minimal extensibility to
 the help interface. Guile-lib's `(texinfo reflection)' uses them, for
@@ -285,11 +987,12 @@ combining arity and formals. For example:
 Additionally, `module-commentary' is now publically exported from
 `(ice-9 session).
 
-** Deprecated: `procedure->memoizing-macro', `procedure->syntax'
+** Removed: `procedure->memoizing-macro', `procedure->syntax'
 
-These procedures will not work with syncase expansion, and indeed are
-not used in the normal course of Guile. They are still used by the old
-Emacs Lisp support, however.
+These procedures created primitive fexprs for the old evaluator, and are
+no longer supported. If you feel that you need these functions, you
+probably need to write your own metacircular evaluator (which will
+probably be as fast as Guile's, anyway).
 
 ** New language: ECMAScript
 
@@ -306,12 +1009,43 @@ languages. See the manual for details, or
 http://en.wikipedia.org/wiki/Brainfuck for more information about the
 Brainfuck language itself.
 
-** Defmacros may now have docstrings.
+** New language: Elisp
+
+Guile now has an experimental Emacs Lisp compiler and runtime. You can
+now switch to Elisp at the repl: `,language elisp'. All kudos to Daniel
+Kraft and Brian Templeton, and all bugs to bug-guile@gnu.org.
+
+** Better documentation infrastructure for macros
+
+It is now possible to introspect on the type of a macro, e.g.
+syntax-rules, identifier-syntax, etc, and extract information about that
+macro, such as the syntax-rules patterns or the defmacro arguments.
+`(texinfo reflection)' takes advantage of this to give better macro
+documentation.
+
+** Support for arbitrary procedure metadata
+
+Building on its support for docstrings, Guile now supports multiple
+docstrings, adding them to the tail of a compiled procedure's
+properties. For example:
+
+  (define (foo)
+    "one"
+    "two"
+    3)
+  (procedure-properties foo)
+  => ((name . foo) (documentation . "one") (documentation . "two"))
 
-Indeed, any macro may have a docstring. `object-documentation' from
-`(ice-9 documentation)' may be used to retrieve the docstring, once you
-have a macro value -- but see the above note about first-class macros.
-Docstrings are associated with the syntax transformer procedures.
+Also, vectors of pairs are now treated as additional metadata entries:
+
+  (define (bar)
+    #((quz . #f) (docstring . "xyzzy"))
+    3)
+  (procedure-properties bar)
+  => ((name . bar) (quz . #f) (docstring . "xyzzy"))
+
+This allows arbitrary literals to be embedded as metadata in a compiled
+procedure.
 
 ** The psyntax expander now knows how to interpret the @ and @@ special
    forms.
@@ -333,16 +1067,33 @@ like this works now:
 It used to be you had to export `helper' from `(foo)' as well.
 Thankfully, this has been fixed.
 
-** New function, `procedure-module'
-
-While useful on its own, `procedure-module' is used by psyntax on syntax
-transformers to determine the module in which to scope introduced
-identifiers.
+** Support for version information in Guile's `module' form
+    
+Guile modules now have a `#:version' field.  See "R6RS Version
+References", "General Information about Modules", "Using Guile Modules",
+and "Creating Guile Modules" in the manual for more information.
+
+** Support for renaming bindings on module export
+    
+Wherever Guile accepts a symbol as an argument to specify a binding to
+export, it now also accepts a pair of symbols, indicating that a binding
+should be renamed on export. See "Creating Guile Modules" in the manual
+for more information.
+
+** New procedure: `module-export-all!'
+
+This procedure exports all current and future bindings from a module.
+Use as `(module-export-all! (current-module))'.
+    
+** New procedure `reload-module', and `,reload' REPL command
+    
+See "Module System Reflection" and "Module Commands" in the manual, for
+more information.
 
 ** `eval-case' has been deprecated, and replaced by `eval-when'.
 
-The semantics of `eval-when' are easier to understand. It is still
-missing documentation, however.
+The semantics of `eval-when' are easier to understand. See "Eval When"
+in the manual, for more information.
 
 ** Guile is now more strict about prohibiting definitions in expression
    contexts.
@@ -356,11 +1107,47 @@ In this specific case, it would be better to do:
 
   (define foo (if test 'bar 'baz))
 
-It is certainly possible to circumvent this resriction with e.g.
-`(module-define! (current-module) 'foo 'baz)'. We would appreciate
-feedback about this change (a consequence of using psyntax as the
-default expander), and may choose to revisit this situation before 2.0
-in response to user feedback.
+It is possible to circumvent this restriction with e.g.
+`(module-define! (current-module) 'foo 'baz)'.  Contact the list if you
+have any questions.
+
+** Support for `letrec*'
+
+Guile now supports `letrec*', a recursive lexical binding operator in
+which the identifiers are bound in order. See "Local Bindings" in the
+manual, for more details.
+
+** Internal definitions now expand to `letrec*'
+
+Following the R6RS, internal definitions now expand to letrec* instead
+of letrec. The following program is invalid for R5RS, but valid for
+R6RS:
+
+    (define (foo)
+      (define bar 10)
+      (define baz (+ bar 20))
+      baz)
+
+    ;; R5RS and Guile <= 1.8:
+    (foo) => Unbound variable: bar
+    ;; R6RS and Guile >= 2.0:
+    (foo) => 30
+
+This change should not affect correct R5RS programs, or programs written
+in earlier Guile dialects.
+
+** Macro expansion produces structures instead of s-expressions
+
+In the olden days, macroexpanding an s-expression would yield another
+s-expression. Though the lexical variables were renamed, expansions of
+core forms like `if' and `begin' were still non-hygienic, as they relied
+on the toplevel definitions of `if' et al being the conventional ones.
+
+The solution is to expand to structures instead of s-expressions. There
+is an `if' structure, a `begin' structure, a `toplevel-ref' structure,
+etc. The expander already did this for compilation, producing Tree-IL
+directly; it has been changed now to do so when expanding for the
+evaluator as well.
 
 ** Defmacros must now produce valid Scheme expressions.
 
@@ -398,6 +1185,18 @@ However its intent is fairly clear. Guile interprets "bar" to be the
 docstring of `foo', and the definition of `baz' is still in definition
 context.
 
+** Support for settable identifier syntax
+
+Following the R6RS, "variable transformers" are settable
+identifier-syntax. See "Identifier macros" in the manual, for more
+information.
+    
+** syntax-case treats `_' as a placeholder
+    
+Following R6RS, a `_' in a syntax-rules or syntax-case pattern matches
+anything, and binds no pattern variables. Unlike the R6RS, Guile also
+permits `_' to be in the literals list for a pattern.
+
 ** Macros need to be defined before their first use.
 
 It used to be that with lazy memoization, this might work:
@@ -429,18 +1228,20 @@ the definition of `double-helper' in `eval-when':
   (define-macro (double-literal x) (double-helper x))
   (double-literal 2) => 4
 
-See the (currently missing) documentation for eval-when for more
-information.
+See the documentation for eval-when for more information.
 
-** New variable, %pre-modules-transformer
+** `macroexpand' produces structures, not S-expressions.
 
-Need to document this one some more.
+Given the need to maintain referential transparency, both lexically and
+modular, the result of expanding Scheme expressions is no longer itself
+an s-expression. If you want a human-readable approximation of the
+result of `macroexpand', call `tree-il->scheme' from `(language
+tree-il)'.
 
-** Temporarily removed functions: `macroexpand', `macroexpand-1'
+** Removed function: `macroexpand-1'
 
-`macroexpand' will be added back before 2.0. It is unclear how to
-implement `macroexpand-1' with syntax-case, though PLT Scheme does prove
-that it is possible.
+It is unclear how to implement `macroexpand-1' with syntax-case, though
+PLT Scheme does prove that it is possible.
 
 ** New reader macros: #' #` #, #,@
 
@@ -455,11 +1256,24 @@ subsequent datum: #'foo => foo. In the unlikely event that anyone
 actually used this, this behavior may be reinstated via the
 `read-hash-extend' mechanism.
 
+** `unquote' and `unquote-splicing' accept multiple expressions
+    
+As per the R6RS, these syntax operators can now accept any number of
+expressions to unquote.
+
 ** Scheme expresssions may be commented out with #;
 
 #; comments out an entire expression.  See SRFI-62 or the R6RS for more
 information.
 
+** Prompts: Delimited, composable continuations
+
+Guile now has prompts as part of its primitive language. See "Prompts"
+in the manual, for more information.
+
+Expressions entered in at the REPL, or from the command line, are
+surrounded by a prompt with the default prompt tag.
+
 ** `make-stack' with a tail-called procedural narrowing argument no longer
    works (with compiled procedures)
 
@@ -474,7 +1288,7 @@ stack will result in an empty stack. To fix this, narrow to a procedure
 that is active in the current continuation, or narrow to a specific
 number of stack frames.
 
-** backtraces through compiled procedures only show procedures that are
+** Backtraces through compiled procedures only show procedures that are
    active in the current continuation
 
 Similarly to the previous issue, backtraces in compiled code may be
@@ -482,6 +1296,17 @@ different from backtraces in interpreted code. There are no semantic
 differences, however. Please mail bug-guile@gnu.org if you see any
 deficiencies with Guile's backtraces.
 
+** `positions' reader option enabled by default
+    
+This change allows primitive-load without --auto-compile to also
+propagate source information through the expander, for better errors and
+to let macros know their source locations.  The compiler was already
+turning it on anyway.
+
+** New macro: `current-source-location'
+
+The macro returns the current source location (to be documented).
+
 ** syntax-rules and syntax-case macros now propagate source information
    through to the expanded code
 
@@ -494,8 +1319,15 @@ Before, `(define ((f a) b) (* a b))' would translate to
   (define f (lambda (a) (lambda (b) (* a b))))
 
 Now a syntax error is signaled, as this syntax is not supported by
-default. If there is sufficient demand, this syntax can be supported
-again by default.
+default. Use the `(ice-9 curried-definitions)' module to get back the
+old behavior.
+
+** New procedure, `define!'
+
+`define!' is a procedure that takes two arguments, a symbol and a value,
+and binds the value to the symbol in the current module. It's useful to
+programmatically make definitions in the current module, and is slightly
+less verbose than `module-define!'.
 
 ** All modules have names now
 
@@ -504,6 +1336,77 @@ because of hygiene and macros, all modules have names. If a module was
 created without a name, the first time `module-name' is called on it, a
 fresh name will be lazily generated for it.
 
+** The module namespace is now separate from the value namespace
+
+It was a little-known implementation detail of Guile's module system
+that it was built on a single hierarchical namespace of values -- that
+if there was a module named `(foo bar)', then in the module named
+`(foo)' there was a binding from `bar' to the `(foo bar)' module.
+
+This was a neat trick, but presented a number of problems. One problem
+was that the bindings in a module were not apparent from the module
+itself; perhaps the `(foo)' module had a private binding for `bar', and
+then an external contributor defined `(foo bar)'. In the end there can
+be only one binding, so one of the two will see the wrong thing, and
+produce an obtuse error of unclear provenance.
+
+Also, the public interface of a module was also bound in the value
+namespace, as `%module-public-interface'. This was a hack from the early
+days of Guile's modules.
+
+Both of these warts have been fixed by the addition of fields in the
+`module' data type. Access to modules and their interfaces from the
+value namespace has been deprecated, and all accessors use the new
+record accessors appropriately.
+
+When Guile is built with support for deprecated code, as is the default,
+the value namespace is still searched for modules and public interfaces,
+and a deprecation warning is raised as appropriate.
+
+Finally, to support lazy loading of modules as one used to be able to do
+with module binder procedures, Guile now has submodule binders, called
+if a given submodule is not found. See boot-9.scm for more information.
+    
+** New procedures: module-ref-submodule, module-define-submodule,
+   nested-ref-module, nested-define-module!, local-ref-module,
+   local-define-module
+
+These new accessors are like their bare variants, but operate on
+namespaces instead of values.
+
+** The (app modules) module tree is officially deprecated
+
+It used to be that one could access a module named `(foo bar)' via
+`(nested-ref the-root-module '(app modules foo bar))'. The `(app
+modules)' bit was a never-used and never-documented abstraction, and has
+been deprecated. See the following mail for a full discussion:
+
+    http://lists.gnu.org/archive/html/guile-devel/2010-04/msg00168.html
+
+The `%app' binding is also deprecated.
+
+** `module-filename' field and accessor
+
+Modules now record the file in which they are defined. This field may be
+accessed with the new `module-filename' procedure.
+
+** Modules load within a known environment
+
+It takes a few procedure calls to define a module, and those procedure
+calls need to be in scope. Now we ensure that the current module when
+loading a module is one that has the needed bindings, instead of relying
+on chance.
+
+** `load' is a macro (!) that resolves paths relative to source file dir
+    
+The familiar Schem `load' procedure is now a macro that captures the
+name of the source file being expanded, and dispatches to the new
+`load-in-vicinity'.  Referencing `load' by bare name returns a closure
+that embeds the current source file name.
+
+This fix allows `load' of relative paths to be resolved with respect to
+the location of the file that calls `load'.
+
 ** Many syntax errors have different texts now
 
 Syntax errors still throw to the `syntax-error' key, but the arguments
@@ -553,6 +1456,12 @@ been removed, along with `defmacro-transformer', `macro-table',
 any of these procedures provided useful facilities to you, we encourage
 you to contact the Guile developers.
 
+** Hygienic macros documented as the primary syntactic extension mechanism.
+
+The macro documentation was finally fleshed out with some documentation
+on `syntax-rules' and `syntax-case' macros, and other parts of the macro
+expansion process. See "Macros" in the manual, for details.
+
 ** psyntax is now the default expander
 
 Scheme code is now expanded by default by the psyntax hygienic macro
@@ -577,7 +1486,7 @@ in psyntax since then. If you find one, please notify bug-guile@gnu.org.
 
 There is no longer any need to import the `(ice-9 syncase)' module
 (which is now deprecated). The expander may be invoked directly via
-`sc-expand', though it is normally searched for via the current module
+`macroexpand', though it is normally searched for via the current module
 transformer.
 
 Also, the helper routines for syntax-case are available in the default
@@ -585,6 +1494,22 @@ environment as well: `syntax->datum', `datum->syntax',
 `bound-identifier=?', `free-identifier=?', `generate-temporaries',
 `identifier?', and `syntax-violation'. See the R6RS for documentation.
 
+** Tail patterns in syntax-case
+
+Guile has pulled in some more recent changes from the psyntax portable
+syntax expander, to implement support for "tail patterns". Such patterns
+are supported by syntax-rules and syntax-case. This allows a syntax-case
+match clause to have ellipses, then a pattern at the end. For example:
+
+  (define-syntax case
+    (syntax-rules (else)
+      ((_ val match-clause ... (else e e* ...))
+       [...])))
+
+Note how there is MATCH-CLAUSE, which is ellipsized, then there is a
+tail pattern for the else clause. Thanks to Andreas Rottmann for the
+patch, and Kent Dybvig for the code.
+
 ** Lexical bindings introduced by hygienic macros may not be referenced
    by nonhygienic macros.
 
@@ -609,10 +1534,11 @@ But this does not:
     (bind-x 10 (ref x)))
 
 It is not normal to run into this situation with existing code. However,
-as code is ported over from defmacros to syntax-case, it is possible to
-run into situations like this. In the future, Guile will probably port
-its `while' macro to syntax-case, which makes this issue one to know
-about.
+if you have defmacros that expand to hygienic macros, it is possible to
+run into situations like this. For example, if you have a defmacro that
+generates a `while' expression, the `break' bound by the `while' may not
+be visible within other parts of your defmacro. The solution is to port
+from defmacros to syntax-rules or syntax-case.
 
 ** Macros may no longer be referenced as first-class values.
 
@@ -623,9 +1549,314 @@ Macros still /exist/ as first-class values, but they must be
 /referenced/ via the module system, e.g. `(module-ref (current-module)
 'if)'.
 
-This decision may be revisited before the 2.0 release. Feedback welcome
-to guile-devel@gnu.org (subscription required) or bug-guile@gnu.org (no
-subscription required).
+** Macros may now have docstrings.
+
+`object-documentation' from `(ice-9 documentation)' may be used to
+retrieve the docstring, once you have a macro value -- but see the above
+note about first-class macros. Docstrings are associated with the syntax
+transformer procedures.
+
+** `case-lambda' is now available in the default environment.
+
+The binding in the default environment is equivalent to the one from the
+`(srfi srfi-16)' module. Use the srfi-16 module explicitly if you wish
+to maintain compatibility with Guile 1.8 and earlier.
+
+** Procedures may now have more than one arity.
+
+This can be the case, for example, in case-lambda procedures. The
+arities of compiled procedures may be accessed via procedures from the
+`(system vm program)' module; see "Compiled Procedures", "Optional
+Arguments", and "Case-lambda" in the manual. 
+
+** Deprecate arity access via (procedure-properties proc 'arity)
+
+Instead of accessing a procedure's arity as a property, use the new
+`procedure-minimum-arity' function, which gives the most permissive
+arity that the function has, in the same format as the old arity
+accessor.
+
+** `lambda*' and `define*' are now available in the default environment
+
+As with `case-lambda', `(ice-9 optargs)' continues to be supported, for
+compatibility purposes. No semantic change has been made (we hope).
+Optional and keyword arguments now dispatch via special VM operations,
+without the need to cons rest arguments, making them very fast.
+
+** New syntax: define-once
+
+`define-once' is like Lisp's `defvar': it creates a toplevel binding,
+but only if one does not exist already.
+
+** New function, `truncated-print', with `format' support
+
+`(ice-9 pretty-print)' now exports `truncated-print', a printer that
+will ensure that the output stays within a certain width, truncating the
+output in what is hopefully an intelligent manner. See the manual for
+more details.
+
+There is a new `format' specifier, `~@y', for doing a truncated
+print (as opposed to `~y', which does a pretty-print). See the `format'
+documentation for more details.
+
+** Better pretty-printing
+
+Indentation recognizes more special forms, like `syntax-case', and read
+macros like `quote' are printed better.
+
+** Passing a number as the destination of `format' is deprecated
+
+The `format' procedure in `(ice-9 format)' now emits a deprecation
+warning if a number is passed as its first argument.
+
+Also, it used to be that you could omit passing a port to `format', in
+some cases.  This still works, but has been formally deprecated.
+    
+** SRFI-4 vectors reimplemented in terms of R6RS bytevectors
+
+Guile now implements SRFI-4 vectors using bytevectors. Often when you
+have a numeric vector, you end up wanting to write its bytes somewhere,
+or have access to the underlying bytes, or read in bytes from somewhere
+else. Bytevectors are very good at this sort of thing. But the SRFI-4
+APIs are nicer to use when doing number-crunching, because they are
+addressed by element and not by byte.
+
+So as a compromise, Guile allows all bytevector functions to operate on
+numeric vectors. They address the underlying bytes in the native
+endianness, as one would expect.
+
+Following the same reasoning, that it's just bytes underneath, Guile
+also allows uniform vectors of a given type to be accessed as if they
+were of any type. One can fill a u32vector, and access its elements with
+u8vector-ref. One can use f64vector-ref on bytevectors. It's all the
+same to Guile.
+
+In this way, uniform numeric vectors may be written to and read from
+input/output ports using the procedures that operate on bytevectors.
+
+Calls to SRFI-4 accessors (ref and set functions) from Scheme are now
+inlined to the VM instructions for bytevector access.
+
+See "SRFI-4" in the manual, for more information.
+
+** Nonstandard SRFI-4 procedures now available from `(srfi srfi-4 gnu)'
+
+Guile's `(srfi srfi-4)' now only exports those srfi-4 procedures that
+are part of the standard. Complex uniform vectors and the
+`any->FOOvector' family are now available only from `(srfi srfi-4 gnu)'.
+
+Guile's default environment imports `(srfi srfi-4)', and probably should
+import `(srfi srfi-4 gnu)' as well.
+
+See "SRFI-4 Extensions" in the manual, for more information.
+
+** New syntax: include-from-path.
+
+`include-from-path' is like `include', except it looks for its file in
+the load path. It can be used to compile other files into a file.
+
+** New syntax: quasisyntax.
+
+`quasisyntax' is to `syntax' as `quasiquote' is to `quote'. See the R6RS
+documentation for more information. Thanks to Andre van Tonder for the
+implementation.
+
+** `*unspecified*' is identifier syntax
+    
+`*unspecified*' is no longer a variable, so it is optimized properly by
+the compiler, and is not `set!'-able.
+
+** Changes and bugfixes in numerics code
+
+*** Added six new sets of fast quotient and remainder operators
+
+Added six new sets of fast quotient and remainder operator pairs with
+different semantics than the R5RS operators.  They support not only
+integers, but all reals, including exact rationals and inexact
+floating point numbers.
+
+These procedures accept two real numbers N and D, where the divisor D
+must be non-zero.  Each set of operators computes an integer quotient
+Q and a real remainder R such that N = Q*D + R and |R| < |D|.  They
+differ only in how N/D is rounded to produce Q.
+
+`euclidean-quotient' returns the integer Q and `euclidean-remainder'
+returns the real R such that N = Q*D + R and 0 <= R < |D|.  `euclidean/'
+returns both Q and R, and is more efficient than computing each
+separately.  Note that when D > 0, `euclidean-quotient' returns
+floor(N/D), and when D < 0 it returns ceiling(N/D).
+
+`centered-quotient', `centered-remainder', and `centered/' are similar
+except that the range of remainders is -abs(D/2) <= R < abs(D/2), and
+`centered-quotient' rounds N/D to the nearest integer.  Note that these
+operators are equivalent to the R6RS integer division operators `div',
+`mod', `div-and-mod', `div0', `mod0', and `div0-and-mod0'.
+
+`floor-quotient' and `floor-remainder' compute Q and R, respectively,
+where Q has been rounded toward negative infinity.  `floor/' returns
+both Q and R, and is more efficient than computing each separately.
+Note that when applied to integers, `floor-remainder' is equivalent to
+the R5RS integer-only `modulo' operator.  `ceiling-quotient',
+`ceiling-remainder', and `ceiling/' are similar except that Q is
+rounded toward positive infinity.
+
+For `truncate-quotient', `truncate-remainder', and `truncate/', Q is
+rounded toward zero.  Note that when applied to integers,
+`truncate-quotient' and `truncate-remainder' are equivalent to the
+R5RS integer-only operators `quotient' and `remainder'.
+
+For `round-quotient', `round-remainder', and `round/', Q is rounded to
+the nearest integer, with ties going to the nearest even integer.
+
+*** Complex number changes
+
+Guile is now able to represent non-real complex numbers whose
+imaginary part is an _inexact_ zero (0.0 or -0.0), per R6RS.
+Previously, such numbers were immediately changed into inexact reals.
+
+(real? 0.0+0.0i) now returns #f, per R6RS, although (zero? 0.0+0.0i)
+still returns #t, per R6RS.  (= 0 0.0+0.0i) and (= 0.0 0.0+0.0i) are
+#t, but the same comparisons using `eqv?' or `equal?' are #f.
+
+Like other non-real numbers, these complex numbers with inexact zero
+imaginary part will raise exceptions is passed to procedures requiring
+reals, such as `<', `>', `<=', `>=', `min', `max', `positive?',
+`negative?', `inf?', `nan?', `finite?', etc.
+
+**** `make-rectangular' changes
+
+scm_make_rectangular `make-rectangular' now returns a real number only
+if the imaginary part is an _exact_ 0.  Previously, it would return a
+real number if the imaginary part was an inexact zero.
+
+scm_c_make_rectangular now always returns a non-real complex number,
+even if the imaginary part is zero.  Previously, it would return a
+real number if the imaginary part was zero.
+
+**** `make-polar' changes
+
+scm_make_polar `make-polar' now returns a real number only if the
+angle or magnitude is an _exact_ 0.  If the magnitude is an exact 0,
+it now returns an exact 0.  Previously, it would return a real
+number if the imaginary part was an inexact zero.
+
+scm_c_make_polar now always returns a non-real complex number, even if
+the imaginary part is 0.0.  Previously, it would return a real number
+if the imaginary part was 0.0.
+
+**** `imag-part' changes
+
+scm_imag_part `imag-part' now returns an exact 0 if applied to an
+inexact real number.  Previously it returned an inexact zero in this
+case.
+
+*** `eqv?' and `equal?' now compare numbers equivalently
+
+scm_equal_p `equal?' now behaves equivalently to scm_eqv_p `eqv?' for
+numeric values, per R5RS.  Previously, equal? worked differently,
+e.g. `(equal? 0.0 -0.0)' returned #t but `(eqv? 0.0 -0.0)' returned #f,
+and `(equal? +nan.0 +nan.0)' returned #f but `(eqv? +nan.0 +nan.0)'
+returned #t.
+
+*** `(equal? +nan.0 +nan.0)' now returns #t
+
+Previously, `(equal? +nan.0 +nan.0)' returned #f, although
+`(let ((x +nan.0)) (equal? x x))' and `(eqv? +nan.0 +nan.0)'
+both returned #t.  R5RS requires that `equal?' behave like
+`eqv?' when comparing numbers.
+
+*** Change in handling products `*' involving exact 0
+
+scm_product `*' now handles exact 0 differently.  A product containing
+an exact 0 now returns an exact 0 if and only if the other arguments
+are all exact.  An inexact zero is returned if and only if the other
+arguments are all finite but not all exact.  If an infinite or NaN
+value is present, a NaN value is returned.  Previously, any product
+containing an exact 0 yielded an exact 0, regardless of the other
+arguments.
+
+*** `expt' and `integer-expt' changes when the base is 0
+
+While `(expt 0 0)' is still 1, and `(expt 0 N)' for N > 0 is still
+zero, `(expt 0 N)' for N < 0 is now a NaN value, and likewise for
+integer-expt.  This is more correct, and conforming to R6RS, but seems
+to be incompatible with R5RS, which would return 0 for all non-zero
+values of N.
+
+*** `expt' and `integer-expt' are more generic, less strict
+
+When raising to an exact non-negative integer exponent, `expt' and
+`integer-expt' are now able to exponentiate any object that can be
+multiplied using `*'.  They can also raise an object to an exact
+negative integer power if its reciprocal can be taken using `/'.
+In order to allow this, the type of the first argument is no longer
+checked when raising to an exact integer power.  If the exponent is 0
+or 1, the first parameter is not manipulated at all, and need not
+even support multiplication.
+
+*** Infinities are no longer integers, nor rationals
+
+scm_integer_p `integer?' and scm_rational_p `rational?' now return #f
+for infinities, per R6RS.  Previously they returned #t for real
+infinities.  The real infinities and NaNs are still considered real by
+scm_real `real?' however, per R6RS.
+
+*** NaNs are no longer rationals
+
+scm_rational_p `rational?' now returns #f for NaN values, per R6RS.
+Previously it returned #t for real NaN values.  They are still
+considered real by scm_real `real?' however, per R6RS.
+
+*** `inf?' and `nan?' now throw exceptions for non-reals
+
+The domain of `inf?' and `nan?' is the real numbers.  Guile now signals
+an error when a non-real number or non-number is passed to these
+procedures.  (Note that NaNs _are_ considered numbers by scheme, despite
+their name).
+
+*** `rationalize' bugfixes and changes
+
+Fixed bugs in scm_rationalize `rationalize'.  Previously, it returned
+exact integers unmodified, although that was incorrect if the epsilon
+was at least 1 or inexact, e.g. (rationalize 4 1) should return 3 per
+R5RS and R6RS, but previously it returned 4.  It also now handles
+cases involving infinities and NaNs properly, per R6RS.
+
+*** Trigonometric functions now return exact numbers in some cases
+
+scm_sin `sin', scm_cos `cos', scm_tan `tan', scm_asin `asin', scm_acos
+`acos', scm_atan `atan', scm_sinh `sinh', scm_cosh `cosh', scm_tanh
+`tanh', scm_sys_asinh `asinh', scm_sys_acosh `acosh', and
+scm_sys_atanh `atanh' now return exact results in some cases.
+
+*** New procedure: `finite?'
+
+Add scm_finite_p `finite?' from R6RS to guile core, which returns #t
+if and only if its argument is neither infinite nor a NaN.  Note that
+this is not the same as (not (inf? x)) or (not (infinite? x)), since
+NaNs are neither finite nor infinite.
+
+*** Improved exactness handling for complex number parsing
+
+When parsing non-real complex numbers, exactness specifiers are now
+applied to each component, as is done in PLT Scheme.  For complex
+numbers written in rectangular form, exactness specifiers are applied
+to the real and imaginary parts before calling scm_make_rectangular.
+For complex numbers written in polar form, exactness specifiers are
+applied to the magnitude and angle before calling scm_make_polar.
+
+Previously, exactness specifiers were applied to the number as a whole
+_after_ calling scm_make_rectangular or scm_make_polar.
+
+For example, (string->number "#i5.0+0i") now does the equivalent of:
+
+  (make-rectangular (exact->inexact 5.0) (exact->inexact 0))
+
+which yields 5.0+0.0i.  Previously it did the equivalent of:
+
+  (exact->inexact (make-rectangular 5.0 0))
+
+which yielded 5.0.
 
 ** Unicode characters
 
@@ -658,7 +1889,19 @@ declaration. See the section of the manual entitled, "Character Encoding
 of Source Files".
 
 The pre-1.9.3 reader handled 8-bit clean but otherwise unspecified source
-code.  This use is now discouraged.
+code.  This use is now discouraged.  Binary input and output is
+currently supported by opening ports in the ISO-8859-1 locale.
+
+** Source files default to UTF-8.
+
+If source files do not specify their encoding via a `coding:' block,
+the default encoding is UTF-8, instead of being taken from the current
+locale.
+
+** Interactive Guile installs the current locale.
+    
+Instead of leaving the user in the "C" locale, running the Guile REPL
+installs the current locale.  [FIXME xref?]
 
 ** Support for locale transcoding when reading from and writing to ports
 
@@ -699,22 +1942,21 @@ There was an EBCDIC compile flag that altered some of the character
 processing.  It appeared that full EBCDIC support was never completed
 and was unmaintained.
 
-** Compile-time warnings: -Wunbound-variable, -Warity-mismatch. 
+** Compile-time warnings
 
 Guile can warn about potentially unbound free variables. Pass the
 -Wunbound-variable on the `guile-tools compile' command line, or add
 `#:warnings '(unbound-variable)' to your `compile' or `compile-file'
-invocation.
+invocation. Warnings are also enabled by default for expressions entered
+at the REPL.
 
 Guile can also warn when you pass the wrong number of arguments to a
 procedure, with -Warity-mismatch, or `arity-mismatch' in the
 `#:warnings' as above.
 
-** New macro type: syncase-macro
-
-XXX Need to decide whether to document this for 2.0, probably should:
-make-syncase-macro, make-extended-syncase-macro, macro-type,
-syncase-macro-type, syncase-macro-binding
+Other warnings include `-Wunused-variable' and `-Wunused-toplevel', to
+warn about unused local or global (top-level) variables, and `-Wformat',
+to check for various errors related to the `format' procedure.
 
 ** A new `memoize-symbol' evaluator trap has been added.
 
@@ -729,16 +1971,143 @@ This slightly improves program startup times.
 
 See `cancel-thread', `set-thread-cleanup!', and `thread-cleanup'.
 
-** Fix bad interaction between `false-if-exception' and stack-call.
+** New threads are in `(guile-user)' by default, not `(guile)'
+
+It used to be that a new thread entering Guile would do so in the
+`(guile)' module, unless this was the first time Guile was initialized,
+in which case it was `(guile-user)'. This has been fixed to have all
+new threads unknown to Guile default to `(guile-user)'.
+
+** New helpers: `print-exception', `set-exception-printer!'
+
+These functions implement an extensible exception printer.  Guile
+registers printers for all of the exceptions it throws.  Users may add
+their own printers.  There is also `scm_print_exception', for use by C
+programs.  Pleasantly, this allows SRFI-35 and R6RS exceptions to be
+printed appropriately.
+
+** GOOPS dispatch in scheme
+
+As an implementation detail, GOOPS dispatch is no longer implemented by
+special evaluator bytecodes, but rather directly via a Scheme function
+associated with an applicable struct. There is some VM support for the
+underlying primitives, like `class-of'.
+
+This change will in the future allow users to customize generic function
+dispatch without incurring a performance penalty, and allow us to
+implement method combinations.
+
+** Applicable struct support
+
+One may now make structs from Scheme that may be applied as procedures.
+To do so, make a struct whose vtable is `<applicable-struct-vtable>'.
+That struct will be the vtable of your applicable structs; instances of
+that new struct are assumed to have the procedure in their first slot.
+`<applicable-struct-vtable>' is like Common Lisp's
+`funcallable-standard-class'. Likewise there is
+`<applicable-struct-with-setter-vtable>', which looks for the setter in
+the second slot. This needs to be better documented.
+
+** GOOPS cleanups.
+
+GOOPS had a number of concepts that were relevant to the days of Tcl,
+but not any more: operators and entities, mainly. These objects were
+never documented, and it is unlikely that they were ever used. Operators
+were a kind of generic specific to the Tcl support. Entities were
+replaced by applicable structs, mentioned above.
+
+** New struct slot allocation: "hidden"
+
+A hidden slot is readable and writable, but will not be initialized by a
+call to make-struct. For example in your layout you would say "ph"
+instead of "pw". Hidden slots are useful for adding new slots to a
+vtable without breaking existing invocations to make-struct.
 
-Exceptions thrown by `false-if-exception' were erronously causing the
-stack to be saved, causing later errors to show the incorrectly-saved
-backtrace. This has been fixed.
+** eqv? not a generic
+
+One used to be able to extend `eqv?' as a primitive-generic, but no
+more. Because `eqv?' is in the expansion of `case' (via `memv'), which
+should be able to compile to static dispatch tables, it doesn't make
+sense to allow extensions that would subvert this optimization.
+
+** `inet-ntop' and `inet-pton' are always available.
+
+Guile now use a portable implementation of `inet_pton'/`inet_ntop', so
+there is no more need to use `inet-aton'/`inet-ntoa'. The latter
+functions are deprecated.
+
+** `getopt-long' parsing errors throw to `quit', not `misc-error'
+
+This change should inhibit backtraces on argument parsing errors.
+`getopt-long' has been modified to print out the error that it throws
+itself.
+
+** New primitive: `tmpfile'.
+    
+See "File System" in the manual.
+
+** Random generator state may be serialized to a datum
+
+`random-state->datum' will serialize a random state to a datum, which
+may be written out, read back in later, and revivified using
+`datum->random-state'.  See "Random" in the manual, for more details.
+
+** Fix random number generator on 64-bit platforms
+    
+There was a nasty bug on 64-bit platforms in which asking for a random
+integer with a range between 2**32 and 2**64 caused a segfault. After
+many embarrassing iterations, this was fixed.
+
+** Fast bit operations.
+
+The bit-twiddling operations `ash', `logand', `logior', and `logxor' now
+have dedicated bytecodes. Guile is not just for symbolic computation,
+it's for number crunching too.
+
+** Faster SRFI-9 record access
+
+SRFI-9 records are now implemented directly on top of Guile's structs,
+and their accessors are defined in such a way that normal call-sites
+inline to special VM opcodes, while still allowing for the general case
+(e.g. passing a record accessor to `apply').
+
+** R6RS block comment support
+
+Guile now supports R6RS nested block comments. The start of a comment is
+marked with `#|', and the end with `|#'.
+
+** `guile-2' cond-expand feature
+
+To test if your code is running under Guile 2.0 (or its alpha releases),
+test for the `guile-2' cond-expand feature. Like this:
+
+     (cond-expand (guile-2 (eval-when (compile)
+                             ;; This must be evaluated at compile time.
+                             (fluid-set! current-reader my-reader)))
+                  (guile
+                           ;; Earlier versions of Guile do not have a
+                           ;; separate compilation phase.
+                           (fluid-set! current-reader my-reader)))
 
 ** New global variables: %load-compiled-path, %load-compiled-extensions
 
 These are analogous to %load-path and %load-extensions.
 
+** New fluid: `%file-port-name-canonicalization'
+    
+This fluid parameterizes the file names that are associated with file
+ports. If %file-port-name-canonicalization is 'absolute, then file names
+are canonicalized to be absolute paths. If it is 'relative, then the
+name is canonicalized, but any prefix corresponding to a member of
+`%load-path' is stripped off. Otherwise the names are passed through
+unchanged.
+
+In addition, the `compile-file' and `compile-and-load' procedures bind
+%file-port-name-canonicalization to their `#:canonicalization' keyword
+argument, which defaults to 'relative. In this way, one might compile
+"../module/ice-9/boot-9.scm", but the path that gets residualized into
+the .go is "ice-9/boot-9.scm".
+
 ** New procedure, `make-promise'
 
 `(make-promise (lambda () foo))' is equivalent to `(delay foo)'.
@@ -772,6 +2141,139 @@ History library functions.
 Instead, use make-typed-array, list->typed-array, or array-type,
 respectively.
 
+** Deprecate the old `scm-style-repl'
+
+The following bindings from boot-9 are now found in `(ice-9
+scm-style-repl)': `scm-style-repl', `error-catching-loop',
+`error-catching-repl', `bad-throw', `scm-repl-silent'
+`assert-repl-silence', `repl-print-unspecified',
+`assert-repl-print-unspecified', `scm-repl-verbose',
+`assert-repl-verbosity', `scm-repl-prompt', `set-repl-prompt!', `repl',
+`default-pre-unwind-handler', `handle-system-error',
+
+The following bindings have been deprecated, with no replacement:
+`pre-unwind-handler-dispatch'.
+
+The following bindings have been totally removed:
+`before-signal-stack'.
+
+Deprecated forwarding shims have been installed so that users that
+expect these bindings in the main namespace will still work, but receive
+a deprecation warning.
+
+** `set-batch-mode?!' replaced by `ensure-batch-mode!'
+
+"Batch mode" is a flag used to tell a program that it is not running
+interactively. One usually turns it on after a fork. It may not be
+turned off. `ensure-batch-mode!' deprecates the old `set-batch-mode?!',
+because it is a better interface, as it can only turn on batch mode, not
+turn it off.
+
+** Deprecate `save-stack', `the-last-stack'
+
+It used to be that the way to debug programs in Guile was to capture the
+stack at the time of error, drop back to the REPL, then debug that
+stack. But this approach didn't compose, was tricky to get right in the
+presence of threads, and was not very powerful.
+
+So `save-stack', `stack-saved?', and `the-last-stack' have been moved to
+`(ice-9 save-stack)', with deprecated bindings left in the root module.
+
+** `top-repl' has its own module
+    
+The `top-repl' binding, called with Guile is run interactively, is now
+is its own module, `(ice-9 top-repl)'. A deprecated forwarding shim was
+left in the default environment.
+
+** `display-error' takes a frame
+
+The `display-error' / `scm_display_error' helper now takes a frame as an
+argument instead of a stack. Stacks are still supported in deprecated
+builds. Additionally, `display-error' will again source location
+information for the error.
+
+** No more `(ice-9 debug)'
+    
+This module had some debugging helpers that are no longer applicable to
+the current debugging model. Importing this module will produce a
+deprecation warning. Users should contact bug-guile for support.
+
+** Remove obsolete debug-options
+
+Removed `breakpoints', `trace', `procnames', `indent', `frames',
+`maxdepth', and `debug' debug-options.
+
+** `backtrace' debug option on by default
+
+Given that Guile 2.0 can always give you a backtrace, backtraces are now
+on by default.
+
+** `turn-on-debugging' deprecated
+
+** Remove obsolete print-options
+    
+The `source' and `closure-hook' print options are obsolete, and have
+been removed.
+
+** Remove obsolete read-options
+
+The "elisp-strings" and "elisp-vectors" read options were unused and
+obsolete, so they have been removed.
+
+** Remove eval-options and trap-options
+
+Eval-options and trap-options are obsolete with the new VM and
+evaluator.
+
+** Remove (ice-9 debugger) and (ice-9 debugging)
+
+See "Traps" and "Interactive Debugging" in the manual, for information
+on their replacements.
+
+** Remove the GDS Emacs integration
+
+See "Using Guile in Emacs" in the manual, for info on how we think you
+should use Guile with Emacs.
+
+** Deprecated: `lazy-catch'
+
+`lazy-catch' was a form that captured the stack at the point of a
+`throw', but the dynamic state at the point of the `catch'. It was a bit
+crazy. Please change to use `catch', possibly with a throw-handler, or
+`with-throw-handler'.
+
+** Deprecated: primitive properties
+
+The `primitive-make-property', `primitive-property-set!',
+`primitive-property-ref', and `primitive-property-del!' procedures were
+crufty and only used to implement object properties, which has a new,
+threadsafe implementation.  Use object properties or weak hash tables
+instead.
+
+** Deprecated `@bind' syntax
+
+`@bind' was part of an older implementation of the Emacs Lisp language,
+and is no longer used.
+    
+** Miscellaneous other deprecations
+
+`cuserid' has been deprecated, as it only returns 8 bytes of a user's
+login.  Use `(passwd:name (getpwuid (geteuid)))' instead.
+    
+Additionally, the procedures `apply-to-args', `has-suffix?', `scheme-file-suffix'
+`get-option', `for-next-option', `display-usage-report',
+`transform-usage-lambda', `collect', and `set-batch-mode?!' have all
+been deprecated.
+
+** Add support for unbound fluids
+    
+See `make-unbound-fluid', `fluid-unset!', and `fluid-bound?' in the
+manual.
+
+** Add `variable-unset!'
+    
+See "Variables" in the manual, for more details.
+
 ** Last but not least, the `λ' macro can be used in lieu of `lambda'
 
 * Changes to the C interface
@@ -785,6 +2287,30 @@ backward-compatible way.  A new allocation routine,
 Libgc is a conservative GC, which we hope will make interaction with C
 code easier and less error-prone.
 
+** New procedures: `scm_to_stringn', `scm_from_stringn'
+** New procedures: scm_{to,from}_{utf8,latin1}_symbol{n,}
+** New procedures: scm_{to,from}_{utf8,utf32,latin1}_string{n,}
+    
+These new procedures convert to and from string representations in
+particular encodings.
+
+Users should continue to use locale encoding for user input, user
+output, or interacting with the C library.
+
+Use the Latin-1 functions for ASCII, and for literals in source code.
+
+Use UTF-8 functions for interaction with modern libraries which deal in
+UTF-8, and UTF-32 for interaction with utf32-using libraries.
+
+Otherwise, use scm_to_stringn or scm_from_stringn with a specific
+encoding.
+
+** New type definitions for `scm_t_intptr' and friends.
+
+`SCM_T_UINTPTR_MAX', `SCM_T_INTPTR_MIN', `SCM_T_INTPTR_MAX',
+`SIZEOF_SCM_T_BITS', `scm_t_intptr' and `scm_t_uintptr' are now
+available to C. Have fun!
+
 ** The GH interface (deprecated in version 1.6, 2001) was removed.
 
 ** Internal `scm_i_' functions now have "hidden" linkage with GCC/ELF
@@ -795,12 +2321,198 @@ application code.
 ** Functions for handling `scm_option' now no longer require an argument
 indicating length of the `scm_t_option' array.
 
-** scm_primitive_load_path has additional argument, exception_on_error
+** Procedures-with-setters are now implemented using applicable structs
+
+From a user's perspective this doesn't mean very much. But if, for some
+odd reason, you used the SCM_PROCEDURE_WITH_SETTER_P, SCM_PROCEDURE, or
+SCM_SETTER macros, know that they're deprecated now. Also, scm_tc7_pws
+is gone.
+
+** Remove old evaluator closures
+
+There used to be ranges of typecodes allocated to interpreted data
+structures, but that it no longer the case, given that interpreted
+procedure are now just regular VM closures. As a result, there is a
+newly free tc3, and a number of removed macros. See the ChangeLog for
+details.
+
+** Primitive procedures are now VM trampoline procedures
+
+It used to be that there were something like 12 different typecodes
+allocated to primitive procedures, each with its own calling convention.
+Now there is only one, the gsubr. This may affect user code if you were
+defining a procedure using scm_c_make_subr rather scm_c_make_gsubr. The
+solution is to switch to use scm_c_make_gsubr. This solution works well
+both with the old 1.8 and with the current 1.9 branch.
+
+Guile's old evaluator used to have special cases for applying "gsubrs",
+primitive procedures with specified numbers of required, optional, and
+rest arguments. Now, however, Guile represents gsubrs as normal VM
+procedures, with appropriate bytecode to parse out the correct number of
+arguments, including optional and rest arguments, and then with a
+special bytecode to apply the gsubr.
+
+This allows primitive procedures to appear on the VM stack, allowing
+them to be accurately counted in profiles. Also they now have more
+debugging information attached to them -- their number of arguments, for
+example. In addition, the VM can completely inline the application
+mechanics, allowing for faster primitive calls.
+
+However there are some changes on the C level. There is no more
+`scm_tc7_gsubr' or `scm_tcs_subrs' typecode for primitive procedures, as
+they are just VM procedures. Likewise the macros `SCM_GSUBR_TYPE',
+`SCM_GSUBR_MAKTYPE', `SCM_GSUBR_REQ', `SCM_GSUBR_OPT', and
+`SCM_GSUBR_REST' are gone, as are `SCM_SUBR_META_INFO', `SCM_SUBR_PROPS'
+`SCM_SET_SUBR_GENERIC_LOC', and `SCM_SUBR_ARITY_TO_TYPE'.
+
+Perhaps more significantly, `scm_c_make_subr',
+`scm_c_make_subr_with_generic', `scm_c_define_subr', and
+`scm_c_define_subr_with_generic'. They all operated on subr typecodes,
+and there are no more subr typecodes. Use the scm_c_make_gsubr family
+instead.
+
+Normal users of gsubrs should not be affected, though, as the
+scm_c_make_gsubr family still is the correct way to create primitive
+procedures.
+
+** Remove deprecated array C interfaces
+
+Removed the deprecated array functions `scm_i_arrayp',
+`scm_i_array_ndim', `scm_i_array_mem', `scm_i_array_v',
+`scm_i_array_base', `scm_i_array_dims', and the deprecated macros
+`SCM_ARRAYP', `SCM_ARRAY_NDIM', `SCM_ARRAY_CONTP', `SCM_ARRAY_MEM',
+`SCM_ARRAY_V', `SCM_ARRAY_BASE', and `SCM_ARRAY_DIMS'.
+
+** Remove unused snarf macros
+    
+`SCM_DEFINE1', `SCM_PRIMITIVE_GENERIC_1', `SCM_PROC1, and `SCM_GPROC1'
+are no more. Use SCM_DEFINE or SCM_PRIMITIVE_GENERIC instead.
+
+** New functions: `scm_call_n', `scm_c_run_hookn'
+    
+`scm_call_n' applies to apply a function to an array of arguments.
+`scm_c_run_hookn' runs a hook with an array of arguments.
+
+** Some SMOB types changed to have static typecodes
+
+Fluids, dynamic states, and hash tables used to be SMOB objects, but now
+they have statically allocated tc7 typecodes.
+
+** Preparations for changing SMOB representation
+
+If things go right, we'll be changing the SMOB representation soon. To
+that end, we did a lot of cleanups to calls to e.g. SCM_CELL_WORD_2(x) when
+the code meant SCM_SMOB_DATA_2(x); user code will need similar changes
+in the future. Code accessing SMOBs using SCM_CELL macros was never
+correct, but until now things still worked. Users should be aware of
+such changes.
+
+** Changed invocation mechanics of applicable SMOBs
+
+Guile's old evaluator used to have special cases for applying SMOB
+objects. Now, with the VM, when Guile sees a SMOB, it looks up a VM
+trampoline procedure for it, and use the normal mechanics to apply the
+trampoline. This simplifies procedure application in the normal,
+non-SMOB case.
+
+The upshot is that the mechanics used to apply a SMOB are different from
+1.8. Descriptors no longer have `apply_0', `apply_1', `apply_2', and
+`apply_3' functions, and the macros SCM_SMOB_APPLY_0 and friends are now
+deprecated. Just use the scm_call_0 family of procedures.
+
+** Removed support shlibs for SRFIs 1, 4, 13, 14, and 60
+
+Though these SRFI support libraries did expose API, they encoded a
+strange version string into their library names.  That version was never
+programmatically exported, so there was no way people could use the
+libs.
+
+This was a fortunate oversight, as it allows us to remove the need for
+extra, needless shared libraries --- the C support code for SRFIs 4, 13,
+and 14 was already in core --- and allow us to incrementally return the
+SRFI implementation to Scheme.
 
 ** New C function: scm_module_public_interface
 
 This procedure corresponds to Scheme's `module-public-interface'.
 
+** Undeprecate `scm_the_root_module ()'
+
+It's useful to be able to get the root module from C without doing a
+full module lookup.
+
+** Inline vector allocation
+
+Instead of having vectors point out into the heap for their data, their
+data is now allocated inline to the vector object itself. The same is
+true for bytevectors, by default, though there is an indirection
+available which should allow for making a bytevector from an existing
+memory region.
+
+** New struct constructors that don't involve making lists
+
+`scm_c_make_struct' and `scm_c_make_structv' are new varargs and array
+constructors, respectively, for structs. You might find them useful.
+
+** Stack refactor
+
+In Guile 1.8, there were debugging frames on the C stack. Now there is
+no more need to explicitly mark the stack in this way, because Guile has
+a VM stack that it knows how to walk, which simplifies the C API
+considerably. See the ChangeLog for details; the relevant interface is
+in libguile/stacks.h. The Scheme API has not been changed significantly.
+
+** Removal of Guile's primitive object system.
+
+There were a number of pieces in `objects.[ch]' that tried to be a
+minimal object system, but were never documented, and were quickly
+obseleted by GOOPS' merge into Guile proper. So `scm_make_class_object',
+`scm_make_subclass_object', `scm_metaclass_standard', and like symbols
+from objects.h are no more. In the very unlikely case in which these
+were useful to you, we urge you to contact guile-devel.
+
+** No future.
+
+Actually the future is still in the state that it was, is, and ever
+shall be, Amen, except that `futures.c' and `futures.h' are no longer a
+part of it. These files were experimental, never compiled, and would be
+better implemented in Scheme anyway. In the future, that is.
+
+** Deprecate trampolines
+
+There used to be C functions `scm_trampoline_0', `scm_trampoline_1', and
+so on. The point was to do some precomputation on the type of the
+procedure, then return a specialized "call" procedure. However this
+optimization wasn't actually an optimization, so it is now deprecated.
+Just use `scm_call_0', etc instead.
+
+** Deprecated `scm_badargsp'
+
+This function is unused in Guile, but was part of its API.
+
+** Better support for Lisp `nil'.
+
+The bit representation of `nil' has been tweaked so that it is now very
+efficient to check e.g. if a value is equal to Scheme's end-of-list or
+Lisp's nil. Additionally there are a heap of new, specific predicates
+like scm_is_null_or_nil.
+
+** Better integration of Lisp `nil'.
+
+`scm_is_boolean', `scm_is_false', and `scm_is_null' all return true now
+for Lisp's `nil'. This shouldn't affect any Scheme code at this point,
+but when we start to integrate more with Emacs, it is possible that we
+break code that assumes that, for example, `(not x)' implies that `x' is
+`eq?' to `#f'. This is not a common assumption. Refactoring affected
+code to rely on properties instead of identities will improve code
+correctness. See "Nil" in the manual, for more details.
+
+** Support for static allocation of strings, symbols, and subrs.
+
+Calls to snarfing CPP macros like SCM_DEFINE macro will now allocate
+much of their associated data as static variables, reducing Guile's
+memory footprint.
+
 ** `scm_stat' has an additional argument, `exception_on_error'
 ** `scm_primitive_load_path' has an additional argument `exception_on_not_found'
 
@@ -826,6 +2538,11 @@ In other words the GNU Lesser General Public License, version 3 or
 later (at the discretion of each person that chooses to redistribute
 part of Guile).
 
+** AM_SILENT_RULES
+
+Guile's build is visually quieter, due to the use of Automake 1.11's
+AM_SILENT_RULES. Build as `make V=1' to see all of the output.
+    
 ** GOOPS documentation folded into Guile reference manual
 
 GOOPS, Guile's object system, used to be documented in separate manuals.
@@ -848,14 +2565,34 @@ macros should now require `guile-2.0' instead of `guile-1.8'.
 If $(libdir) is /usr/lib, for example, Guile will install its .go files
 to /usr/lib/guile/1.9/ccache. These files are architecture-specific.
 
+** Parallel installability fixes
+
+Guile now installs its header files to a effective-version-specific
+directory, and includes the effective version (e.g. 2.0) in the library
+name (e.g. libguile-2.0.so).
+
+This change should be transparent to users, who should detect Guile via
+the guile.m4 macro, or the guile-2.0.pc pkg-config file. It will allow
+parallel installs for multiple versions of Guile development
+environments.
+
 ** Dynamically loadable extensions may be placed in a Guile-specific path
 
 Before, Guile only searched the system library paths for extensions
 (e.g. /usr/lib), which meant that the names of Guile extensions had to
 be globally unique. Installing them to a Guile-specific extensions
-directory is cleaner. Use `pkg-config --variable=extensionsdir
+directory is cleaner. Use `pkg-config --variable=extensiondir
 guile-2.0' to get the location of the extensions directory.
 
+** User Scheme code may be placed in a version-specific path
+
+Before, there was only one way to install user Scheme code to a
+version-specific Guile directory: install to Guile's own path,
+e.g. /usr/share/guile/2.0. The site directory,
+e.g. /usr/share/guile/site, was unversioned. This has been changed to
+add a version-specific site directory, e.g. /usr/share/guile/site/2.0,
+searched before the global site directory.
+
 ** New dependency: libgc
 
 See http://www.hpl.hp.com/personal/Hans_Boehm/gc/, for more information.
@@ -865,6 +2602,10 @@ See http://www.hpl.hp.com/personal/Hans_Boehm/gc/, for more information.
 See http://www.gnu.org/software/libunistring/, for more information. Our
 Unicode support uses routines from libunistring.
 
+** New dependency: libffi
+
+See http://sourceware.org/libffi/, for more information.
+
 
 \f
 Changes in 1.8.8 (since 1.8.7)
@@ -4639,7 +6380,7 @@ incrementally add to the innermost environment, without checking
 whether the restrictions specified in RnRS were met.  This lead to the
 correct behaviour when these restriction actually were met, but didn't
 catch all illegal uses.  Such an illegal use could lead to crashes of
-the Guile interpreter or or other unwanted results.  An example of
+the Guile interpreter or other unwanted results.  An example of
 incorrect internal defines that made Guile behave erratically:
 
   (let ()