…except there is not much in the way of original research. But I have received a lot of positive feedback about my project from the Scheme and Emacs community. So let me ask the Scheme/Emacs fediverse: if you would be interested in using or contributing to a Scheme-based Emacs that is mostly backward-compatible with #GNUEmacs , what is it about this prospect that is most interesting to you?

Personally, I live inside of Emacs and program most of my personal workflows in Emacs Lisp, though I feel that Scheme is a more interesting and fun language to use when compared to other #Lisp-family languages. So I would just like to be able to use Scheme as the language in which I program all of my personal workflows. Also I am curious if it is possible to write a large application in #R7RS Scheme such that it runs on many different Scheme implementations.

So does anyone else agree, or are there other things about a prospective Scheme-based Emacs that interest you that might be worth mentioning to a the audience of the Scheme-related chapters of the ICFP?

I was talking with William Byrd, who is one of the conference organizers of ICFP/SPLASH this year, and he says the committee could possibly accept anything of interest to the Scheme community, for example experience reports and “position papers” (helping others understand an opinion or philosophy on the topic). And they would judge these papers on different criteria than a paper about novel scientific research.

Anyone feel free to comment, but I am going to ping a few people in particular who seem to have opinions on this, like @dougmerritt @jameshowell @david_megginson @tusharhero @arialdo @lispwitch @cwebber @dpk and also @PaniczGodek who published on GRASP at this conference last year, if I recall correctly.

• https://conf.researchr.org/home/icfp-splash-2025/scheme-2025#Call-for-Papers
• https://codeberg.org/ramin_hal9001/schemacs

#tech #software #FOSS #FLOSS #SchemeLang #ProgrammingLanguage

I can setup the project to build using Akku-R7RS:

akku add akku-r7rs;
akku install;
./.akku/env;

But then how should I build each of the .sld files to binary using the Chez compiler?

@mdhughes @civodul @wasamasa do any of you know how to do this?

#tech #software #Scheme #SchemeLang #R7RS #ChezScheme #Akku #AkkuScm #AkkuScheme #AkkuR7RS #Lisp #ComputerProgramming #LispQuestions #LispAskFedi

This took me three months (a month longer than I had hoped), but I finally have merged it into the main branch!

This patch rewrites the Emacs Lisp lexer and parser in Scheme using Scheme code that is 100% compliant with the #R7RS standard, so it should now work across all compliant Scheme implementations. Previously the old parser relied on #Guile -specific regular expressions.

This patch also implements a new feature where a stack trace is printed when an error occurs. This of course makes debugging much, much easier. Previously the old parser did not keep track of where code evaluation was happening, it simply produced lists without source location information. The new parser constructs an abstract syntax tree (AST) and source locations are attached to the branches of the tree which can be used in error reporting and stack traces.

Next I will make whatever minor tweaks might be necessary to get my Emacs Lisp interpreter run on other Scheme implementations, in particular MIT Scheme, Gambit, Stklos, and Gauche. I would also like to try to get it running on Chicken and Chez, although these are going to be a bit more tricky.

Then I will continue with the task of implementing a new declarative GUI library.

#tech #software #FOSS #FunctionalProgramming #Lisp #Scheme #SchemeLang #EmacsLisp #Emacs #Schemacs #GuileScheme

I've been seeing this error for r7rs.org today, if anyone knows who manages their site.

#r7rs #scheme

Listen at: https://archives.anonradio.net/202504020000_screwtape.mp3

This week we will talk about the Unix Philosophy and how it compares and contrasts with whatever one might call the “Emacs Philosophy.”

The impetus for the discussion is a series of blog posts by @ramin_hal9001 called “Emacs fulfills the UNIX Philosophy”:

• The original introductory blog post
• The show notes

…as well as a fascinating discussion that took place over this past week on ActivityPub on the topic of the Unix philosophy and history of Lisp on Unix in which some very knowledgeable people have contributed anecdotes and facts.

#technology #programming #SoftwareEngineering #RetroComputing #lisp #r7rs #SchemeLang #UnixPhilosophy

within each of us
our loved ones, in tiny form,
caring's innate yield
    company at a distance
    legacy in case of loss

#senryu #poem #ShortPoem #SmallPoem #SmallPoems

What I don’t like:

• some stuff breaks “everything is a list” model
• Common Lisp is not minimal, includes overlapping and legacy stuff

does #scheme address this?

@rzeta0 I would say yes, Scheme sort of addresses those issues.

Scheme’s biggest advantage is that it is minimal enough that you can understand the whole language specification top-to-bottom, inside and out. But that is also it’s greatest drawback: is that it is too minimal to be practical. So for a long time, every single Scheme implementation has a it’s own large and unique set of libraries for solving practical programming problems that were incompatible with other Scheme implementations, making the Scheme ecosystem very fragmented. The Scheme Request for Implementation (SRFI) process is meant to address this fragmentation issue. Fragmentation is still (in my opinion) a pretty big problem, though things are much better than they were 20 years ago.

The R6RS standard, as I understand it, tried to make Scheme more practical, but it started to become too Common Lisp-like in complexity so it was mostly rejected by the Scheme community — with a few notable exceptions, like the Chez Scheme compiler.

The next standard, R7RS, split the language into two parts: “R7RS small,” ratified in 2014, which is more like the original minimal core of the Scheme language, but just a few new features, in particular the define-library macro, for modularizing parts of Scheme programs into immutable environment objects. Then they took a collection of “SRFIs” and declared them to be part of the “R7RS large” language standard. The full “large” language specification is not yet fully ratified, even 11 years after the completion of R7RS “small,” but I think the SRFIs they have ratified so far already make the latest Scheme standard a very practical language. The final R7RS standard may end up being larger than Common Lisp, but that is fine with me since it can be almost completely implemented in the R7RS “small” Scheme standard.

R7RS “small” Scheme, in my opinion, is a powerful but minimal language that exists to implement other languages, but is still useful in it’s own right as a progeny of Lisp. The “R7RS large” language then adds the useful features of larger languages like Python or Common Lisp as a layer on top of the “R7RS small” language.

The current chair of the R7RS working group is Daphne Preston Kendal, and is often on Mastodon as @dpk . She can tell you if I got anything in this post wrong.

#tech #software #SchemeLang #R7RS #ProgrammingLanguage

@xameer the “R7RS small” Scheme standard has a full numerical tower built-in, including unbounded integers.

(- (+ (expt 10 100) 1) (expt 10 100))

gives you precisely the correct answer without any floating-point operations. Although macros for symbolic computation with optimization that would avoid computation of (expr 10 100) is “an exercise left to the reader.” Haskell might do the optimal computation though thanks to it’s lazy evaluation.

#tech #computers #software #FunctionalProgramming #Lisp #SchemeLang #Scheme #R7RS

@wingo is asking if anyone knows of a good course on the Nanopass framework (perhaps to recommend to others), but as usual he forgot to add hashtags to his post. So please reply to this post here: https://mastodon.social/@wingo/113956474737820425

#tech #software #Lisp #Scheme #SchemeLang #R7RS #R6RS #GuileScheme #Guile #Compilers #ProgrammingLanguages #PLT

@screwtape https://codeberg.org/ramin_hal9001/gypsum #gypsum #emacs #elisp #r7rs #scheme

me, scoffing: dude there’s like a million of those. what, does yours compile on a pregnancy test?

@garbados I can’t find it now, but someone apparently wrote a #SchemeLang that compiles to Ethereum smart contracts. Being that it runs on the cryptocurrency blockchain, they called it “Pyramid Scheme.” It may have been a joke, but I think someone actually did that.

I have challenged myself to try to get my large Scheme code base to compile on any #Scheme I can find that claims to conform to the #R7RS standard. So far I can get a significant portion of it to compile on #Guile (reference), Gambit, MIT Scheme, #Gauche, and Chibi. I hope I can get it to build on Chez with the #R7RS compatability layer built-in to the Snow Fort package manager.

How can I write a "hello world" with a main method/procedure using #guile #scheme #r7rs ?

For some reason I can't find anything online about a main method in scheme.
Did not finish reading the full report yet.

```
(define-library (hello-world)
(import (scheme base)
(scheme write))
(begin
(define (main args)
(display "Hello, world!\n ~a" args))))
```

guile --r7rs hello-world.sld

#guile #scheme #beginner

what are the differences between resurrected GuileEmacs that was also announced in EmacsConf2024 and Gypsum? At first glance seems like both projects have the same goal.

@ram535 thanks for asking! The goal for both projects are similar, but they are achieved in slightly different ways.

Gypsum is a clone written in Scheme, meaning it is software the behaves exactly like Emacs, but it is written from scratch in a new code base. In this case, it is also being written in a completely different programming language, Scheme instead of C. The larger goal is to have an Emacs that is backward compatible with GNU Emacs but is written in Scheme that runs on any R7RS standard compliant Scheme implementation. There is no C code in this project at all, it is purely Scheme. I would like to also target other compilers such as MIT Scheme, Gambit, Stklos, and possibly Chicken and Larceny as well, though this will be pretty difficult and rely on a lot of cond-expand code. The larger goal is to have an Emacs app platform that encourages the use of the Scheme language for creating applications and text editing work flows, regardless of the underlying compiler.

@lispwitch ‘s “GuileEmacs” is not a clone, but a fork of both GNU Emacs and GNU Guile, meaning it modifies the existing GNU Emacs code base and some of the Guile source base, replacing some of the C source code in GNU Emacs with other C source code from Guile. Then, the Emacs Lisp interpreter written in C is replaced with an Emacs Lisp interpreter written in Guile Scheme. This allows Emacs Lisp to be JIT compiled using Guile’s JIT compiler, and also make use of all of the Guile software ecosystem to extend Emacs. This is incredibly useful, because there is quite a lot of Guile software, including things like web servers and game engines, and soon it could all be available for use by Emacs programmers. It will probably also be production ready much sooner than my Gypsum project because it only needs to implement the core of Emacs Lisp to work. However, it relies on language features specific to Guile to achieve this, so it is not fully R7RS standards compliant, and will not work on other Scheme implementations.

#tech #software #Emacs #SchemeLang #Scheme #R7RS #Guile #GuileEmacs #GuileScheme

It’s called (rapid match), and it is part of the “Rapid Scheme” compiler project, which is a Scheme compiler written in portable, standards-compliant R7RS “small” Scheme.

It is tiny, only 300 lines of code, and compiles almost instantly. But it lacks features that other pattern matchers might have, especially matching on record data types, becuase the R7RS “small” standard does not provide any mechanism for introspection of record data. Also it cannot assign a whole pattern to a single variable, you can only match variables to elements inside of the pattern, which is unfortunate.

But it is efficient, and it gets the job done. It will probably cover 80% of all use cases. It’s best features are portability and it’s small footprint. I have decided to use it in my Gypsum software.

I also discovered that unfortunately Guile Scheme does not fully implement the R7RS standard for library definitions, it is missing the (export (rename from-sym to-sym)) declaration syntax. But I was able to work around it and get (rapid match) to build on Guile.

#tech #software #SchemeLang #Scheme #R7RS #GuileScheme #Guile #FunctionalProgramming #PatternMatching

The presentation is live now, and I am available for questions in the “Big Blue Button” chat room. Feel free to ask me questions here on ActivityPub.

• Stream URL: https://live0.emacsconf.org/dev.webm
• Presentation page: https://emacsconf.org/2024/talks/gypsum/
• Chat room: https://bbb.emacsverse.org/rooms/uqn-ewi-54c-roh/join

The project is an implementation of #EmacsLisp written in portable #R7RS standard #Scheme programming language. The reference implementation is written in #GuileScheme

#tech #software #Emacs #EmacsConf #SchemeLang #Guile

@daviwil hey, thanks for mentioning my talk in your latest live stream! (I watched it but wasn’t able to comment in the chat.) I hope I can answer everyone’s questions tomorrow when my presentation goes live. I haven’t made as much progress on my “Gypsum” project as I had hoped, but I think I have a solid foundation on which we (me and anyone who wants to contribute) can build.

I am also really looking forward to @lispwitch presentation.

It was nice to see @cwebber and @dpk there as well.

https://www.youtube.com/watch?v=RsW7PWhS_vg

#software #programming #tech #SchemeLang #Emacs #EmacsConf2024 #SystemCrafters #Scheme #R7RS

I've also done the same for my generalized-arrays egg! Use transducers everywhere!

https://gitlab.com/ThatGeoGuy/chicken-generalized-arrays

#Scheme #R7RS

“Question for lispers with experience: If you should start to learn a LISP style language today, which one do you pick up? Why?”

@syntaxerror The R7RS “Small” Scheme standard is roughly 80 pages, so you can learn about all of the language features very quickly. I love it because of it’s minimalism, it is my preferred language.

My take on it is that the “Small” Scheme standard is perfectly designed to construct larger programming languages with more features. One such language is R7RS “Large” Scheme, but you could theoretically use it to implement Common Lisp, Python, JavaScript, or any other language.

The R7RS “Large” standard is still being discussed (10 years after “small” was ratified), but it relies heavily on the “Scheme Request For Implementation“ (SRFI) process to fill out features. The larger portion of the R7RS “Large” standard is already ratified and published, so it is still useful even though it is not complete.

There are many Scheme implementations, but I recommend Guile, as it is almost completely R7RS-Small compliant, and has a ton of other useful features that come with it out of the box. So if you need, for example, a quick web server, or a way to search your filesystem, Guile has modules for that.

Another good batteries-included Lisp is Racket, which is a larger language built on top of Chez Scheme (an R6RS Standard Scheme implementation). You can easily install the R7RS Scheme language pack on Racket and write your code in Scheme as you read through the R7RS standard document.

Both Guile and Racket/CS (Chez Scheme) not only have many useful features, but compile to binary code that runs extremely fast for a high-level language.

Also, if you haven’t already, try to learn to use Emacs.

#tech #software #Lisp #CommonLisp #Scheme #SchemeLang #R7RS #Emacs #GuileScheme #RacketLang

Although I have gone out of my way to make this library portable R7RS, it may require a little tweaking to make it work on your Scheme implementation. I have tested it on #Guile , Gambit, #Stklos , and MIT/GNU Scheme. Only Guile passes all tests.

#tech #software #Lisp #ProgrammingLanguage #SchemeLang

#Ol #Lisp #Scheme #R7RS

We have become more Ubuntu (Mint, Pop!_OS, etc.) friendly. We launched our own PPA!

https://launchpad.net/~yuriy-chumak/+archive/ubuntu/ol

#Lisp #Scheme #r7rs

#Ol received an automatic one-liner!
Just do `(write (read))` on any Ol library and you'll clear the source code of comments and unnecessary whitespaces.

Yeah, really. Just read it and then just write!

That's it for speeding up reading! And for "portable" Ol!