I think something the scheme community could learn from Haskell is to lean-in on it's prestige. I see so many people post about how they were never able to figure out how to use scheme in any practical way, and most schemers I've spoke to said it took them about a year to get really compfortable. But I think the #scheme community has traditionally advertised it as "so easy, you can learn it in an afternoon!", and so people, often times already coming from some other #lisp like #clojure, expect to be able to just pick it up, and when they fail to they think the language is lacking. But nobody comes to #Haskell with such expectations, and the Haskell community never advertised it as super easy and quick to learn. In my experience, Haskell has always been sold as "takes time to learn, but is worth it".
@ramin_hal9001 the thing is, I would say this is starting to change with r6 and #r7rs implementations, and #akku does a pretty job of working out the compatibility between different implementations (but the guix package needs some fixing... on my TODOs).
but I agree about the pressure to pick the right one, it drove me mad, but I also think that the idea that getting used to multiple schemes is impossible, and it should even be encouraged to work with a few of them, because once you've navigated a couple, they're all kind of the same at root. but I think people should stick to one for their first year.
it's primarily just the #r5rs implementations that differ wildly. I think theres this mythology that r5rs was this legendary, impeccable standard, and that the process went astray after that, but the truth is that #r6rs really was a massive improvement, and r7rs-large will be something like r6rs (creating an r7rs compatability later for r6rs schemes is a matter of defining a module and a few identifier-syntax macros). problems with post-r5rs are primarily social, rather than technical imo.
Question for anyone familiar with #Scheme programming, and in particular #Guile (@wingo): how hard would it be to port GOOPS to other Scheme implementations like #Chez, #Gauche, Gerbil, or Chicken? I know that other Scheme implementations provide their own #OOP systems (e.g. Chicken COOPS), but what if I want my library written in Guile to be more portable, could I still use GOOPS and try to move the code over to some other platform?
Or has this already been done? Is there a portable GOOPS, akin to a large Scheme library such as SLIB?
@PaniczGodek oh really? to me they are like the bread and butter. when you build good records and structure your programs around them, your flexibility increases dramatically as you have these quasi-"intermediate representations" that are extensible and easy + performant to handle. many schemes use records as their fundamental underlying data representation, including #guile and I believe #chez as well. and I think #r6rs record protocols make them both extremely extensible and parametric, as well as #guix's define-record-type* lazy records which serve a similar purpose with a lot less cognitive overhead.
lots of cool record systems out there, I'm interested in understanding the tradeoffs of #gauche's approach in particular, which is to implement records within a #clos-like object system, which seems to allow you to work with generic methods on record-types (which is something that GOOPs is not very good at, for example). what approach did you go with for your record system?