Re: Trying to understand chicken limitations

[Iain Duncan]

Thank you very much for such a detailed and helpful response Felix. I can see the reputation for help community is deserved! This all sounds promising. I have a few questions based on what you've said.

- I think I don't need OS level threading, because that is handled by Max, so my code should be executing within the max threads provided by the API, and I expect busting out of those is asking for performance trouble. There are two thread contexts I can write code for, audio and event. I expect to be sticking to the event thread as I'm wanting to do algorithmic composition in scheme, not dsp code. I guess one thing that would be good to know is if there is going to be any problems having multiple separate instances of my scheme code running. Does that work? I.E. two isolated C contexts each with some embedded chicken? 

Regarding your comments about compiling, this is the area I got most confused about. 

- Assuming I have an embedded chicken REPL, does the code I send to the repl get compiled to C before it exectutes? Or can I embed an interpreter that is running chicken?

- Am I correct in understanding from your explanation that I could have precompiled scheme functions and have dynamic scheme code (as in, sent to the process in real time from the user) evaluate and call those compiled functions for more performance?

- Will it be possible to replace functions or other definitions on the fly? I'm hoping to be able to achieve some sort of hot coding, where functions and definitions in my scheme environment may get overwritten by the user doing live coding. Are there limitations on what kind of thing can be dynamically evaluated or can I evaluate anything, but with perhaps a performance penalty?

Also, if anyone knows of example code for embedding chicken in C plugins beyond the one example in the docs, I'd love to look at some.

thanks

On Sun, Dec 22, 2019 at 1:26 PM <address@hidden> wrote:

> Hi folks, I'm hoping someone can help a me, a scheme newbie, choose my
> scheme implementation for a project. (I've done ClojureScript, and am now
> learning Scheme and lisp in general). What I'm not clear on from my
> perusing of the chicken sites is what limitations the fact that chicken
> compiles to C introduces. I'm building a music composition in Max/MSP, and
> I want to host a scheme environment in a C plugin using the Max SDK. My
> goal is to write high level composition related code in scheme, with only
> the ugly max plumbing in C, as it's a rather low-level SDK. One aspect of
> this is that I want users of the plugin to be able to send scheme code, as
> files or strings, from max (passing through the C plugin) into the scheme
> instantiation for evaluation, giving us a REPL-in-max essentially. I've
> been looking at a few options: Guile, S7, Chez, and Chicken right now. I
> feel like the ability to generate C as output could be really useful, but I
> don't understand what I lose from Chicken's design for this case. (Boy I'd
> love to hear "nothing"!)  So any help on that or pointers to resources
> would be much appreciated.

Hi!

It all depends, of course. Since CHICKEN generates C and you want to talk to
a C API, I'd think that it would be more than adequate. I don't know anything
about Max/MSP, so there might be constraints that can make a choice difficult.
Is this on Linux? Mac? Windows? CHICKEN will run on anything, but Windows
makes things always a bit awkward - nothing that can be solved, of course.

Do you need multiple threads? CHICKEN's runtime system is inherently single-
threaded and there is nothing that can be done about it. You might want to to
take that into account.

Performance? If you use a lot of abstractions, things can get slow, if you keep
your code tight and take some time to learn how to write fast Scheme code,
then I see no problem. Compiled code in CHICKEN can be quite efficient, but needs
to go through a C compiler, there is no runtime-compilation as in Chez.
Perhaps you just build + configure objects to be executed in the Max application,
but perhaps you have callbacks from the main application into your plugin
that has to be fast?

CHICKEN's C interface is powerful and comprehensive, you won't find many
Schemes with more convenient means in that regard. Also, this is at compile
time, so code you sent through to a REPL will be interpreted, but can invoke
compiled Scheme code, of course, where there is no interpretation overhead.

The Scheme heap grows + shrinks dynamically, but how you map C-level
data to your Scheme plugin is a crucial design decision. There are facilities
to help you with tying foreign objects into the Scheme memory management,
like finalizers, GC-roots, etc. This is low-level stuff, but doable.

One advantage is that CHICKEN has no dependencies, and it is usually
straightforward to integrate code compiled with it into another application.
It's also very portable, so with some effort, your plugin may run on multiple
platforms supported by Max.

CHICKEN doesn't have particularly powerful debugging facilities, that should
be kept in mind. Particularly in C plugins, one straddles the boundaries
beween C and Scheme a lot, so it is advisable to get some experience
understanding the code that the Scheme compiler produces.

There exists a bunch of extensions that you can use, so you won't have to
start from scratch, if you take care not to include dependencies that don't
play well with Max/MSP. Sometimes integration/build of external code
may need some extra steps, depending on how you want to deploy your
plugin. All that is doable and whether it is easy or hard depends on the
constraints that developing a plugin for a large application involves. I have
done this myself and it can be everything from trivial to hellishly complicated.

Perhaps the most important factor: there is a bunch of people using CHICKEN
that are always eager to help, should you need it, whether it's basic Scheme
questions or whether it's about arcane CHICKEN internals. We have used it in big and complex
applications, in plugins, in commercial products, on all sorts of platforms, so
ask on the mailing lists or in #chicken on freenode if your need assistance.
We can't debug your code, of course, but we can try to explain nearly anything
about CHICKEN itself.

If you already have some experience with one of the other Scheme implementations
you mentioned, then I would advise you to use the one you know. If not, then
CHICKEN might be the right choice, if you need seamless C integration, and
if you are willing to accept that one has to get acquainted to a Scheme implementation
to use it optimally, especially when interfacing with a complex piece of software.

So I'd start from the following basic questions and look what you need:

- what are your performance requirements?
- do you need (OS-level) multithreading?
- are debugging facilities needed?
- is portability an issue?
- how much effort you want to put into this?
- what are the build/deployment constraints?

If you need further advice regarding these points, please feel free to ask.


felix