[HN Gopher] My resignation letter as R7RS-large chair
___________________________________________________________________
My resignation letter as R7RS-large chair
Author : nickmain
Score : 114 points
Date : 2023-08-17 16:31 UTC (6 hours ago)
(HTM) web link (groups.google.com)
(TXT) w3m dump (groups.google.com)
| tedivm wrote:
| Does anyone actually use Scheme for real projects? The only
| places I've ever seen it used have been in classrooms.
| evdubs wrote:
| I use Racket (a Scheme) for option trading.
|
| https://github.com/evdubs/renegade-way
| sph wrote:
| Great example, very readable and with a GUI as well!
| dharmatech wrote:
| Fascinating!
|
| If you hadn't gone with Scheme, what's another language you'd
| have considered for this project?
| evdubs wrote:
| Java and JavaFX.
| whartung wrote:
| How was your experience with Racket in this case vs Java
| (assuming you've had some FX experience to contrast it
| to)?
| dharmatech wrote:
| I've used Scheme a bunch in the past.
|
| These days, I've been using PowerShell for economy data and
| some options stuff:
|
| https://github.com/dharmatech/options-chain-marketdata.ps1
|
| https://github.com/dharmatech?tab=repositories
| dxbydt wrote:
| I used it just the other day to work an aime problem for my
| middle schooler.
|
| scheme@(guile-user) [5]> (exp (* (atan 1) -2))
|
| $9 = 0.20787957635076193
|
| scheme@(guile-user) [5]> (expt 0+1i 0+1i)
|
| $10 = 0.20787957635076193+0.0i
|
| a problem c/c++/java/js/python/rust/go can't handle after
| decades of progress. even my favorite R can't work this
| problem. scheme ftw.
| fn-mote wrote:
| I think this is probably because you did not know how to type
| a complex number in R. The coefficient of i is not optional.
| > exp(-2 * atan(1)) [1] 0.2078796 > 1i ** 1i
| [1] 0.2078796+0i
| satya71 wrote:
| Hmm. Python 3.11 (didn't test in earlier)
|
| >>> from math import atan, exp
|
| >>> exp(atan(1)*-2)
|
| 0.20787957635076193
|
| >>> 1j**1j
|
| (0.20787957635076193+0j)
| dxbydt wrote:
| thank you. i tested this on lc playground and yeah it does
| work.
| dragonwriter wrote:
| As well as python noted in a sibling, Ruby handles this quite
| well out-of-the box.
|
| Is your complaint just that some popular languages don't have
| complex numbers as part of the core/stdlib?
| vinaypai wrote:
| What's the "aime problem" and why can't
| c/c++/java/js/python/rust/go handle it?
| dqv wrote:
| I did a little googol and found out it's like an
| accelerated math thing https://artofproblemsolving.com/wiki
| /index.php/American_Invi...
| mlyle wrote:
| To be clear, it's a competitive exam and one of the
| primary feeders into the USA Math Olympiad team.
|
| Many problems are quite challenging.
| vinaypai wrote:
| Okay, I was just wondering if there's something non-
| obvious here. I guess OP is just woefully misguided about
| languages other than scheme or "these languages can't
| handle it" means something more like "I don't know how to
| use those languages".
| chriswarbo wrote:
| I chose Racket for a project that involved lots of AST
| manipulation. Those ASTs were already in s-expression format,
| so Scheme seemed a natural fit.
|
| The lack of static types was annoying; Typed Racket helped, but
| was so slow I only enabled it during unit tests (more
| precisely: Typed Racket functions can be faster than those
| written in normal Racket, but calling them from normal Racket
| functions will be slow as it performs run-time checks)
|
| https://github.com/Warbo/theory-exploration-benchmarks/tree/...
| kryptiskt wrote:
| I assume that Cisco is using Chez Scheme for something since
| they bought it (and open sourced it).
| cosmojg wrote:
| Yes, the very website[1] on which you posted this comment is
| written in Scheme[2], for example.
|
| [1] https://en.wikipedia.org/wiki/Hacker_News
|
| [2] https://en.wikipedia.org/wiki/Arc_(programming_language)
| tedivm wrote:
| Both of the links you share contradict your statement. ARC
| isn't scheme, and the hacker news link you posted as a source
| doesn't mention scheme either.
| agumonkey wrote:
| It's a dialect on top of mzscheme iirc. You're right it's
| not in scheme per se but used as "runtime target".
| duncan-donuts wrote:
| Like all lisps it is niche. I don't use scheme but have used
| Common Lisp and clojure for a few years. Racket has a thriving
| community as far as I can tell. You just don't see lisp much in
| the wild but it's there.
| senkora wrote:
| Guile Scheme is used extensively in the Guix linux
| distribution, and works quite nicely there.
| _zoltan_ wrote:
| extreme niche on extreme niche.
| Zambyte wrote:
| Which is terribly unfortunate, because it solves very non-
| niche packaging problems in a very elegant way.
| pxc wrote:
| Guix is niche, but it's very much 'real software'. It does
| useful things well, and it solves some problems that very
| few competitors adequately do. It's used for reproducible
| scientific computing on some HPC clusters, which is a
| pretty cool niche if you ask me.
|
| The Guix package collection is also sizeable and growing
| exponentially-- within a few years, it'll probably outgrow
| most Linux distros in terms of size.
| kdmccormick wrote:
| Unless they have quietly rewritten it, HN itself is written in
| Scheme. Or, more precisely, it is written in Arc, which is
| implemented in Scheme.
| [deleted]
| alexott wrote:
| Around 20 years ago I worked on commercial email
| filtering/archiving system implemented in MzScheme (now PLT) -
| it was relatively small code base, but very powerful.
|
| I wrote an article about it in Russian (almost 15 years ago),
| for some reason google translate doesn't work for archive url:
| https://web.archive.org/web/20210506123442/http://fprog.ru/2...
| retrac wrote:
| It's currently used as a back-end for the Idris language.
| (Which is primarily a research language, admittedly.) It's a
| fairly popular target for languages to compile to, for similar
| reasons that C is -- small, well-defined, minimal, many
| implementations, runs just about everywhere. Very nice
| compilation target for functional languages in particular, as
| call/cc can, with reasonable efficiency, implement just about
| any kind of control flow/evaluation/threading model that you
| can think of.
|
| Also, used as a scripting language in the GIMP.
| bmitc wrote:
| I don't think the intention of Idris is to be a research
| language.
| retrac wrote:
| > Idris is primarily a research project, led by Edwin Brady
| at the University of St Andrews, and has benefited from
| SICSA (https://www.sicsa.ac.uk) and EPSRC
| (https://www.epsrc.ac.uk/) funding. This does influence
| some design choices and implementation priorities, and
| means that some things are not as polished as we'd like.
| Nevertheless, we are still trying to make it as widely
| usable as we can!
|
| -- https://idris2.readthedocs.io/en/latest/faq/faq.html
|
| At this point, the creator has described it as "Pac-Man
| complete", able and easy to implement a game like Pac Man.
| (Or itself - it compiles to Scheme but is written in
| itself.)
|
| Dependent types are still rather new; I believe Idris and
| its libraries are one of the largest, if not the largest,
| body of general-purpose software that uses them. (F*
| maybe?) How to use dependent types properly in a standard
| library seems be an ongoing development.
| Quekid5 wrote:
| The Pac-Man Complete bit is tongue-in-cheek. It's an
| observation that TC is rarely (if ever) _actually_ needed
| in practice.
|
| (This might sound strange people unfamiliar with
| dependently typed langs, but infinite streams etc.,
| servers that "loop forever" doing request-repsonse can
| still be modeled without TC.)
| kryptiskt wrote:
| It's intended to be a practical research language. Its
| niche is as a dependently typed language that is useful for
| writing real programs. But it also needs to be a toolkit
| for research into dependently typed programming, since most
| of the devs have to publish.
| sinkwool wrote:
| The Unison language JIT is being written in Scheme:
| https://www.unison-lang.org/whats-new/jit-announce/
| tmalsburg2 wrote:
| C is neither minimal nor well-defined, as has been discussed
| extensively. Random blog post illustrating only some of the
| issues is here [1]. Just google "undefined behavior c" for a
| lot more. There are also a bunch of famous rants by Linus
| Torvalds on his topic.
|
| [1] https://blog.regehr.org/archives/213
| PennRobotics wrote:
| can we all agree that the undefined behavior is pretty well
| identified and documented? Plus, if you understand the
| entire language and then limit your imagination, C can be
| quite simple!
| mrguyorama wrote:
| It's so simple to avoid undefined behavior, just never
| add two numbers, or dereference a pointer that you can't
| statically guarantee the value of.
| fluoridation wrote:
| You can add two numbers. If the operands are signed you
| just need to check the operands before the addition to
| make sure you won't cause an overflow.
| spookie wrote:
| Yes, it's a simple language. That's why there are no safe
| guards around INT_MAX + 1, or variants of that.
| wk_end wrote:
| Naughty Dog used Racket as part of the development of The Last
| of Us.
|
| [0] https://www.youtube.com/watch?v=oSmqbnhHp1c
| chongli wrote:
| I think the biggest issue with any lisp is that it's just too
| damn powerful of a language. This makes it super easy for
| developers to create their own little ecosystem of macros and
| functions that nobody else can understand. This can be
| absolutely disastrous for large teams and companies looking to
| hire.
|
| Languages that force you to be more verbose and don't let you
| build your own ultra-powerful abstractions seem to work better
| for large teams where you can force everyone to adopt a
| standard style. This makes onboarding much easier too.
| tikhonj wrote:
| People say this, but it hasn't been my experience in practice
| --the worst, most complex codebases I've seen have been in
| Python and Java.
|
| But I guess they look simple and uniform at a superficial,
| syntactic level. If you can't follow that it's your fault, if
| you can't follow Lisp code it's Lisp's fault...
| remexre wrote:
| I dunno, I got a (Common) Lisp job, and I don't think I've
| ever had a problem where I didn't understand the semantics of
| a macro; people aren't just making a ton of them all the time
| for no reason, and the ones that are popular are from popular
| libraries (e.g. alexandria and iterate) and have clear
| semantics.
|
| I think the same problem applies perfectly well to developers
| who "create their own little ecosystem of classes and
| functions nobody else can understand" -- I don't think [0]
| would be made any harder to understand by having macros
| involved.
|
| [0]: https://old.reddit.com/r/programming/comments/15s0lp6/ho
| w_we... (only picking on it because I saw it recently)
| matrix12 wrote:
| We use Gerbil/Gambit scheme in production. The new actor system
| makes it a very compelling.
| all2 wrote:
| How do you handle Gerbil's incomplete docs? I'll admit, when
| I was looking at them I had no clue how Schemes worked, but I
| found the lack of documentation to be a very difficult
| barrier.
| BaculumMeumEst wrote:
| i would wager that anyone ballsy enough to use gerbil in
| production is at a minimum very active on gitter and
| probably a contributor to the language
| kkylin wrote:
| Isn't Julia's parser still in Scheme?
| sundarurfriend wrote:
| For now, yes. The upcoming 1.10 release (which is now in
| beta) will switch to a pure Julia parser as the default (with
| the old Scheme parser available as an option).
|
| Not because of any fault with Scheme per se (afaik), just
| that contributors to Julia are more likely to know Julia than
| Scheme, so it makes sense from a maintanence point of view.
| adgjlsfhk1 wrote:
| note that in 1.10 scheme is still used for lowering
| (simplifying AST to IR which is a lot of code for julia)
| cbkeller wrote:
| Femptolisp, a "Scheme dialect"
| MadcapJake wrote:
| Chicken Scheme is a high performance source-to-source (C)
| Scheme that supports the R5RS and R7RS (work in progress)
| http://www.call-cc.org/
| gumby wrote:
| Could someone fill in the background? R7RS seems like an unlikely
| venue for hot conflict, but then again I haven't been a scheme
| user in decaes.
| that_guy_iain wrote:
| Well, a quick search into this found this talk from John Cowan
| that appears to be from 2011 on R7RS -
| https://www.youtube.com/watch?v=kC7xPBQWsVE
|
| I honestly don't think there can be any value in a standard
| that takes so long to come up with. Now in an industry that
| moves as quickly as this one.
| TylerE wrote:
| The whole situation feels - as a total outsider - pretty
| bikesheddy. The lower the real world stakes, the higher the
| tension.
| tobinfricke wrote:
| What is R7RS?
| tmtvl wrote:
| It's the Revised Revised Revised Revised Revised Revised
| Revised Report on the algorithmic programming language
| Scheme. That's 7 "Revised"s, hence R7RS. Basically the RxRSes
| are full specifications of what you need in a Scheme
| implementation to conform to the Xth iteration of the
| language.
| dxbydt wrote:
| (Revised (Revised (Revised (Revised (Revised (Revised
| (Revised Report)))))))
| tmtvl wrote:
| I like using arrow-macros (threading macros) myself;
| (-> report revised revised
| revised revised revised
| revised revised)
| joshxyz wrote:
| that's an interesting naming convention!
| Decabytes wrote:
| Revised report version 7. The current scheme standardization.
| It proceeded R6RS which many felt was too large, and added
| too many things to the scheme standard (it's only 90 pages
| long). R7RS was the compromise
| kkylin wrote:
| Exactly. R7RS-small was meant to be a minimal core
| language, in the spirit of RnRS for n <= 5, whereas R7RS-
| large was meant to be a fairly complete set of standard
| libraries.
| CamperBob2 wrote:
| _R7RS seems like an unlikely venue for hot conflict, but then
| again I haven 't been a scheme user in decades._
|
| It appears to be an instance of Sayre's Law:
| https://en.wikipedia.org/wiki/Sayre%27s_law
| neilv wrote:
| Scheme is an especially appealing elegant and powerful
| language. And it attracts people who aren't in software or
| programming languages for the money.
|
| So, the stakes are very small, in terms of commercial value,
| but...
|
| If you think of Scheme as an oasis, relative to most popular
| programming languages and communities, then the stakes can be
| quite large.
| CamperBob2 wrote:
| Right, that's what I mean. It doesn't mean something to
| everyone, but it means everything to a few.
| munificent wrote:
| The Scheme community has long held tension between people who
| want to use Scheme as a teaching language, versus those who
| want to use it for writing real-world programs.
|
| The former want the language to stay as minimal as possible
| with a tiny standard library so that there are fewer concepts
| and options for students to stumble over. The latter want a
| full-featured language (but still minimal, it is Scheme after
| all) with a large standard library of useful types and
| functions so they can get stuff done.
|
| These two perspectives are both reasonable but fairly
| incompatible.
|
| For most of its history, Scheme leaned towards education.
| Around the type of the sixth edition (RSR6), pulled somewhat
| the other way and the language and library spec got much
| bigger. This alienated a lot of folks who wanted to stay a
| small teaching language.
|
| For RSR7, they tried to resolve that by simply splitting the
| language in two: a small one and a large one. Then each
| subcommunity can have what they want.
|
| Around the same time, the language PLTScheme renamed itself to
| Racket to clarify that they aren't trying to be beholden to the
| overall direction of the Scheme community. Racket is also a
| "large Scheme" in that it's a Scheme-derived language that
| tries really hard to be batteries included for all sorts of
| uses. It also can be "subset" into smaller languages for use in
| teaching.
|
| My impression (from far on the outside) is that Racket has
| taken up a lot of the oxygen, which may partially explain why
| RSR7-large never managed to reach consensus and ship.
| allenrb wrote:
| Indeed, thanks for the explanation. Not being super familiar
| with the Scheme community, "R7RS" sounds like a high-
| performance Audi.
| frob wrote:
| It's the Revised Revised Revised Revised Revised Revised
| Revised Report on the Algorithmic Language Scheme, or
| (Revised)^7 Report on the Algorithmic Language Scheme, or
| R7RS.
| munificent wrote:
| (Because, of course, Scheme folks couldn't resist the
| urge to use a little recursion in the name of the spec
| instead of defining it as an iterated series of version
| numbers.)
| AndrewKemendo wrote:
| That is extremely well written thank you.
| merlincorey wrote:
| I don't have much more context than you, but one bit I did
| catch is that this resignation is for "R7RS-large" and not
| "R7RS-small" (which might even be complete already).
|
| Traditionally, Scheme is as minimalist as possible by design.
| Therefore, the very idea of "R7RS-large" is likely
| controversial to some parties involved.
|
| Apparently it has been an on-going argument for years on just
| what to include in R7RS-large, as we can see a Reddit thread
| from 2 years ago asking when it will be ready[0] and John Cowan
| (the person who is resigning from the committee) saying parts
| one and two are done and part three should "follow quiuckly
| thereafter".
|
| > That depends entirely on how much time people can devote to
| it. The first two parts, Red and Tangerine, are already in
| place; Orange needs a few things pulled together before it can
| be voted on, and Amber should follow quickly thereafter.
|
| I'm guessing getting that last 90+% of agreement stretched ever
| further and further on and as John said in the resignation
| letter, it was surely exhausting.
|
| [0]
| https://www.reddit.com/r/scheme/comments/nohfwe/when_will_r7...
| jsnell wrote:
| > "R7RS-small" (which might even be complete already).
|
| I believe r7rs-small was finalized over 10 years ago.
| Someone wrote:
| Indeed, but not by a large margin.
| https://small.r7rs.org/attachment/r7rs.pdf says "July 6,
| 2013"
| pvarangot wrote:
| I think programming language standards committees are not an
| unlikely venue for hot conflict, quite the opposite if you talk
| just about conflict without the word "hot". I don't have the
| background on this one though.
|
| Do you have any experience reaching to similar organizations?
| for example reporting compiler or linker bugs or trying to get
| support for new features or platform that are not well
| documented? If you don't and think it sounds fun go ahead and
| have fun if you can do that work without getting dragged into
| hot conflict.
| bachmeier wrote:
| Additional background would be nice. I clicked the link out of
| curiosity to see what it meant for a piece of furniture to resign
| from something. After clicking the link, I was no better
| informed.
| [deleted]
| neilv wrote:
| Thanks to John Cowan for all his work on a very challenging PL
| standards efforts.
|
| Someday, I'd be interested in what were the _process_
| difficulties overcome, and how, and what are the remaining
| problems or costs.
|
| (Disclosure: I was involved in the working groups, briefly and in
| a much lesser capacity.)
| tannhaeuser wrote:
| FYI John Cowan is also known as editor of the XML 1.1 spec, as
| well as other works related to markup languages and Unicode.
| refulgentis wrote:
| I almost posted this an hour ago, and feel more comfy now that
| it's an hour later:
|
| I'm sad how quickly this rocketed to top 3 on front page and how
| little content there is, it's just someone resigning from a
| project virtually none of us know about. The "My resignation
| letter" was titillating enough to skyrocket upvotes and
| engagement
| j-wags wrote:
| I upvoted because I'm involved in a growing OSS project that's
| tangling with similar questions of scope and governance.
| Simultaneously being responsible for everything from software
| deployment and PR reviews to project scoping and interpersonal
| conflict de-escalation is absolutely exhausting. I'm
| fantasizing/extrapolating that many of the people writing "so
| sorry to see you go" messages were the ones being quarrelsome
| and refusing compromise, and now they're getting the defect-
| defect outcome.
| chriswarbo wrote:
| > a project virtually none of us know about
|
| You may be surprised! For context, R7RS is the latest standard
| for Scheme. Actually it's two standards: a 'small' one for the
| core language (similar to R5RS; this was finished a decade
| ago), whilst this involves the 'large' standard, which is
| trying to agree on a "standard library".
|
| Some reasons people may have upvoted this, or otherwise be
| interested in Scheme:
|
| - R7RS has been dragging on for so long, it may be nice to see
| some/any sort of status update
|
| - Scheme has so many diverse implementations (Racket, Guile,
| Gambit, Chicken, Chez, Stalin, etc.) that it's really important
| to have some common standards.
|
| - Scheme was a major influence on Javascript (along with Self)
|
| - Scheme pioneered many features that are now taken for
| granted, e.g. first-class functions (it's a "1-lisp"), lexical
| scope, tail-call elimination, continuation-passing style,
| call/cc, etc.
|
| - Scheme is commonly used as a scripting language by
| applications written in other languages (similar to Lua).
| Indeed, Guile is the "official" extension language of the GNU
| project (e.g. see Guix, Shepherd, etc.).
|
| - Scheme was/is taught at many schools and university courses
|
| - Well-known textbooks like SICP use Scheme; and indeed guide
| the reader through writing their own implementation!
|
| - Scheme is used for programming language research (e.g.
| "towers of interpreters", (delimited) continuations,
| miniKanren, etc.). Indeed Racket used to be called PLT Scheme
| (PLT = Programming Language Theory)
| zem wrote:
| > - R7RS has been dragging on for so long, it may be nice to
| see some/any sort of status update
|
| that's why i upvoted! this is a pretty significant status
| update if you're interested in r7rs or scheme in general.
| [deleted]
| greggsy wrote:
| https://github.com/johnwcowan/r7rs-work/blob/master/R7RSHome...
|
| I still have no idea what exactly R7RS is
| arp242 wrote:
| The 7th version of the Scheme standard/specification,
| basically. There's a "small" and "large" version of it, for
| different use cases/preferences (there's a bit of drama behind
| this: R6RS introduces a lot of "large" features that many
| implementers felt were too "bloated", which was eventually
| resolved by splitting the standard in small/large variants).
| all2 wrote:
| It seems like "core language" vs "standard library" almost.
| The Large spec includes things like lists, vectors, streams,
| and generators [0].
|
| [0] https://practical-scheme.net/gauche/man/gauche-refe/R7RS-
| lar...
| [deleted]
| [deleted]
| yieldcrv wrote:
| I thought it was a Xaiomi smart chair posting on the internet
| mananaysiempre wrote:
| There used to be a website a long time ago, but for now your
| link is it, unfortunately.
|
| R7RS is the _Revised7 Report on the Algorithmic Language
| Scheme_ , the latest common-ground description of the language.
|
| Revisions up to and including R5RS were fairly minimalistic
| (even if not all of the features new to R5RS are
| uncontroversial) and specified essentially no library
| facilities, which were usually either completely
| implementation-specific or released as RFC-style documents
| called SRFIs (Scheme requests for implementation). As a result,
| toy, teaching, or research implementations of Scheme were
| fairly easy to make, but moving programs between
| implementations was a bit of a crapshoot.
|
| The reaction to that was R6RS, which is--if not the length of
| the Common Lisp spec--similar in scope, with utility and OS
| interface libraries, an extensive macro system, a freshly
| designed module system, and a lot of other stuff. When SRFIs
| for the new functionality existed, R6RS certainly took
| inspiration from them, but its redesigns were neither fully
| compatible nor taken through the public SRFI process (the
| standard was still subject to public discussion, but in a
| different venue with different procedures). And people wanting
| a minimal standard to implement on their own (a not
| insubstantial part of Scheme users) were told that R6RS wasn't
| for them and pointed back to R5RS.
|
| Long story short, the few commercial Scheme vendors (first of
| all Chez Scheme, prior to the Cisco acquisition and open-source
| release) largely adopted R6RS; the rest of the implementor
| community largely ignored it or cherry-picked some parts--and
| that means not only the myriad hobby implementations, but also
| the medium-scale ones like Chicken, Gambit, or Gauche. I think
| even Guile (whose stance on minimalism mirrors that of most
| other GNU software) requires some wrangling to get it close to
| R6RS.
|
| R7RS was intended to close that divide: there's R7RS-small,
| which is an R5RS-style lean spec, and R7RS-large, which was
| intended to be a R6RS-style real-world language, but composed
| with more respect to existing practice and SRFIs and with more
| implementor buy-in. It was to be released in several issues
| organized by topic (data structures, I/O, etc.). John Cowan
| managed to get a couple of these out the door over the last
| decade, but the efforts seem to have stalled. AFAIK Chez, the
| gold standard of real-world implementations how that PLT Scheme
| has reinvented itself as Racket and gone its own way, has also
| indicated no interest in even looking at R7RS-large however
| nice it turns out, because they have customers now and that
| takes priority over ecosystem health.
| ur-whale wrote:
| > moving programs between implementations was a bit of a
| crapshoot.
|
| You just summarized the historical reason why LISP and its
| various incarnations (Scheme among others) failed.
|
| So many different patois, no way to move code from one to the
| other without giant headaches.
| User23 wrote:
| That's not quite so true. The Common Lisp standard actually
| works pretty well for having many conforming
| implementations. For example SBCL, which it's fair to call
| a nontrivial program, is portable across itself, CMUCL,
| Clozure CL, CLISP, ABCL, and ECL.
| mananaysiempre wrote:
| Eh. Giant headaches is overstating it, I think, if we're
| talking Lisp post 2005 or 2010: Common Lisp implementations
| are largely compatible; Racket only has one implementation
| (and no spec); in Scheme you'll have to spend a bit of time
| porting between the three or four big implementations that
| can actually run your stuff, big whoop. (On this forum I
| probably have to mention Arc, but I don't believe it ever
| grew beyond a personal project.) I'd say that the main
| obstacle to adoption was rather the (apparent) absence of
| shinies (and boy were there a lot of competing shinies at
| the time).
|
| Even if this were correct, though, my experience is that I
| find very little enjoyment in things that are targeted at
| what in your terms is success. For example, Go feels
| dreadfully unpleasant even though I can't deny the good--
| occasionally downright brilliant--engineering that went
| into it, kind of like a mass-produced concrete residential
| building. Let's be honest, I'm in this largely for the
| hackery, a little bit for the feeling of having solved
| somebody's problem, and not in the slightest for the social
| acceptance. You might not agree here (or you might!), but I
| hope that, if one day nobody does, I still have the self-
| awareness to step away from the computer and go do
| something else.
| all2 wrote:
| R7Rs Small: https://small.r7rs.org/
|
| R7Rs Large: https://practical-scheme.net/gauche/man/gauche-
| refe/R7RS-lar...
|
| R6RS: https://www.r6rs.org/
|
| R5RS: https://conservatory.scheme.org/schemers/Documents/Stan
| dards...
|
| R4RS: https://people.csail.mit.edu/jaffer/r4rs_toc.html
| pavon wrote:
| Thanks, that is helpful background. I can see how it would be
| difficult find agreement between groups who want
| compatibility with R6RS, and those who want compatibility
| with SRFIs.
| cobbal wrote:
| It's a specification of the scheme programming language:
| https://en.wikipedia.org/wiki/Scheme_(programming_language)
| cosmojg wrote:
| It's the latest version of a language specification for the
| Scheme family of programming languages.
| layer8 wrote:
| Took me a few moments to realize this isn't a satirical text
| about a large seating furniture.
| [deleted]
| mkl95 wrote:
| [flagged]
| JonChesterfield wrote:
| It does have slight perl 6 vibes. Scheme was a very small
| language with high expressive power (compiler under application
| control and first class continuations). It picked up cleanups
| and fixes until revision 4 or 5ish, the r6 changed direction
| and went for relatively big language. More like common lisp.
|
| R6 fractured the community, some people stayed on R5
| indefinitely. R7 tried to handle this with a small and large
| revision, shipped the small part a decade ago, and the large
| one is a work in progress (and seems at risk of getting the
| same reception r6 did).
|
| So whether it is scheme, or whether it's an obscure project
| using the same name, kind of depends on perspective.
| mkl95 wrote:
| Thanks for the insight! Looks like some people took the time
| to flag my simple question.
| bhaney wrote:
| > all I learnt is that it's somehow related to Scheme
|
| It _is_ Scheme
| [deleted]
| jp57 wrote:
| I got involved with scheme back in the days of R{5,6}RS (as a
| user, not in the standards process). Even then it was an argument
| for the BDFL model over design by committee.
| JonChesterfield wrote:
| I wonder if the optimum is a benevolent dictator controlling
| the language and committee controlling the associated library.
| The community is then a sort of third ring of library
| evolution.
|
| Inconsistency is more expensive the closer to the language
| definition it arises as the blast radius is wider.
|
| Compromises and redundancy are more valuable in the library
| layer.
|
| Lisp blurs the lines somewhat but it's usually possible to
| subdivide a system into a core and stuff built on that core.
| patrickmay wrote:
| R4RS was a gem. Let's revert.
| eweise wrote:
| Disappointed. Thought I was going to see a resignation letter
| shaped like a large chair.
| hinkley wrote:
| I hate that the world sometimes requires a human sacrifice in
| order for change to happen. I can empathize with people that say
| this is a stupid way to fix a problem, but unfortunately the
| world is full of stupid things that actually work.
|
| On one project, we had a horrible integration test system that
| required a human to read and interpret the output. The guy who
| wrote it made his own DSL. As we struggled with it, he noped out
| and left the project. The next guy had partly the right idea. He
| figured out how to translate the whole thing into Python with a
| couple of macros. So at least you could step through it. Then he
| noped out. Since I do a lot of CI/CD work and my primary goal on
| the project had already been fulfilled, I took over. What a mess.
| I made it better but I still couldn't nail down pass/fail
| statuses reliably. Pointless system.
|
| I kept harping on how we needed to throw out the whole thing. It
| was a false sense of safety at best. When I left to work on
| something closer to my life goals, at the very last big meeting
| one of my people I'd been mentoring said, "The last 3 people to
| leave this team worked on this one project. Maybe we should get
| rid of it." and everyone started nodding. Son of a bitch.
|
| Now, I wouldn't have stayed anyway, but someone else might have.
| I've seen other situations like this play out, and while there's
| always gonna be someone who 'takes their ball and goes home',
| often enough it's someone reasonably determining that they cannot
| or will not be responsible for the chaos represented by Option A
| over Option B. This will burn down, fall over, and sink into the
| swamp.
| [deleted]
| ansible wrote:
| What's the overall Scheme community look like these days? How
| much are new libraries targeting the specifications (like R6RS)
| vs. just targeting a specific implementation like Racket, Guile
| or Chicken Scheme?
|
| What forces are keeping the various implementations aligned and
| moving in the same direction? What is driving them apart? What
| does the future look like?
| munificent wrote:
| I'm just watching this as an observer, but I suspect a lot of
| it is:
|
| People who want to write real-world Scheme code have a strong
| incentive for a single definition of the language so that their
| code will reliably run on multiple implementations. They want
| one language and are probably willing to deal with some
| breakage in places where implementations are alreaday
| incompatible in order to get there.
|
| People who maintain Scheme implementations want backwards
| compatibility so that they aren't forced to rewrite a bunch of
| already working implementation code or try to support multiple
| different languages at the same time. They don't want to make
| breaking changes to their implementations and break all of
| their users in order to converge towards some other
| implementations' behavior they may not care about.
|
| Teachers want a language that is maximally elegant and minimal.
| They are perfectly happy to make tweaks to the language to make
| it incrementally cleaner even if it breaks tons of existing
| code because most of their code is short-lived anyway.
|
| Reconciling these very different incentives does not sound fun.
| tptacek wrote:
| It'd be neat if someone familiar with Scheme standardization laid
| out some of the big disagreements in R7RS-large, or else most of
| this thread will just be a Scheme vs. Every Other Language
| discussion.
| bloppe wrote:
| I've been trying to get up to speed myself. It seems like the
| best way is simply reading the mailing list and checking out
| the codeberg issues. This issue [1] was given as an example of
| a non-technical problem that's easy to get distracted by when
| most of the core technical work should be straightforward. It's
| referenced in this candidacy statement [2] for John's chair
| position which is a good read to understand what's happening.
| It's essentially the classic language debate of breaking
| compatibility with past version versus evolving the language,
| and seems pretty complicated. I'm sure there are other
| problems. I'm still reading.
|
| [1]: https://codeberg.org/scheme/r7rs/issues/126 [2]:
| https://groups.google.com/g/scheme-reports-wg2/c/TUbmlPY9lR0
| merlincorey wrote:
| The second link provided here has a little overview of
| Daphne's thoughts on why things are dragging on:
|
| > The establishment of the central issue tracker is, I
| reckon, more to blame for the current disputes. The old model
| of periodic ballots provided the community with focus; the
| issue tracker has the problem that, since all currently
| outstanding problems are listed in one place, any such
| problem can become a focus of attention at any time, and then
| arguments about the details of that problem erupt. John has
| observed in #scheme that the more into detail we get, the
| more we seem to argue, which seems accurate. It has also, in
| practice, become a place where issues related to the
| Foundations only are discussed, and work on the Batteries has
| mostly stalled. Mea culpa!
___________________________________________________________________
(page generated 2023-08-17 23:01 UTC)