1. 1

    Finishing the first working implementation of a small fzf/fzy replacement in Zig with a better fuzzy matcher. Also pushing the boundaries of Zig’s comptime and inevitably running into more compiler bugs :) Then some hiking and practicing for a piano accompaniment.

    1. 1

      Why is the case so large but empty?

      1. 4

        There’s a lot of reasons. You need something big enough to hold both the innards and the various probes and wires for a logic analyser. Some modules start out as breadboard prototypes before being integrated on the main PCB, so you may need to house both the innards and a breadboard. During early development, you need buttons that are easy to reach and easy to press, with contacts that are easy to connect to signal generators, even if the actual product has small buttons, because you are going to press them damn buttons thousands of times and stress-test everything with a signal generator that presses buttons hundreds of times per second before you get IRQ handling right. That’s why the wheel is about as big as the whole iPod. Boards slip out easily when they’re held in place by duct tape (you can’t screw them in place because sometimes you need to flip them over for legit purposes, like reaching a test pad), and you want something that’s big enough to allow for some slippage without falling onto something metallic on someone’s desk and accidentally shorting the board.

        This is a pretty late prototype so some of these reasons are less obvious, but – obviously, depending on what route each development team takes and so on – earlier prototypes tend to make these things look far less empty. I’ve worked on things that ended up slightly larger than a VHS tape but started out in a box big enough to take up half my desk.

        Edit: just a few additional notes because I just know these are gonna pop up :-D.

        1. Dogfooding: yes, it’s a valid concern, but if you start doing that too early, all you get is angry developers who have to press tiny buttons while being careful not to accidentally short teenie-weenie 0402 SMDs with their fingers. Some development has to happen before you can dogfood some things. Managers who insist on doing it as early as technically possible aren’t visionary, just clueless.

        2. Obscuring hardware details to software teams and vice-versa: first of all, there’s only so much you can obscure before making development literally impossible – e.g. the people doing the UI need to know how big the screen is, for example, not to mention that the people doing the hardware need to know how big the screen is and where the buttons are. If you give the former a box that has a spinwheel and four buttons and a screen yay big, it’s not that hard to put two and two together and get a basic set of specs.

        What the author most likely meant to say by this:

        It also has the Jobsian side-benefit of keeping the engineers in the dark about what the final device will look like.

        is IMHO that it had the side-benefit of allowing people to work on the software while minimising the chances of a leak about the case design. That’s obviously important for a company which uses leaks as a marketing tool.

        Second, while you can technically do this obscuring thing (albeit not too early in a project) it’s usually a very bad idea – it’s one of the ways that you get hardware which is ill-suited for the software it’s supposed to run, and slow software (that’s not even inefficient, it’s just optimised for the wrong hardware).

        A prototype like this one has the far more mundane benefit of allowing people to start working on the software way before the hardware is finished in all its details. Depending on what CPU you use, you can often start working on the software using a development board, long before the first hardware design draft, as long as you stick to the correct parts. This isn’t some Jobsian vision, it’s how embedded software has been written since practically forever.

        1. 1

          It also has the Jobsian side-benefit of keeping the engineers in the dark about what the final device will look like.

          I understood this to mean the engineers could work on hardware and software of the iPod without risk of them leaking what the final device would look like. It’s not clear if that was the intention of the large case, or a natural side effect.

          I also expect that developing on a prototype is much more productive and inexpensive. You could swap components more easily than if it were all glued together in a tiny metal case.

        1. 3

          Programming is a broad topic (language knowledge, tooling, ecosystems, algorithm design, project architecture, etc.), but I’ll focus on knowledge of languages. I don’t have a regular practice besides just writing code as part of work, school, and personal projects.

          The way I see it, knowledge of a programming language is much like a spoken language. I read, write, and speak English daily, but I never set aside time for deliberate English practice. Yet by using English daily my skills stay strong (and I pick up new words and concepts on occasion). When writing code in C++, Python, or any other language, using it close to daily is enough for me to maintain or build my skills.

          As an anecdote, I once went about two years without programming. My first project after that was in Python. It took a days to remember everything, but my knowledge came back much faster than it took to learn it in the first place.

          So at least for me, just writing code while for a project or assignment is enough to build and maintain skills, no set aside practice needed.

          1. 1

            In one-on-one or in very small groups, I think the best choice is to teach a language that will best help the learners in their goals and interests. In larger groups or classroom settings I lean toward teaching a language that has a concept of pointers and manual memory management, but in the end I think the language doesn’t really matter.

            I’ve been a teaching assistant for my university’s intro CS class for nearly 3 years now. We currently teach C++. For the majority of the students the course is their first exposure to programming. As a teaching assistant I focus on answering student questions, so I every day I see what topics the students struggle with. Every year the biggest conceptual hurdles are functions, classes/objects, and pointers. But by the end of the semester, nearly every student figures the hard topics out.

            I started programming by teaching myself JavaScript, Python, and ActionScript, then APCS with Java in high school. It wasn’t until I took this intro C++ class a few years ago that some concepts in Java and Python suddenly made sense to me. Having an understanding of pointers and memory helped me make more sense of the higher-level languages that I had learned previously.

            I wish I had learned C or C++ sooner. I think some concepts in Python and Java would have been more clear to me had I known about memory management. But memory is only one part of programming. For understanding control flow and expressing intent in a computer language, I don’t think the programming language matters. The learners will always learn something useful about programming that will make learning their next language easier.

            1. 1

              OTOH, it wasn’t until I learned some assembly that I actually understood pointers in C.

            1. 1

              Relaxing and working on my reimplementation of Reckless Drivin’, a Macintosh game from 2000. Does anyone else remember that game? Also finally finishing up a post about some interesting things I have learned while working on it over the last year.

              1. 2

                There’s a guy on GitHub that’s managed to convince Pangea Software to release source code as CC-BY-SA-4.0.

                So far, it seems to be the following:

                • Bugdom
                • Nanosaur
                • Otto Matic
                • Mighty Mike (aka Power Pete)
                1. 1

                  Thanks for linking to this! I’ve never played those games, but the source code in those repos is a very helpful reference for what I’m doing.

              1. 17

                I tried this and it actually is pretty darn fast. Coming from completion-nvim, it’s a massive difference in speed. If only the author licensed it properly

                1. 19

                  Everything about this ‘edgy’, meme marketing reeks of immaturity – down to naming it Coq right after news of Coq realizing it probably needs a new name. While there is room on the scale for more fun/serious (no, putting emoji in the docs or CLI is not ‘fun’), I think this well overshot into gawdy and something I can’t take seriously.

                  1. 8

                    I’m not a huge fan of the copy, but it is pretty good software so I’ll judge it by that metric.

                    1. 5

                      I wouldn’t want to raise an issue or collaborate with the project though

                    2. 3

                      Very edgy. I respect the author’s choice to represent their project however they like, but it all comes across very unprofessional to me. Profanity aside, the commit log alone makes me wonder about the quality of the project.

                      1. 6

                        I don’t get why professionalism matters here? This is a personal project they made in their spare time and released for other people to use if they want. There’s nothing professional about it.

                        1. 6

                          Profanity aside, the commit log alone makes me wonder about the quality of the project.

                          Ouch… I just took a look at it, and yes, I understand your reluctance… I never look at the commit log of projects to assess their quality, now I’m thinking that I should start doing that.

                          Thanks for saying this!

                          1. 4

                            I think icy’s point is a good one. If its good software, then who cares. The commit log being organized says nothing about the quality of the software. If the author is working on a thing primarily by themselves, then it doesn’t matter too much if the commit log is clean as they are the only ones that are hurt by it.

                            If the software solves a problem, then that’s a worthy reason for its existence imho

                            1. 2

                              You’re welcome! The log certainly isn’t the only indicator of project quality, but when the readme concerns me I like to check the logs.

                              1. 1

                                The r/vim sub didn’t take kindly either https://redd.it/p5931v considering it’s Neovim only and the react doesn’t inspire confidence

                                1. 1

                                  If it’s good software, isn’t that evidence you should care less about the commit log?

                                  1. 5

                                    Reading commit logs is a great first step towards contributing to the project. Whenever I’m learning how a project works, often times I’ll look at the log messages, especially when I want to run git blame or git annotate.

                                    Proper log messages not only help others, but yourself, too. I’ve forgotten a lot of the code I’ve written over the period of my hobbyist/career. I’ve needed to go back and make changes to code I’ve written. So that I can provide the best fix possible, it’s helpful to understand the “why” of a commit. The changes a commit produces the “what” and log messages (should) provide the “why”.

                                    1. 2

                                      None of that is an argument for why a chaotic commit log is evidence that a project is not good or that the software is bad

                                      1. 2

                                        That’s not the point I was making.

                              2. 2

                                Moreover… I don’t know if you understand French but “gawdy” is probably a good adjective to describe the linked video at the beginning of the readme.

                              3. 8

                                I wrote a github comment on that license issue: https://github.com/ms-jpq/coq_nvim/issues/15#issuecomment-900956033

                                Usually I don’t care too much, stuff like the WTFPL is a bit stupid but ultimately mostly harmless. But this “license” is really dangerous and could end up getting people hurt, if any part of it turns out to be enforceable.

                                1. 4

                                  Yeah this neovim completion engine has me shaking in my boots.

                                  I find it all refreshing that this guy doesn’t care about using his github as a linkedin or about people who think his license is dangerous.

                                  1. 2

                                    Are you making fun of the idea that giving up your rights to sue anyone ever can be dangerous? I don’t think I’m understanding you.

                                    1. 3

                                      Interpreting this as “can’t sue for any reason ever” should definitely and obviously be unenforceable right? If that could ever work, that’s not an issue with the license, rather that’s a huge issue with the legal system in question.

                                      1. 3

                                        I mean, I agree. It’s probably not enforceable. But I don’t know, I’m not a lawyer and neither is the author - and I’d not be willing to test it.

                                        I have a lot of confidence that the “you can’t sue me” part of the license is unenforceable, so users of software under this license are probably safe. I assume. Again, not a lawyer. But the part where the license author promises not to ever sue the licensee? I have no idea how that works in court. Could a lawyer argue that the author of the license didn’t know what they were doing so that the license he wrote doesn’t apply to himself? Are there other protections in place to protect license authors from themselves? I really, really wouldn’t want to find out if I was in his shoes.

                                        If there are any lawyers out there who could bring some clarity to this, I’d love to hear it. But the obvious practical solution is to pick a real license.

                                      2. 2

                                        Yes

                                  2. 6

                                    It has now been relicensed as GPL v3

                                    1. 2
                                      1. 1

                                        Have you compared it to coc-nvim?

                                        1. 2

                                          No. I’m using Neovim’s built in LSP.

                                      1. 8

                                        Oh, also: whatever approach you choose, you are going to also need to provide an ergonomic, performant animation API.

                                        This is where I died inside. Just no. Animations are one of the most despicable developments of recent UIs. I don’t want to keep either waiting for the computer to do its trivial jobs, or distract me in general altogether. Want to make your phone faster? Disable animations!

                                        You need to support emoji.

                                        Also no, this is a largely pointless complication.

                                        Async You do have nice ergonomic async support, don’t you?

                                        What does this even mean? Win32/X11/Qt/GTK+ are all async by their sheer nature.

                                        He’s describing an opinionated, everything-but-the-kitchen-sink approach. But a decent overview nonetheless.

                                        1. 33

                                          Complaints about animations an emoji sound very much like “old man yells at cloud”.

                                          Emoji (and generally Unicode support for more than BMP) is now an expected feature of modern software.

                                          UI animations can be done well and be helpful, and hint how UI items relate to each other spatially. It’s really weird that even low-end mobile devices have GPUs that can effortlessly animate millions of 3D triangles, but sliding a menu is considered a big effort.

                                          1. 7

                                            I’ve honestly never seen a single helpful UI animation in my life, other than spinning wheels and the likes, indicating that the application/system hasn’t frozen up completely. Instead of “click, click, click, be done”, things tend to shift into “click, have your attention grabbed, click, have your attention grabbed, throw your computer out of the window and go live in the woods”. GNOME Builder and GIMP 3 settings dialogues are spectacular examples of GNOME keeping digging its grave.

                                            One would expect the computer to be a tool, rather than a work of art.

                                            1. 19

                                              Maybe that’s just a failing of GNOME?

                                              For example, macOS has generally well-done animations that don’t get in the way. It tends to animate after an action, but not before. Animations are very quick, unless they’re used to hide loading time. There are also animations to bring your attention to newly created/focused elements. Reordering of elements (menu icons, tabs) is smooth. IMHO they usually add value.

                                              Touchscreen OSes also animate majority of elements that can be swiped or dragged. The animation is not on a fixed timer, but “played” by your finger movements, so you may not think about it as an animation, but technically it is animating positions and sizes of UI elements. Users would think UI is broken if it instantly jumped instead of “sticking” under the finger.

                                              1. 4

                                                Eh, macOS has sort of jumped the gun on animation, too. I’ve activated the “Reduce motion” for it because, by default, the transition between full-screen apps is done by having windows “slide” in and out of view. It’s not just slow (it takes substantially more time to do the transition that in takes to Cmd-Tab between the applications), it legit makes you dizzy if you keep switching back and forth.

                                                I imagine it’s taken verbatim from iPad (last macOS version I used before Big Sur was… Tiger, I think? so I’m not sure…) where it makes some sense, but I can’t for the life of me understand what’s the point of it on a thing that has a keyboard and doesn’t have a touch screen.

                                                1. 3

                                                  I can’t for the life of me understand what’s the point of it on a thing that has a keyboard and doesn’t have a touch screen.

                                                  Probably because most people will use their MacBook trackpad to swipe between full screen apps/desktops. I only rarely use the Ctrl-arrow shortcuts for that. A lot of macOS decisions make more sense when you assume the use of a trackpad rather than a mouse (which is why I’ve always found it weird they don’t ship a trackpad with iMacs by default)

                                                  1. 1

                                                    You can still cmd-tab between full-screen applications, which is what a lot of people actually do – a “modern” workplace easily gets you an email client, several Preview windows, a Finder window, and a spreadsheet. Trackpad swiping works great when you have two apps open, not so much when you got a bunch of them.

                                                    When you’re on the seventh out of the fifteen invoices you got open, you kindda want to get back to the spreadsheet without seeing seven invoices again. That’s actually a bad example because full-screen windows from the same app are handled very poorly but you get the point: lots of apps, you don’t always want to see all of them before you get to the one you need…

                                                  2. 1

                                                    These animations are helpful, and have been shown to be so. It’s not something some asshole down at Cupertino just cooked up because he thought it would look cool. Cues as to the spatial relations of things (as the desktops have an order and you use left/right gestures to navigate them) are very valuable to a lot of people, and they even let you turn them off, I don’t really see anything worth complaining about.

                                                    I mean there’s a lot of questionable things Apple is doing these days, but that’s not one of them.

                                                    1. 2

                                                      I’m not talking about desktops, but “maximized” applications (i.e. the default, full-screen maximisation you get when you press what used to be the green button).

                                                      You get full-screen sliding animations when you Cmd-Tab between apps in this case, even though there’s no spatial relations between them, as the order in which they’re shown in the Cmd-Tab stack has nothing to do with the order in which they’re shown in Mission Control (the former is obviously mutable, since it’s in a stack, the latter is fixed).

                                                      In fact, precisely because one’s a stack and the other one isn’t, the visual cue is wrong half the time: you switch to an application to the right of the stack, but the screen slides out to the left.

                                                      Animation when transitioning between virtual desktops is a whole other story and yes, it makes every bit of sense there.

                                                      and have been shown to be so.

                                                      Do you have a study/some data for that? I know of some (I don’t have the papers at hand but I can look it up if you’re curious), but it explicitly expects only occasional use so it doesn’t even attempt to discuss the “what if you use it too much” case. So it’s not even close to applying to the use case of e.g. switching between a spreadsheet and the email client several times a minute.

                                                      (Edit: just for the fun of it, I tried to count how often I Cmd-Tab between a terminal window and the reference manual after I ended up ticking the reduce animation box in accessibility options. I didn’t automate it so I gave up after about half an hour, at which point I was already well past 100. Even if this did encode any spatial cues, I think spatial cues are not quite as valuable as not throwing up my guts.)

                                                2. 9

                                                  There are many legitimate uses for animations. Yes loading spinners are one of them, unless you think that every single operation can be performed instantly. Sliding and moving elements around on mobile especially is another one. A short animations to reveal new elements after a user action can also improve the UX.

                                                  Not everything has to be one extreme or another - it’s not pointless animations everywhere, or no animations at all. When used well they can improve usability.

                                                  1. 1

                                                    Loading spinners are far from ideal though. A progress bar would be generally better so you have some idea of if it is actually still working and how far is left to go. Or anything else that provides similar information.

                                                    I’ve seen so many times when a loading spinner sits there spinning forever because, for example, the wifi disconnected. The animation then is misleading, since it will never complete.

                                                    1. 4

                                                      That’s an entirely different loading element. You can have animated progress bar. And when progress is indeterminate a spinner makes the most sense. A spinner not stopping on error is a UI bug, not a problem with the concept. If you want to get mad at bad design, how about programming languages and paradigms that don’t make you explicitly handle errors to get in this state.

                                                    2. 1

                                                      The standard way of indicating length is to say so to the user, and possibly add a progress bar, for when progress can be sensibly measured. Like adding a spinner, it needs to be done explicitly. Revealing new elements can be done responsively by improving the design–the standard way is by turning an arrow.

                                                      The notion of phones invading GUIs, as x64k hinted at, is interesting here (though not new). Transplanting things that do not belong, just because of familiarity.

                                                      Going back to the article, it said I needed to. I don’t. And still, I can make anything I desire with the toolkit, with no real change to the required effort. Except for “modern” IM, when I don’t care to implement pictures as pseudo-characters.

                                                    3. 7

                                                      One would expect the computer to be a tool, rather than a work of art.

                                                      The computers I remember most fondly all had some qualities of art in it. Sometimes in the hardware, others in the software, and the ones I like the most had it in both.

                                                      Animations are important in devices in which there is mostly visual feedback. Most computers don’t have haptics, and we often get annoyed at audio feedback. Visual cues that an action was performed or that something happened are important. There is a difference between UI animation and a firework explosion in the corner of the app.

                                                      1. 5

                                                        One would expect the computer to be a tool, rather than a work of art.

                                                        You, me, and everybody in this thread is in the top 0.001% of computer power users. What’s important to us is totally different than what’s important to the rest of the population. Most normies I talk to value pleasing UIs. If you want to appeal to them, you’re going to need animations.

                                                        1. 6

                                                          I’d argue even further that the 0.001% of computer power users also need animations. When done well, animations really effectively convey state changes in a way that speaks to our psychology. A great example is that when I scroll a full page in my web browser, the brief scroll animation shows my brain how where I am now relates to where I was a split second ago. Contrast this to TUIs which scroll by a full page in a single frame. It’s easy to consciously believe that we can do without things like animations, but I’m pretty sure that all the little immediate state changes can add up to a subperceptual bit of cognitive load that nevertheless can be fatiguing.

                                                          1. 2

                                                            I think good animations are ‘invisible’, but bad ones aren’t. So people remember the bad more than the good.

                                                      2. 3

                                                        UI animations can be done well

                                                        Absolutely. I love the subtle animations in iOS. Like when I long-press on the brightness slider to access more controls like the dark mode toggle. I’m already making an action that takes more time than a simple tap, and the OS responds with a perfectly timed animation to indicate that my action is being processed.

                                                        On the other hand, animations can be very easily abused. Plenty of examples, like today’s Grumpy Website post, show animations that hinder accessibility. I think the cases where animation goes wrong are where it was thrown in only because “it’s modern” rather than primarily as a means to convey information.

                                                      3. 15

                                                        I respectfully disagree with your opinion about animations. There are lots of times when I genuinely feel that the animation is important and actually conveys information. For example, the Exposè-style interface in macOS and GNOME is much better since the windows animate from their “physical” locations to their “overview” locations; the animation provides important context about which windows went where, so your eyes get to track the moving objects. It also helps that those animations track your finger movements on the trackpad perfectly, with one pixel of movement per tiny distance travelled across the trackpad (though the animation also has value when triggered using a hotkey IMO).

                                                        But there’s definitely a lot of software which over-uses animations. The cardinal sin of a lot of GUI animations is to make the user wait for your flashy effects. A lot of Apple’s and GNOME’s animations do fit this description, as well as arguably most animations in general. So I think a GUI framework needs a robust animation system for when it’s appropriate, but application programmers must show much more discretion about when and how they choose to use animations. For example, I’m currently in Safari on macOS, and when I do the pinch gesture to show an overview of all the tabs, I have to wait far too long for the machine to finish its way too flashy zoom animation until I actually get the information I need in order to interact further.

                                                        1. 6

                                                          Bad news, even smooth scrolling is a kind of animation.

                                                          1. 2

                                                            I’ll admit, this is an improvement in the browser. Bumping my counter to one case of a useful animation.

                                                          2. 3

                                                            What does this even mean? Win32/X11/Qt/GTK+ are all async by their sheer nature.

                                                            Not really. It is very easy to block the event loop with various other calls (including things like clipboard which like the thing said is async under the hood on X, but qt and gtk don’t present it that way). The gui thing needs to have some way for other operations to hook into the event loop so you can avoid blocking.

                                                            Not terribly difficult but still you do need to at least think about it, it isn’t fully automatic. (Even on Windows, where it is heavenly bliss compared to unix, you do still need to call a function in your loop like SleepEx to opt into some additional sync processing.)

                                                            1. 2

                                                              GTK+ does present clipboard retrieval asynchronously, see https://docs.gtk.org/gtk3/method.Clipboard.request_contents.html which contains a callback argument–that much I remember. Setting clipboard contents can be done blindly, you can have ownership snatched at any moment.

                                                              Going the way of recursive event loops requires caution that I would avoid imparting on users as much as possible, in particular because of callbacks vs state hell. Typically, this is reserved for modal dialogues, and the API user knows what they’re dealing with.

                                                              There’s also the possibility of processing the event pump selectively, though that’s another thing you don’t want to do to yourself.

                                                            2. 1

                                                              Want to make your phone faster? Disable animations!

                                                              This is generally the point of animations as a UX feature - they mask the slow operation of applications with a silly animation to keep you distracted/indicate a process is occurring. Want to notice when your app is using a jpeg to pretend it’s loaded? Disable animations!

                                                              1. 21

                                                                It’s not only that. The human visual system is very good at tracking movement, much worse at noting that a thing has disappeared and reappeared. If a thing disappears, you’ll typically notice quickly but not immediately be aware of what has disappeared. If you animate movement then there’s lower cognitive load because a part of your brain that evolved to track prey / predators is used rather than anything related to understanding the context of the application.

                                                                1. 4

                                                                  This is it exactly. The human visual system evolved in a world where things don’t instantly flicker out of existence or appear out of nothing.

                                                                2. 2

                                                                  I don’t think OP is talking about things like progress bars and spinning indicators, which are pretty legitimate everywhere, but things like “gliding” page transitions between application screens. If a framework is indeed so slow that you notice it rendering widgets, an animation API will help now and then, but won’t make that big a dent. (Edit: also, unless you’re loading things off a network, loading JPEGs cannot be a problem anymore, it hasn’t been a problem in twenty years!)

                                                                  I do think this piece could’ve been more aptly titled “so you want to write a GUI framework for smartphones”. Animations are important on touch screen driven by gestures (e.g. swiping) – gestures are failure-prone, they need incremental feedback and so on, plus nobody who’s not high on their 2013-era post-PC supply expects efficiency out of phone UIs.

                                                                  But they are pretty cringy on desktop. E.g. KDE’s Control Center (and many Kirigami apps) has an annoying misfeature, where you click “back” and the page moves out of view as if you’d swiped it. But you didn’t swipe. Regardless of what you think about animation, it’s not even the right animation.

                                                                  That’s why so many people see them as useless eye candy. If you go all Borg on it and only think in absolute terms, you get a very Borg user experience.

                                                                  Edit: yes, I know, “a modern GUI toolkit” should have all these things. The point is you can drop a lot of them and still write useful and efficient applications. Just because Google is doing something on Android doesn’t mean everyone has to do it everywhere.

                                                                  1. 3

                                                                    It’s funny you mention page transitions. I have my ebook reader set up to do a 200ms-ish animation when I tap the ‘next page’ button where the current page slides off to the left and the next one slides in from the right. It has an option to disable it, but I actually find that disorienting in this vague way I can’t explain. But on my desktop, it’s fine with no animations.

                                                                  2. 1

                                                                    Empirically, that is not how it’s used. This masking is a minority of use cases, and even then it’s bad. To some people that aren’t me, it might be better described as “eye candy” and “smoothness”.

                                                                    Being able to disable this irritation is being lucky, e.g. it’s CSS-hardcoded in Firefox and GTK+ (/org/gnome/desktop/interface/enable-animations only works partially).

                                                                  3. 1

                                                                    What does this even mean? Win32/X11/Qt/GTK+ are all async by their sheer nature.

                                                                    I think they’re talking about Rust async, since this is all in the context of writing a cross-platform GUI toolkit in Rust. This is more of a problem than it seems because if you’re doing a cross-platform toolkit that uses native widgets, it’s not at all trivial to impedance-match whatever model the native widget toolkit uses behind the scenes with your toolkit, which exposes an async model.

                                                                    (Edit: there are some additional complications here, too. For example there are toolkits that (generally) async, but still do some operations synchronously. The author mentions the copy-paste API as an example.)

                                                                    One might conclude that it’s better to not do any of that and instead expose the platform’s intended programming model, as second-guessing thirty year-old code bases tends to backfire spectacularly, but maybe I’m just being grumpy here…