GNU Guile 2.9.2 Released [beta]

GNU Guile 2.9.2 Released [beta]

[Andy Wingo]

We are pleased to announce GNU Guile release 2.9.2.  This is the second
pre-release of what will eventually become the 3.0 release series.

Compared to the current stable series (2.2.x), the future Guile 3.0 adds
support for just-in-time native code generation, speeding up all Guile
programs.  See the NEWS extract at the end of the mail for full details.

Compared to the previous prerelease (2.9.1), Guile 2.9.2 adds native
code generation support on the ia32, ARMv7, and AArch64 architectures.

We encourage you to test this release and provide feedback to
guile-devel@gnu.org, and to file bugs by sending mail to
bug-guile@gnu.org.

The Guile web page is located at http://gnu.org/software/guile/, and
among other things, it contains a copy of the Guile manual and pointers
to more resources.

Guile is an implementation of the Scheme programming language, with
support for many SRFIs, packaged for use in a wide variety of
environments.  In addition to implementing the R5RS Scheme standard,
Guile includes a module system, full access to POSIX system calls,
networking support, multiple threads, dynamic linking, a foreign
function call interface, and powerful string processing.

Guile can run interactively, as a script interpreter, and as a Scheme
compiler to VM bytecode.  It is also packaged as a library so that
applications can easily incorporate a complete Scheme interpreter/VM.
An application can use Guile as an extension language, a clean and
powerful configuration language, or as multi-purpose "glue" to connect
primitives provided by the application.  It is easy to call Scheme code
From C code and vice versa.  Applications can add new functions, data
types, control structures, and even syntax to Guile, to create a
domain-specific language tailored to the task at hand.

Guile 2.9.2 can be installed in parallel with Guile 2.2.x; see
http://www.gnu.org/software/guile/manual/html_node/Parallel-Installations.html.

A more detailed NEWS summary follows these details on how to get the
Guile sources.

Here are the compressed sources:
  http://alpha.gnu.org/gnu/guile/guile-2.9.2.tar.lz   (10MB)
  http://alpha.gnu.org/gnu/guile/guile-2.9.2.tar.xz   (12MB)
  http://alpha.gnu.org/gnu/guile/guile-2.9.2.tar.gz   (21MB)

Here are the GPG detached signatures[*]:
  http://alpha.gnu.org/gnu/guile/guile-2.9.2.tar.lz.sig
  http://alpha.gnu.org/gnu/guile/guile-2.9.2.tar.xz.sig
  http://alpha.gnu.org/gnu/guile/guile-2.9.2.tar.gz.sig

Use a mirror for higher download bandwidth:
  http://www.gnu.org/order/ftp.html

Here are the SHA256 checksums:

  823dce6c89a993663dbd3eba058cb65daa7a67ef120fcf0295f6ba5682c05fef  guile-2.9.2.tar.gz
  1a64b2e4d7f0d394df437355662219cbfa13fda5ebde93db4ad11356449b7d6c  guile-2.9.2.tar.lz
  e403be8e0ace0ee1150260288755c64a47cce11732e3f8c5fc9e552e5c4365f0  guile-2.9.2.tar.xz

[*] Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact.  First, be sure to download both the .sig file
and the corresponding tarball.  Then, run a command like this:

  gpg --verify guile-2.9.2.tar.gz.sig

If that command fails because you don't have the required public key,
then run this command to import it:

  gpg --keyserver keys.gnupg.net --recv-keys 4FD4D288D445934E0A14F9A5A8803732E4436885

and rerun the 'gpg --verify' command.

This release was bootstrapped with the following tools:
  Autoconf 2.69
  Automake 1.16.1
  Libtool 2.4.6
  Gnulib v0.1-1157-gb03f418
  Makeinfo 6.5


Changes in alpha 2.9.2 (since alpha 2.9.1):

* Notable changes

** Just-in-time code generation support on ARMv7, ia32, AArch64

This release adds just-in-time (JIT) native code generation for the
ia32, ARMv7, and AArch64 platforms, in addition to the x86-64 support
already present in 2.9.1.

** Cheaper just-in-time code generation

Guile now includes a forked version of GNU Lightning.  This "Lightening"
effort, spun out as a separate project, aims to build on the back-end
support from GNU Lightning, but adapting the API and behavior of the
library to match Guile's needs.

One of the important points that this project fixes is run-time
overhead.  With the adoption of Lightening, Guile has lowered its
thresholds for when to generate native code at run-time, so that user
programs run faster, sooner.

For more information, see https://gitlab.com/wingo/lightening.


Cumulative changes in the alpha 2.9.x series (since the stable 2.2 series):

* Notable changes

** Just-in-time code generation

Guile programs now run up to 4 times faster, relative to Guile 2.2,
thanks to just-in-time (JIT) native code generation.  Notably, this
brings the performance of "eval" as written in Scheme back to the level
of "eval" written in C, as in the days of Guile 1.8.

See "Just-In-Time Native Code" in the manual, for more information.  JIT
compilation will be enabled automatically and transparently.  To disable
JIT compilation, configure Guile with `--enable-jit=no' or
`--disable-jit'.  The default is `--enable-jit=auto', which enables the
JIT if it is available.  See `./configure --help' for more.

In this release, JIT compilation is enabled only on x86-64.  In future
prereleases support will be added for all architectures supported by GNU
lightning.  Intrepid users on other platforms can try passing
`--enable-jit=yes' to see the state of JIT on their platform.

** Lower-level bytecode

Relative to the virtual machine in Guile 2.2, Guile's VM instruction set
is now more low-level.  This allows it to express more advanced
optimizations, for example type check elision or integer
devirtualization, and makes the task of JIT code generation easier.

Note that this change can mean that for a given function, the
corresponding number of instructions in Guile 3.0 may be higher than
Guile 2.2, which can lead to slowdowns when the function is interpreted.
We hope that JIT compilation more than makes up for this slight
slowdown.

** By default, GOOPS classes are not redefinable

It used to be that all GOOPS classes were redefinable, at least in
theory.  This facility was supported by an indirection in all "struct"
instances, even though only a subset of structs would need redefinition.
We wanted to remove this indirection, in order to speed up Guile
records, allow immutable Guile records to eventually be described by
classes, and allow for some optimizations in core GOOPS classes that
shouldn't be redefined anyway.

Thus in GOOPS now there are classes that are redefinable and classes
that aren't.  By default, classes created with GOOPS are not
redefinable.  To make a class redefinable, it should be an instance of
`<redefinable-class>'.  See "Redefining a Class" in the manual for more
information.

* New deprecations

** scm_t_uint8, etc deprecated in favor of C99 stdint.h

It used to be that Guile defined its own `scm_t_uint8' because C99
`uint8_t' wasn't widely enough available.  Now Guile finally made the
change to use C99 types, both internally and in Guile's public headers.

Note that this also applies to SCM_T_UINT8_MAX, SCM_T_INT8_MIN, for intN
and uintN for N in 8, 16, 32, and 64.  Guile also now uses ptrdiff_t
instead of scm_t_ptrdiff, and similarly for intmax_t, uintmax_t,
intptr_t, and uintptr_t.

* Incompatible changes

** All deprecated code removed

All code deprecated in Guile 2.2 has been removed.  See older NEWS, and
check that your programs can compile without linker warnings and run
without runtime warnings.  See "Deprecation" in the manual.

In particular, the function `scm_generalized_vector_get_handle' which
was deprecated in 2.0.9 but remained in 2.2, has now finally been
removed. As a replacement, use `scm_array_get_handle' to get a handle
and `scm_array_handle_rank' to check the rank.

** Remove "self" field from vtables and "redefined" field from classes

These fields were used as part of the machinery for class redefinition
and is no longer needed.

** VM hook manipulation simplified

The low-level mechanism to instrument a running virtual machine for
debugging and tracing has been simplified.  See "VM Hooks" in the
manual, for more.

* Changes to the distribution

** New effective version

The "effective version" of Guile is now 3.0, which allows parallel
installation with other effective versions (for example, the older Guile
2.2).  See "Parallel Installations" in the manual for full details.
Notably, the `pkg-config' file is now `guile-3.0'.

Re: GNU Guile 2.9.2 Released [beta]

[David Pirotte]

[-- Attachment #1: Type: text/plain, Size: 2975 bytes --]

Hello Andy,
Ludovic and Mark,

> We are pleased to announce GNU Guile release 2.9.2.  This is the second
> pre-release of what will eventually become the 3.0 release series.
> ...

Thanks for the the fantastic work and and congrat for the release.

I'd like to insist upon the importance, imo, and I believe in the opinion of those
of us who do work daily manipulating (very) large structures (lists, vectors ...),
like Daniel [1], to have the default repl and raised exception printers to use
truncated-print (or what ever procedure), together with a very simple 'mechanism' to
set it to 'full line printing' on demand [2]:

	excerpt from [1]:

	"... I depend on the patch myself to be able to use Guile..."

	So do I - thanks Daniel - and so does any of us that has to manipulate
	large to very large structure ...

Having to have to update/change (ice-9 boot) to be able to merely use large
structures in Guile is quite a 'bad sign', even for us, but for end-users, it is a
blocker: not even Guix accepted to patch Guile this way, why would any lambda
end-user accept that they have to do that? In my experience, they don't [3]:

	while talking to 'bavier' - a long time ago, time runs ... - the guix
	contributor who offered to package Guile-CV, I mentioned that Guile should be
	patched as well, otherwise Guile-CV would be unusable, then Rekado said he
	would not accept to do that ... (I am not blaming him, just saying that if
	even one of the Guix maintainer is 'scared' to patch (ice-9 boot) using a patch
	written by someone who has commit right for Guile ...)

I wish I could recommend any one to install and use Guile-CV, even to those who do
not know scheme (yet) - and I wish it'd be packaged n Guix: this problem is not the
only reason this did not happen yet, but it is the major one [4].

I hope this email, and those it refers to, will grab your attentions to this - 'not so
important for you' but fundamental for us and our users - 'problem' (it is a real
problem for us and our users).

3.0 is an excellent time to 'fix it', imo.

Thanks,
David

[1]	https://www.mail-archive.com/guile-devel@gnu.org/msg14648.html

[2]	to be used 'when needed', either punctually, in a repl, or in .guile for
	those who prefer this default or even in $prefix/share/guile/site/init.scm
	for those who	prefer/need a global config - but the default should be
	to use truncate both for the repl and the raise exception 'system'.

[3]	in order to be able to 'just' use Guile-CV, here is what a user has to do 

	https://www.gnu.org/software/guile-cv/manual/html_node/Configuring-Guile_0027s-raised-exception-system.html#Configuring-Guile_0027s-raised-exception-system

[4]	the other reason for Guile-CV not being in Guix yet is being that it uses
	latex to produce histograms, needs a few latex packages, but in Guix,
	Texlive is a huge package and Guix contributors would prefer to split Texlive
	first ... iiuc


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

Re: GNU Guile 2.9.2 Released [beta]

[Mark H Weaver]

Hi Andy,

I finally got a chance to look closely at your recent work on Guile 3,
and I just wanted to say that the code looks great, a pleasure to read
and hack on.  Thanks again for your sustained injection of awesomeness
into Guile and our community.  I probably don't say that enough.

      Mark