Threads for river

  1. 2

    Annoying. I wanted to see what else the guy has made on github, but his profile is empty

    1. 18

      The post by the author (who I believe is a lobste.rs member) ends on a sad note. I don’t think just the publicity caused this crash in enthusiasm - I’m guessing the internet was the internet and people were unkind to them which I can totally see killing enthusiasm for an endeavor, especially if the spotlight was shone too early.

      To the author - I hope, once this 15min of hell has passed, your motivation comes back, and you keep working on it, since there must have been interesting problems in that space you wanted to solve.

      1. 21

        Generally I’d agree with this sentiment.

        But the author is known for being rather obnoxious and rude towards other projects he disagrees with, and was even banned from lobsters for this reason. So in this case I don’t feel too bad.

        1. 28

          He’s also made significant effort - and improvement! - on those fronts.

          I have first-hand experience of interacting with him on IRC, as a paying customer requesting with questions about his products. I wish all vendors were as approachable, polite, and direct as he is.

          Re. the note on his ban - I too find myself disappointed in the world (of software) at times, as do many of my friends and colleagues. I note though that few people take the step of launching our own commercial products as a means of improving it.

          1. 8

            commercial products

            commercial and ethical products

            They might be opinionated, but they are still free software. That’s really not typical nowadays.

            I have noticed some introspection, e.g. https://drewdevault.com/2022/07/09/Fediverse-toxicity.html.

            I too have issues dealing with my frustration and textual interactions don’t make it any easier. Without easily accessible peers to discuss things with, it falls to the online community to help people cultivate their opinions.

            I am thankful that many people here have the patience.

            1. 5

              They might be opinionated, but they are still free software. That’s really not typical nowadays.

              Agreed; and that’s a large part of the reason I made the switch to sourcehut from GitLab.

          2. 12

            In this case you are the one being obnoxious and rude. You don’t know the guy, don’t spread rumors and hate.

            1. 12

              I agree that it’s time lobsters moved on from this and stop bringing up DeVault’s past mistakes.

              However, this isn’t a “rumor” or “hate”. They were simply stating a well-known fact about Drew’s aggressiveness and rudeness, one which I’ve also experienced and seen others experience. (To be fair, I’ve noticed good behavior has improved a lot over the past 12 months.)

              Jeez, I really look forward to the day when lobsters can discuss Drew’s work before dragging up shit from 1 year ago.

              1. 15

                I think it certainly is hate. These comments seem a lot like targeted harassment to me. Most of the commenters don’t seem to have first hand experience with what they are talking about. They also appear whenever drew does something good which just detracts from everything.

            2. 11

              The reasons were not made public and it’s bad form to attack someone who can’t respond.

              1. 7

                Ah, I am no longer as active on lobste.rs as I used to be and I missed that Drew got banned. I just searched through his history but didn’t find the smoking gun that got him banned. Anyhoo, sad all around.

                1. 16

                  There’s some context in this thread, though it doesn’t provide an exact reason.

                  I had a long response to his Wayland rant because I think the generalizations in that post were simply insulting at best and it drove me crazy.

                  He is a clever engineer, but he has a tendency to invite controversy and alienate people for no reason. After that rant of his, I lost any desire to ever engage with him again or use his products if I can help it, which may be extreme, but after numerous similar exchanges I think it’s unfortunately necessary.

                  1. 12

                    Yeah, I’m surprised and somewhat sad. He’s difficult and abrasive sometimes, but I respect his engineering.

                    1. 3

                      im so tired of this sentiment

                      1. 17

                        im so tired of this sentiment

                        Saying you’re tired of another person’s take without giving any reason is a pretty vacuous and unnecessary comment. The button for minimizing threads is there for a reason.

                        1. 18

                          I’m also tired of the sentiment that allows someone to be shitty just because they’re good at solving a problem.

                          1. 2

                            Unfortunately (?) you can’t disallow someone from being shitty.

                            1. 7

                              One can for certain exclude them from a group of friends that you care for.

                          2. 2

                            This comment is inappropriate. I am sure that the tone and attitude here is not a fit for the community what we are aiming for on lobsters

                          3. 2

                            The opposite leads to bad engineering decisions.

                            1. 12

                              Health care and related fields have a concept of the quality-adjusted life year, which is used to measure impacts of various treatments, or policies, by assigning a value to both the quantity and quality of life. There are grounds for critiquing the way the concept is used in those fields, but the idea probably ports well to our own field where we could introduce the concept of the quality-adjusted code unit. Let’s call it QALC to mirror QALY for life-years.

                              The gist of the argument here is that while there are some people who produce an above-average number of QALCs, if they are sufficiently “abrasive” they may well end up driving away other people who would also have produced some number of QALCs. So suppose that a is the number of QALCs produced by such a person, and l is the number lost by their driving away of other people. The argument, then, is that in many cases l > a or, more simply, that the person’s behavior causes a net loss overall, even when taking quality (or “good engineering” or whatever synonym you prefer) into account.

                              My own anecdotal experience of involvement in various open-source projects is that we often drastically overestimate the “abrasive” person’s QALCs and underestimate the QALCs of those who are driven away, making it almost always a net loss to tolerate such behavior.

                              1. 5

                                I’m 100% OK with bad engineering decisions (within reason) if it means my life is more pleasant. If hanging out with brilliant assholes makes your life more pleasant, then by all means, go for it!

                                1. 2

                                  It took me 20 minutes to pay for something on my iPhone today because the app wouldn’t let me scroll down to the “submit” button, and the website wouldn’t either until I looked up how to hide the toolbar on Safari. That doesn’t make my life more pleasant.

                                  Besides, you aren’t forced to hang out with people just because they are allowed to post.

                                  1. 2

                                    By allowing them to post you allow them to hang out in your and the other users’ brains.

                                2. 6

                                  there is no tradeoff

                                  we don’t have to accept abusive or toxic people in our communities

                                  1. 5

                                    I think this mindset is what has lead to the success of the Rust project in such a short span of time. It turns out that having a diverse community of respectful individuals invites more of them and leads to better problem solving.

                                  2. 3

                                    Are you implying that only difficult and abrasive engineers do good work? Because I have personal experience of the opposite, not to speak of numerous historical accounts.

                                    1. 2

                                      No.

                        1. 1

                          There is also a simple BFS search tool I wrote https://crates.io/crates/bfs

                          Handling unicode was much more complex than I expected, since filenames may not be valid unicode.

                          1. 3

                            So what makes dimensions 8 and 24 so special? “Everybody asks what is special about dimensions 8 and 24 — I don’t know, it’s a mystery,” Viazovska told us in 2018. “In these dimensions we have these two extremely great configurations, which we don’t have in other dimensions. They are so good that methods which fail in all other dimensions, in these dimensions give a sharp estimate. If you ask me why, I don’t know.”

                            This is remarkable to me. Someone, who’s among the very best in the world in her subfield and just made a historic breakthrough, eagerly admits that neither she nor anyone else has any insight into some obvious and straightforward question concerning it. There’s so much we don’t know!

                            1. 2

                              There are some incredibly strange behaviors in higher dimensions which do not seem to have an intuitive explanation yet. Like exotic spheres, exotic R^4 and of course the leech lattice https://en.wikipedia.org/wiki/Exceptional_object#8_and_24_dimensions Another similar kind of thing is some work on 4d unknotting https://www.quantamagazine.org/graduate-student-solves-decades-old-conway-knot-problem-20200519/ There’s so much of this interesting and unique behavior that occurs in higher dimensions.

                            1. 1

                              It sounds too good to be true. So what can it do in practice?

                              1. 3

                                So in order to make your site slightly more accessible to screen readers, you’ll make it completely inaccessible to browsers without JavaScript?

                                1. 6

                                  i was born without javascript and life has been so hard for me

                                  1. 2

                                    Accessibility isn’t just about disorders.

                                    1. 6

                                      I think @river’s point is that it’s most important to accommodate limitations due to circumstances beyond the user’s control. And these are limitations that can prevent people from getting or keeping a job, pursuing an education, and doing other really important things. In all cases that I’m aware of, at least within the past 15 years or so, complete lack of JavaScript is a user choice, primarily made by very techy people who can easily reverse that choice when needed. The same is obviously not the case for blindness or other disabilities. Of course, excessive use of JavaScript hurts poor people, but that’s not what we’re talking about here.

                                      1. 1

                                        If using <details> made the site impossible to use for blind people, that would obviously be much more important, but here the complaint is that… the screen reader reads it slightly wrong? Is that even a fault of the website?

                                        1. 4

                                          Fair point. Personally, I wouldn’t demand, or even request, that web developers use JavaScript to work around this issue, which is probably a browser bug, particularly since it doesn’t actually block access to the site.

                                          On the other hand, if a web developer decides to use JavaScript to improve the experience of blind people, I wouldn’t hold it against them. IMO, making things easier for a group of people who, as @river pointed out, do have it more difficult due to circumstances beyond their control, is more important than not annoying the kind of nerd who chooses to disable JS.

                                          1. 1

                                            Well, disabling JS is not always a choice. Some browsers, such as Lynx or NetSurf, don’t support it. But yeah, I generally agree.

                                            1. 3

                                              I suppose it’s possible that some people have no choice but to use Lynx or Netsurf because they’re stuck with a very old computer. But for the most part, it seems to me that these browsers are mostly used by tech-savvy people who can, and perhaps sometimes do, choose to use something else.

                                              1. 3

                                                I suppose it’s possible that some people have no choice but to use Lynx or Netsurf because they’re stuck with a very old computer. But for the most part, it seems to me that these browsers are mostly used by tech-savvy people who can, and perhaps sometimes do, choose to use something else.

                                                And what percentage of those lynx users is tech-savvy blind people? Or blind people who are old and have no fucks left to give about chasing the latest tech? There are, for instance, blind people out there who still use NetTamer with DOS. DOS, in 2022. I’m totally on board with their choice to do that. Some of these folks aren’t particularly tech savvy either. They learned a thing and learned it well, and so that’s what they use.

                                                1. 1

                                                  Many users who need a significant degree of privacy will also be excluded, as JavaScript is a major fingerprinting vector. Users of the Tor Browser are encouraged to stick to the “Safest” security level. That security level disables dangerous features such as:

                                                  • Just-in-time compilation
                                                  • JavaScript
                                                  • SVG
                                                  • MathML
                                                  • Graphite font rendering
                                                  • automatic media playback

                                                  Even if it were purely a choice in user hands, I’d still feel inclined to respect it. Of course, accommodating needs should come before accommodation of wants; that doesn’t mean we should ignore the latter.

                                                  Personally, I’d rather treat any features that disadvantage a marginalized group as a last-resort. I prefer selectively using <details> as it was intended—as a disclosure widget—and would rather come up with other creative alternatives to accordion patterns. Only when there’s no other option would I try a progressively-enhanced JS-enabled option. I’m actually a little ambivalent about <details> since I try to support alternative browser engines (beyond Blink, Gecko, and WebKit). Out of all the independent engines I’ve tried, the only one that supports <details> seems to be Servo.

                                                  JavaScript, CSS, and—where sensible—images are optional enhancements to pages. For “apps”, progressive enhancement still applies: something informative (e.g. a skeleton with an error message explaining why JS is required) should be shown and overridden with JS.

                                                  (POSSE from https://seirdy.one/notes/2022/06/27/user-choice-progressive-enhancement/)

                                    2. 2

                                      I mean not for not, but I’m fairly certain you can constrain what can be executed in your browser from the website.

                                      I’m certainly okay with a little more JS if it means folks without sight or poorer sight can use the sites more easily.

                                      1. 5

                                        I’m certainly okay with a little more JS if it means folks without sight or poorer sight can use the sites more easily.

                                        In my experience (the abuse of) JavaScript is what often leads to poor accessibility with screen readers. Like, why can I not upvote a story or comment on this site with either Firefox or Chromium? ISTR I can do it in Edge, but I don’t care enough to spin up a Windows VM and test my memory.

                                        We need a bigger HTML, maybe with a richer set of elements or something. But declarative over imperative!

                                        1. 2

                                          Like, why can I not upvote a story or comment on this site with either Firefox or Chromium?

                                          I use Firefox on desktop and have never had a problem voting or commenting here.

                                          We need a bigger HTML, maybe with a richer set of elements or something. But declarative over imperative!

                                          The fallback is always full-page reloads. If you want interactivity without that, you need a general-purpose programming language capable of capturing and expressing the logic you want; any attempt to make it fully declarative runs into a mess of similar-but-slightly-different one-off declaration types to handle all the variations on “send values from this element to that URL and update the page in this way based on what comes back”.

                                          1. 5

                                            I use Firefox on desktop and have never had a problem voting or commenting here.

                                            Yes, but do you use a screenreader? I do.

                                            The fallback is always full-page reloads. If you want interactivity without that, you need a general-purpose programming language capable of capturing and expressing the logic you want;

                                            Sure, but most web applications are not and do not need to be fully interactive. Like with this details tag we’re talking about here? It’s literally the R in CRUD and the kind of thing that could be dealt with by means of a “richer HTML”.

                                      2. 1

                                        On modern browsers, the <details> element functions builtin, without JS.

                                        In fact that’s the entire point of adding the element.

                                        1. 1

                                          Yes, and the article recommends against using <details>.

                                      1. 1

                                        In a sense, the fundamental problem in cryptosystems is distributing, managing, and correctly using secrets (‘keys’). If we can assume perfect key distribution and key management (including use) for arbitrary sized keys, we can use one-time pads and have totally secure communications

                                        This is not true. one time pads provide perfect confidentiality but zero integrity. The reason for this is that mallory can edit bits of the data by xoring it.

                                        The shorter the secret is (without being guessable in too short a time), the more random it is

                                        No this isn’t true at all. entropy is the measure of randomness and the length of a string does not affect its entropy (it just puts an upper bound on it): what increases entropy to pick things uniformly instead of bias, and to pick things from a large pool of possibilities.

                                        Also the justification of Kerchoff’s principle is not theoretical - as this post tries to argue. It is practical. We’ve learned that this is important for real attacks throughout history. From https://blog.cloudflare.com/a-note-about-kerckhoffs-principle/

                                        A great example of this is the breaking of the Nazi German Enigma cipher during the Second World War. By stealing machines, receiving information from other secret services, and reading the manuals, the Allies knew everything there was to know about how the Enigma machine worked.

                                        Engima’s security relied not on its secrecy, but on its complexity (and on keeping the daily key a secret). Engima was broken by attacking the mathematics behind its encryption and building special machines to exploit mathematical flaws in the encryption.

                                        1. 2

                                          This is not true. one time pads provide perfect confidentiality but zero integrity. The reason for this is that mallory can edit bits of the data by xoring it.

                                          True, but with no limits on key size we can add enough bits for a random linear message authentication code.

                                          The shorter the secret is (without being guessable in too short a time), the more random it is

                                          No this isn’t true at all. entropy is the measure of randomness and the length of a string does not affect its entropy

                                          The author does not present this as an implication, these are two of the three desirables — short, random, narrowly available.

                                          Also the justification of Kerchoff’s principle is not theoretical - as this post tries to argue. It is practical.

                                          The post argues it has both practical and also theoretical justifications. And arguably the theoretical justifications proposed summarise a subset but not all of the practical justifications (which is a reasonable thing for theoretical arguments to do).

                                        1. 2

                                          Seems like a good idea!

                                          1. 1

                                            where is the calculus exam?

                                            1. 4

                                              So what do you do when editing the header? Update all pages? A sed I assume.

                                              1. 4

                                                The post mentions that it’s filled in with a bit of JavaScript. RIP you if the JavaScript fails to load, I guess?

                                                1. 2

                                                  yikes. that’s not plain HTML at all. Horrible solution.

                                              1. 1

                                                agreed. emoji should not be in unicode. it’s prescriptive rather than descriptive.

                                                1. 2

                                                  How do you mean it’s prescriptive?

                                                  1. 2

                                                    Emojis are really useful for text communication, when you want to convey feelings or emotions as a side channel to text. Besides, they’re single-handedly forcing anglo-saxon programmers to fix their unicode handling programs 🙃

                                                    1. 1
                                                    1. 8

                                                      this is just a tweet

                                                      1. 2

                                                        well, to be more specific, it’s a thread; not just the title tweet

                                                      1. -5

                                                        oh they are copying discord

                                                        1. 17

                                                          Zulip, WebEx, Discord, email, Microsoft Teams, and others have threaded discussions.

                                                          What makes this a Discord copy more than a copy of any other mentioned chat platform?

                                                          1. 1

                                                            Discord added this feature recently

                                                            1. 11

                                                              Well, threads have been on the roadmap for over a year IIRC and have been in development for months. So the timing wasn’t too deliberate.

                                                          2. 14

                                                            Did Discord invent threaded discussions?

                                                            1. 6

                                                              This comment is a bit distasteful. It’s not constructive and from my perspective insinuates that the work done is just a rip-off. Features like this are often requested from the community that find a particular pattern useful and want to see it on their platform of choice, which IIRC is why discord implemented it themselves. You could argue discord copied this from previous incarnations implemented in other services and standards but does it really matter?

                                                              Imagine if you were a developer of this feature and read this comment - how you would feel?

                                                              1. 4

                                                                After Slack introduced threads, pretty much everyone – Element, Discord, even IRC – immediately put it on their roadmap. So it’s no surprise that Element and Discord release them at roughly the same time.

                                                              1. 1

                                                                better to just have the zip and binary together in one folder

                                                                1. 1

                                                                  perhaps could have used a compression algorithm instead.

                                                                  1. 3

                                                                    You can almost always do better with a compression algorithm that’s tailored to the data than a general-purpose one and it looks as if this one reduces the size quite considerably relative to gzip (30338 bytes gzip’d vs 17871 bytes with this approach).

                                                                    The alternative approach, which is coming back into fashion now, is to use some kind of ML model and store that plus the exceptions. This is how TeX stores its hyphenation databases: they’re a map of two-letter sequences to weights and a short list of exceptions. From memory, for English, something like 70 words don’t get correctly hyphenated if you take the weights and use them to determine hyphenation points, so there’s a separate table of 70 words along side a 676 weight entry table, which lets TeX correctly hyphenate 20+K English words. It’s especially fun because the same code for generating the compressed version works with English and American, in spite of their different hyphenation rules (English rules are related to root words, American to syllable breaks), as long as you have a corpus of valid words.

                                                                    It would be interesting to see what happens if you train even something simple, like a Markov chain that generates 5-letter sequences, with the set of words in the list and then set a threshold probability where all of the words in the list are generated and include a list of all of the ones that it can generate, yet aren’t in the original list (or one that generates almost all of the required words with a list of ones that it doesn’t generate, or some combination) and see how that compares in size.

                                                                    1. 2

                                                                      Keep reading; they refer to that later on.

                                                                    1. 1

                                                                      wouldn’t you just use a pipe

                                                                      1. 17

                                                                        one disadvantage of pipes is that they’re not restartable: if the consumer fails the message is lost. that could be bad.

                                                                        another disadvantage (related to the first) is that the consumer has to run concurrently with the producer. that might make it harder to manage resources well enough to prevent consumer-failure

                                                                        another disadvantage of pipes is that they’re only atomic up to PIPE_BUF.

                                                                        another disadvantage of pipes is that in order to have more consumers than producers, the producer needs to do routing. which logfiles, the consumers can simply skip every N-1 records (where N is the size of the group).

                                                                        if these disadvantages are important, you probably should not use a pipe, but if not, there’s nothing preventing your from also using a fifo as the source for your logs (you can use cat if you want).

                                                                        i don’t recommend the approach in the article for crashproof consumption, or the message format: the message should begin with a newline (not end in one) to protect against losing the first good message (in addition to the last bad one you can do nothing about at this point). there’s too much copying there. instead there is a much simpler approach: record the position in the logfile as you make progress and restart from that position if you are (well) restarted. you can even rotate logfiles to create the illusion of one really big logfile that is perhaps easier to manage for the sysadmin, just remember to consider the filename to be part of the position.

                                                                        1. 4

                                                                          Thank you! So much great insight in this comment!

                                                                      1. 6

                                                                        Fennel being loadable from Lua, and Lua being written in ANSI C makes an interesting combination for anyone wanting to write bootstrappable software in a functional style.

                                                                        1. 4

                                                                          Aren’t many LISPs written in C?

                                                                          1. 9

                                                                            Indeed but Lua is insanely portable. They have taken great pains to depend only on what is guaranteed by C89: there are no endian dependencies, no assumptions about struct layout, etc.

                                                                            1. 5

                                                                              Yes but it’s unusual to have no dependencies beyond a C89 compiler and libc.

                                                                              1. 2

                                                                                I’m pretty sure Janst can be built with just a C compiler. And several of the numerous dialects of Scheme.

                                                                              2. 3

                                                                                Some, but most are written in Lisp, maybe or maybe not with a C core for runtime. Bootstrapping is occasionally a bit of a headache.

                                                                                1. 3

                                                                                  Most LISPs are not what I’d consider Functional. They’d support it, sure, and functions are first class, but they don’t emphasize immutability and bottom-up-creation and side-effect limiting like what I think of with functional languages.

                                                                                  1. 4

                                                                                    Absolutely true. I’ve never understood why LISP gets associated with functional. The syntax seems like it would lead that direction, but in practise most LISPs are very low level.

                                                                                    1. 2

                                                                                      Back when lisps were new, the fact that it was even possible to do functional programming at all was considered unique and novel. Having access to lambda was considered a very advanced feature. Nowadays if your language doesn’t even have closures, no one will really take it seriously, so whatever association lisp-in-general has with FP should probably be thought of as historical.

                                                                                      1. 3

                                                                                        When lisps were new, they frequently lacked lexical closures. See the ‘upwards funarg problem’.

                                                                                        1. 1

                                                                                          I may be a heretic here but I actually think lexical closures are bad, and a poor substitute for currying/partial application.

                                                                                          1. 4

                                                                                            You’ll hate Fennel then! Probably shouldn’t use it. Closures are more central to Fennel than any other language I know.

                                                                                            1. 1

                                                                                              More than other lisps?

                                                                                              1. 2

                                                                                                I haven’t used every lisp, but …

                                                                                                • much more than: Emacs Lisp, Common Lisp, Hy, LFE
                                                                                                • a fair bit more than: Clojure
                                                                                                • a little more than: Racket, Scheme (mostly due to the module system which is mostly closures)

                                                                                                Fennel has partial, but not currying, since it’s on a runtime where argument count for a function isn’t determinable.

                                                                                            2. 1

                                                                                              What is the difference between lexical closures and currying/partial application?

                                                                                              1. 2

                                                                                                With a lexical closure every term that is closed over now has to live as long as the execution of that closure, with no explicit annotation of anything about the sharing.

                                                                                                When a human reads the program they have to remember if this is a by-value or by-name binding.

                                                                                                If you want a type system that incorporates lifespans or ownership, then again you need some default rule to describe the relationship between outer and inner code, which the programmer has to remember and cannot alter.

                                                                                                By contrast, if all such sharing happens via a function call (which is to say with explicit parameter passing and type annotation) then the writing programmer can make explicit what the sharing regime is, and the reader can apply the same rules that apply when they read any other function call.

                                                                                                Obviously, you can do absolutely amazing things with lexical closures, but you can also do all those things with non-closing functions and partial application.

                                                                                                I guess I’m saying that explicit is better than implicit.

                                                                                                1. 2

                                                                                                  When a human reads the program they have to remember if this is a by-value or by-name binding.

                                                                                                  This is less an argument against closures and more an argument for making your language have consistent and sensible argument passing semantics. It’s not a problem in Fennel because the distinction between pass-by-value and pass-by-name is irrelevant.

                                                                                                  If you want a type system that incorporates lifespans or ownership, then again you need some default rule to describe the relationship between outer and inner code, which the programmer has to remember and cannot alter.

                                                                                                  Again, there are plenty of contexts where this is true, but none of this is the slightest bit relevant here.

                                                                                                  1. 2

                                                                                                    Thanks for the response, but this didn’t address the question I had.

                                                                                        2. 1

                                                                                          Yeah my knowledge is somewhat stale but at least back in the day only the very core functions were in C and the majority of the image was LISP.

                                                                                          There was also a lot on top of that core that use a foreign function interface to layer in functions from C-land like UI libraries and the like.

                                                                                        3. 3

                                                                                          Fennel & Lua seem like a great duo to be aware of. I’ve also recently learned about Fabrice Bellard’s QuickJS which is interesting for similar reasons as a simple & embeddable pure C implementation of ES2020.

                                                                                        1. 1

                                                                                          I don’t think it is good to keep inventing new languages. Wouldn’t guix or nix have worked better here?

                                                                                          1. 4

                                                                                            I see where you’re coming from, but I’m not sure that would work given the (at least implicit) contstraints. One of the goals mentioned in the original pull request (discussion) was for it to be small and self contained, thus minimising the overhead (both in terms of machine resources and brainspace) of working on the build itself.

                                                                                            Both Nix and Guix depend on an underlying runtime system (nix language and guile scheme respectively). Not only is it yet another dependency to manage, but it also means there’s more context switching overhead when moving between hacking on the build vs. hacking on the source code. Wheras Zuo is designed to be very similar to racket, and should make it easier to switch tracks.

                                                                                            Besides, build systems are fun!

                                                                                            1. 4

                                                                                              To add to crstry’s post, Nix and Guix wouldn’t work for building Racket on Windows, anyway.

                                                                                              1. 4

                                                                                                It is allways good to keep inventing new languages.

                                                                                              1. 13

                                                                                                stage1 (release) build stage2 (debug) (LLVM backend):

                                                                                                • wall clock: 47.80 seconds
                                                                                                • peak rss: 8.6 GiB

                                                                                                stage2 (release) build stage3 (debug) (LLVM backend):

                                                                                                • wall clock: 43.26 seconds
                                                                                                • peak rss: 2.3 GiB

                                                                                                That’s a nice reduction in memory usage.

                                                                                                Gives me hope that I’ll be able to build even large projects on my laptop, something I struggle to do with Rust.

                                                                                                1. 10

                                                                                                  those are some fantastic times. Not many languages have compilers that can be built that fast!

                                                                                                  1. 15

                                                                                                    The big wins are still yet to come! If you’re curious to learn more, I went over these details in the video linked by @kristoff.