[anta40]

So, what's the recommended Scheme implementation to "get things done", and not only for learning CS stuffs?

For example, now our backend system is mostly implemented in Go (some with Fiber, some with Echo). The rest are pretty common: Postgres, Mongo, Firebase etc.

Perhaps Gambit? BTW, I have nothing against experimentation. Not everything have to do with practical purpose on mind. That's why I'm also tinkering with Haskell & Ocaml :D

[rgrmrts]

Racket, Guile, Gambit, Chicken Scheme, chez are all pretty solid with different trade-offs. I think Racket has a fairly decent developer experience and others like chez and gambit are great implementations but may be lacking in tooling (in the sense that you won’t get a nice package manager or build tool). Options exist (like Akku) but IMO the scheme ecosystem is somewhat disjointed.

Guile integrates well with C, and uses the same build tools as a lot of the GNU ecosystem (make and autotools).

I recognize the answer isn’t maybe the most helpful but it does exemplify, in my opinion, one of the challenges with using Scheme for getting things done.

[jfoutz]

100%

If I had to put scheme in production, I think I'd pick racket. I think that would give me the best chance at helping other dev's get set up, explain the problem, and show the solution. anta40 asked about packages, and racket has the db interaction as part of the normal distribution, I see there's a mongo client in the package manager, but no idea about firebase. I guess wrap the cli?

Racket has been ported over to the chez backend, and got a big performance pop. And they've done stuff with arrays instead of lists, immutable lists. Pointer chasing is always going to have certain tradeoffs.

As much as I love scheme, it's going to be a fringe language. Small shop, that can be ok. You need to hire 50 people? yeah, that's not really going to work out I think.

anta40 also mentiond stuff like Haskell and Ocaml. I feel like those are much easier to refactor, the compiler helps so much, you just chase errors and feel good about code staying correct. scheme, I feel like I just throw it away and start over.

For personal stuff, language doesn't matter, think harder, you'll find a way out.

For "team" stuff. Ugh. That really depends on how dysfunctional the team is. I think go is a pretty solid default. But everything is very textured and nuanced. Just you? go with what you know. Wasting time ramping up on a shiny new thing won't ship. You have a mostly working team? Keep doing that. add linters or whatever to improve code quality.

Screwing around with a weekend project that might turn into something big? Racket seems like the path of least resistance. it's a hard question to answer optimally.

[anta40]

I see... so Racket is the most likely choice for work. Obviously won't use it for my office though, considering Scheme devs here are practically... zero.

Or probably I'll just use Scheme for learning compiler dev :) :D

[jfoutz]

This is readable and interesting - https://legacy.cs.indiana.edu/~dyb/papers/3imp.pdf Dybvig's dissertation (he wrote chez scheme) it's easy to follow.

IMHO, it's a lot easier to write compilers in Haskell or ocaml, for a bunch of reasons. you might take a look at https://wespiser.com/writings/wyas/00_overview.html which walks through writing a scheme implementation in Haskell.

Do what's fun. I think both of those are worth poking at.

[anta40]

Ah seems fascinating. Bookmarked.

[tmtvl]

Maybe Gauche (https://practical-scheme.net/gauche/)? It kinda depends on what you want to get done, though. If the thing you want to get done is to make an operating system I guess Loko would be your go-to.

EDIT: There's also GNU Kawa, which runs on the JVM, so you get all of that Java-y goodness in a language that's actually nice to use.