> Not for me. See for example in a dictionary: 'involving recent techniques, methods, or ideas'. Much of the stuff in Scheme is decades old and has been provided incompatible in multiple ways, none really satisfying. See 'Error handling'.

Then nothing is modern in the programming language world, for you, and you're not up for a discussion.

Rust's type safety is old, Scala's DOTTY is the exploration of combining several older theories to create DOT, and both of those are supposed to be cutting edge.

Modern Scheme has:

* Lazy, immutable, mutable subsets

* Hygenic and unhygenic macros

* Fast and simple error handling

* Fast and simple compiling and evaluation

* Tail call elimination

* Procedures, closures, currying

* Safe eval, and generative environments

* Multi-threading and asynchronous callbacks

It's simple and powerful enough that people commonly plug object-orientation, type safety and DSLs into it.

What is left for you to consider modern?

> Just look at the table of contents

Wow. It looks like a table of contents. Starting with a short introduction, and slowly expounding on previous knowledge to detail the entire language. Looks remarkably similar to the manuals for SBCL and ECL, simpler than Python, Rust's Reference and Julia.

All you're giving me... Is that you're afraid of TOC pages. Which I'm hoping is not the case.

> Several error handling libraries, none really good and all not well integrated into the rest of the language. That's really basic stuff which hurts. Instead of at least an attempt at a coherent language it is a patchwork of tiny stuff.

I cannot agree with you here.

There are several ways of error handling, because error-handling lazy, immutable, mutable and object-oriented things can't be done in the same way, to the level of detail that Scheme will hand you.

But, if you want one simple, high level approach to handle them all... You're looking for the Exception stuff.

(with-exception-handler
...code...
(exception-handler ...error handling func...))

Done. Easy.

(In fact, most other error systems are only there for backwards compatibility with previous versions of the Scheme standard.)

> In fact, what about SBCL?

> What about it?

It differs from the Common Lisp spec in much the same way as Guile, as the link pointed out. Apparently you find only one of these facts confusing.

> SBCL has already the core language defined in detail. Example from above: there is one error handling mechanism (the Condition System) and it is used everywhere and it is well integrated.

And the same is true of Scheme. You have the Exception system, used everywhere. When finer-grained control is desired, you also have that available.

The Scheme "core language" is right here [1].

The semantics of the language are well spelled out, and the standard library is also spelled out.

The only difference any compliant-implementation, like Guile, has, is a larger standard library. Any infix-operators, or S-XML, or any of these other things... Is just a library. Anything beyond r7rs-simple, is just a library.

Your complaint with the spec seems to boil down to "Scheme keeps the most popular things around to make backwards-compatibility easy, and upgrading easy".

[1] http://trac.sacrideo.us/wg/raw-attachment/wiki/WikiStart/r7r...