43 pointsby paroneayea2 days ago4 comments
  • linguaea day ago
    This is excellent news, and also quite timely! I am working on a side project where I want to build an exokernel, and recently (earlier this week, in fact) I decided to use Pre-Scheme as a base for implementing this exokernel and other low-level libraries that handle functionality such as memory management. Eventually I want to be able to host a language like Common Lisp, or at the bare minimum, something like Self (which can be thought of as Smalltalk without classes; see https://selflanguage.org/) on top of Pre-Scheme. This is all part of explorations of how to build a modern OS inspired by the Lisp and Smalltalk environments of the 1980s but updated to address modern concerns such as security and multi-core processors.
    • sourcepluck13 hours ago
      I hope I'm not completely beside the point, but what you describe makes me think of the "malleable systems collective" people who I was reading more about recently:

      https://malleable.systems/catalog/

      I think there may be some synchronicity between the kinds of things being discussed on the forum section of that site and what you're attempting. Very cool project anyway, I hope it goes well!

      • linguae9 hours ago
        Yes, this is exactly what I’m interested in, and building malleable systems is exactly why I’m interested in Lisp- and Smalltalk-style systems where metaprogramming and component-based design are infrastructure for enabling malleable software construction. Exokernels are also a nice complement since this aids in the swapping of even low-level OS components, since OS services are implemented as libraries on top of a tiny kernel that only handles hardware multiplexing and protection.
    • neilva day ago
      When I was learning Scheme, I made a very simple Self-ish object model in R5RS, as an exercise: https://www.neilvandyke.org/racket/protobj/

      Your project sounds more interesting and challenging.

  • ristos16 hours ago
    Very nice!

    I'm looking to use prescheme for low level code that needs more precise control where chibi scheme or guile isn't a good fit. I'm also hoping at some point that I have the time to write a borrow checker on top of prescheme, which might be a subset of prescheme but would still fit many use cases, so that it can be used instead of Rust. And also to create a transpilation step that creates optimizations, that would then ideally be proved. And then that way the borrow checked code with optimizations can be all transpiled by prescheme into C, and then tiny c compiler can compile it unoptimized into straightforward assembly. The goal would be to have verified code that can also be easily hand audited as well. LLMs just make all this stuff so much more possible because of how much faster we can iterate. Fun times for coding!

  • jayemar13 hours ago
    Hadn't heard of Pre-Scheme so I looked through the site a bit and was surprised to see this:

    > Pre-Scheme only supports data-types which are supported natively by C. There are no lists,

    A lisp without lists, very interesting project!

  • 2 days ago
    undefined