Threads for tinsnail

  1. 2

    Gonads is a real word that has nothing to do with Go nor monads, and I can’t decide if I think this was intentional or not.

    1. 3

      Mara: What is that package name?

      Cadey: It’s a reference to Haskell’s monads, but adapted to Go as a pun.

      Pretty sure it’s intentional 😉

      1. 1

        possibly a reference to a talk by someone who didn’t know what they were talking about

    1. 4

      This is one of my biggest gripes with rust. I wish the author(s) would also consider adding an executor in std as a possibility (merging smol for example?)

      1. 4

        Making one executor the “blessed official” one would be a little divisive, especially as different ones have different design goals. The other reply asking why not another executor is a perfect example of this.

        One of rust’s official design goals was to avoid the ossification of the standard library, by leaving big things like this out of it. We are definitely suffering the unfortunate consequence of that: fragmentation in areas where interop is hard.

        Standardizing on an interface and keeping that in the stdlib would ideally let us have the best of both worlds.

        1. 3

          Making one executor the “blessed official” one would be a little divisive, especially as different ones have different design goals

          It makes sense, given that one of Rust’s foundational pillars is “abstraction without overhead”. Any concrete executor is unavoidably specialized to particular class(es) of workload, and will unavoidably impose overhead for others. That’s inherent complexity to the domain.

          Following from that, and alas, I’m afraid that

          Standardizing on an interface and keeping that in the stdlib would ideally let us have the best of both worlds.

          is essentially impossible. I think any abstraction sufficiently general to support even the existing set of implementations will necessarily prevent the end-to-end optimizations that make each of those implementations suitable for their use cases. Exectors aren’t, like, JSON parsers, or regexp engines; effective parallelism requires deep integration with the full language stack.

        2. 4

          If smol was merged, then many Rust projects would still replace it with tokio. You’d still have fragmentation, dependencies, and keep explaining to users unhappy with async Rust’s speed/features that std is not the best option. Or if std merged tokio instead, then you’d have a similar talk with microcontroller people who say Rust’s async is too bloated. In browser WASM you have no choice but to use browser’s runtime. In GUI applications you’d rather use the GUI event loop as your executor, not a custom runtime.

          One-size-fits-all runtime together with std’s promise of never making any breaking changes ever, is a recipe for being stuck with a deprecated sub-par solution.

          1. 1

            . . . a recipe for being stuck with a deprecated sub-par solution.

            For some workloads, sure. Is there a runtime that would best serve the needs of the majority of Rust users? Honest question!

            1. 6

              For most users evidently tokio works fine.

              But keep in mind that Rust in general targets a minority of users not served well by more popular languages — for most programs using a garbage collector is fine. So in this case I’d also be concerned that even though for most users tokio is fine, it’d leave out an important minority that really really needs something else.

              1. 2

                (FWIW: I’m one of the original project members of async-std)

                I would say async-std, smol and tokio all serve the needs of the majority. The reason for that is that most users are interested in the execution model, but are not using it that strongly that all of the small details matter.

                From the async-std side, we do see users picking async-std over tokio though for performance profile reasons (tokio is better tuned for latency, async-std better to throughput - note that this is reported on their workload).

            2. 1

              I hear really great things about smol but was also wondering why not async-std? That also seems really capable, no?

              1. 2

                From what I understand async-std and smol both use async-executor. I believe async-std is effectively a wrapper around async-io and blocking, which smol encourages you to use directly. Both were developed by the same person.

            1. 3

              This feels very similar to my experiences at a large software company. A million teams with vast, overlapping and frequently changing areas of ownership, resulting in nobody having the time to spend on any project.

              1. 8

                I completely moved from vim/neovim to vis, very satisfied.

                1. 13

                  I ended up moving off Vis because of the lack of Language Server support. For Rust development, that’s the difference between a ~5s feedback cycle and a ~200ms feedback cycle.

                  Likewise, though it’s syntax highlighting system is simple, it is pretty bad for Ruby, where every variable ends up highlighted like a method name (since it’s impossible to tell the difference). Turn that off, and method signatures aren’t highlighted anymore.

                  1. 10

                    There’s also helix which I think is shaping up rather nicely.

                    1. 2

                      This looks really nice. I’m definitely going to check it out. Thanks for mentioning it!

                      1. 1

                        How does Helix compare to Kakoune?

                    1. 3

                      Shopify doesn’t support Git.

                      This isn’t really correct. See their docs on Github integration.

                      That is nice and all, but one thing that bothers me is that Shopify doesn’t minify the code for you. The same goes for JavaScript.

                      Shopify does automatically minify assets when they are served, including CSS and JS.

                      1. 2

                        Didn’t know that. I’ll take a look and edit the article. Thank you!

                        1. 2

                          Happy to help!

                      1. 7

                        I quite like the writing style. It reminds me of Aphyr’s “Technical Interview” series.

                        1. 3

                          Yes, and it does a pretty good job of being fun without getting in the way. I love that we have another emergent flavour of whimsy in our field, alongside the Hacker Koans from the older generation.

                        1. 25

                          A quick, rough timeline:

                          • 2005: git is released, and Junio Hemano becomes the core maintainer
                          • 2008: the first thread about staging on the linked article, and, GitHub is formed
                          • 2021: 13 years later, this is still a thing

                          There’s something about “we can’t change this, what about all the people using this” in the early days, becoming an issue for far far longer and for far many more people, that feels like a failure mode.

                          1. 31

                            I’m reminded of the anecdote about make: Its original author used tab characters for indentation in Makefiles without much thought. Later when they decided to add make to UNIX, they wanted to change the syntax to something more robust. But they were afraid of breaking the ten or so Makefiles in existence so they stuck with the problematic tab syntax that continues to plague us today.

                            1. 12

                              Your comment reminds me of the origin of C’s confusing operator precedence rules:

                              Eric Lippert’s blog post “Hundred year mistakes”

                              There were several hundred kilobytes of existing C source code in the world at the time. SEVERAL HUNDRED KB. What if you made this change to the compiler and failed to update one of the & to &&, and made an existing program wrong via a precedence error? That’s a potentially disastrous breaking change. …

                              So Ritchie maintained backwards compatibility forever and made the precedence order &&, &, ==, effectively adding a little bomb to C that goes off every time someone treats & as though it parses like +, in order to maintain backwards compatibility with a version of C that only a handful of people ever used.

                              But wait, it gets worse.

                              1. 18

                                I think this article includes a logical fallacy. It assumes that whatever you’re doing will be successful, and because it is successful, it will grow over time. Since it will grow over time, the best time for breaking changes is ASAP.

                                What this logic ignores is that any tool that embraces breaking changes constantly will not be successful, and will not grow over time. It is specifically because C code doesn’t need continual reworking that C has become lingua franca, and because of that success, we can comment on mistakes made 40+ years ago.

                                1. 6

                                  Sure, but this error propagated all the way into Javascript.

                                  I’m not saying C should have changed it. (Though it should.) But people should definitely not have blindly copied it afterwards.

                              2. 3

                                I’m curious why you think it is problematic? Just don’t like significant whitespace? But make also has significant newlines…

                                1. 4

                                  For me it’s because most editors I’ve used (thinking Vim and VSCode) share their tab configs across file types by default.

                                  So if I have soft tabs enabled, suddenly Make is complaining about syntax errors and the file looks identical to if it was correct. Not very beginner friendly.

                                  1. 4

                                    IIRC Vim automatically will set hardtabs in Makefiles for you. So it shouldn’t be a problem, at least there (as long as you have filetype plugin on).

                                    1. 2

                                      I always make sure to have my editor show me if there are spaces at the front of a line. Having leading spaces look the same as r trb is a terrible UX default most unfortunately have

                                  2. 2

                                    Thanks, I hate it

                                    1. 1

                                      What was the problem with tab syntax?

                                  1. 2

                                    Not just these two, but all methods. Why in the world can I not <form method="buy"> after all these years is baffling. This is a huge contributing factor to people giving up on HTTP, when browsers refuse to implement it sensibly.

                                    1. 3

                                      Assuming you mean adding custom methods to HTTP, how would a browser know which of these methods are idempotent?

                                      I don’t think the lack of custom methods harms HTTPs usage personally, though this may be because I’ve internalized a record-cetric way of modelling. I would probably implement that as a POST /products/123/purchases, or maybe PUT /products/123/purchases/<transaction_id>

                                      1. 4

                                        No custom method is idempotent, basically. That’s the only safe way

                                        1. 1

                                          Provide an attribute on the form which tells the browser if the request is idemptotent.

                                          A POST can be idempotent too, but the browser assumes it is not.

                                        2. 3

                                          This feature would contradict the basic design principles of HTTP. The spec has this to say on the HTTP verbs:

                                          HTTP was originally designed to be usable as an interface to distributed object systems…

                                          Unlike distributed objects, the standardized request methods in HTTP are not resource-specific, since uniform interfaces provide for better visibility and reuse in network-based systems [REST]. Once defined, a standardized method ought to have the same semantics when applied to any resource, though each resource determines for itself whether those semantics are implemented or allowed.

                                          Fielding also addresses this point:

                                          The central feature that distinguishes the REST architectural style from other network-based styles is its emphasis on a uniform interface between components (Figure 5-6). By applying the software engineering principle of generality to the component interface, the overall system architecture is simplified and the visibility of interactions is improved. Implementations are decoupled from the services they provide, which encourages independent evolvability. The trade-off, though, is that a uniform interface degrades efficiency, since information is transferred in a standardized form rather than one which is specific to an application’s needs.

                                          That is, the basic idea is that every application has resources, identified by URIs, that you interact with via this tiny set of very general verbs. The specifics of your application are not defined by adding custom verbs, but by custom media types. This article walks through a simple example of doing this.

                                          A whole world-view is implied here: The world is made up of resources, each with a canonical location. You can view them, create them, update them, and delete them. Want to log in? Wrong. You are actually creating a new session resource. Want a refund on your purchase? Create a new refund request resource. It is a noun-centric world view.

                                          The merits of this design are debatable, of course, but understanding the intention will at least make things less confusing, and you don’t have to wonder why this feature hasn’t been implemented yet.

                                          1. 1

                                            The noun-centric worldview is precisely why GET and POST are insufficient. There are things you can do with a resource besides get it or create it.

                                            1. 2

                                              This is still verb-think :)

                                              As another poster mentioned: In your example, you don’t buy something – you create a new purchase resource (or order, or whatever). Yes, this is unnatural. It clearly doesn’t click for most people. Probably it was not the best design. Still, it is absolutely fundamental to the principles of REST and HTTP, and I think it’s easier to just embrace it. I don’t think it’s going anywhere.

                                        1. 2

                                          So what is then the go-to for that ? Easy device aware frontends that use REST APIs without bootstrap that actually look good and not like some bare HTML stuff from the 2000s ? I just want to throw the logic inside, not hire a frontend dev for my hobby projects. QT frontends feel easier..

                                          1. 2

                                            Writing HTML and CSS, maybe using a CSS framework (other than bootstrap if you prefer). Using JavaScript fetch() calls when you need to contact an API.

                                            If you weren’t writing CSS with a React site, then you are already using a CSS framework just via React components.

                                            1. 2

                                              using a CSS framework just via React components

                                              which is something you’ll do sooner or later, as you reach reactive components that need JS to run (date pickers, search bars with dropdown etc). At which point you’ll throw your hands in the air trying to marry the bootstrap code with your react render pipeline.

                                              1. 2

                                                For teams of a significant size I’m sure this is the case, it’s been a while since I did frontend development in that context.

                                                I still believe it’s entirely possible to write those yourself if needed though, or to bring in React for only a few elements on the page. People made interactive websites before React, of course 😅.

                                                Is my position the most practical? Maybe not. I prefer avoiding react as a first choice because I think that it encourages not understanding the software you are writing.

                                          1. 7

                                            The commit says it’s an experiment so I don’t see what the problem is. And I wouldn’t expect Google to create a new OSD spec and involve all search engine providers for something they’re only experimenting with.

                                            1. 34

                                              I don’t think “experiment” is a magic word that lets you blatantly create unfair advantages for your own services. Anti-trust law doesn’t (as far as I know) have an “experiment” exception.

                                              1. 1

                                                I think if Google was experimenting by suddenly getting all Android phones to automatically connect to search engines, they’d be blamed too.

                                                1. 9

                                                  This could also have been an opt-in behavior on the search engines side, though. Perhaps a non-standard header or meta tag.

                                                  1. 2

                                                    but at least it wouldn’t be potentially illegal.

                                                    anyway they always have the option to not implement the optimization.

                                                    1. 1

                                                      I see your point but I honestly see that as an experiment by developers who want to see if their idea makes any sense. And the best way for them to test is with the Google search engine, since they can’t reasonably start spamming other search engines with pre-fetch requests.

                                                      1. 1

                                                        what’s the relevance of it being an experiment? does it exempt them from legal or social obligations?

                                                  2. 1

                                                    From another point of view, Google by creating a spec so that other search engines would benefit from the same optimization is actually sponsoring better usability for their competition. That gives the competition an unfair advantage, because Google has actually paid for developers time when developing this feature, and competitors didn’t.

                                                    That maybe sounds like a stretch, but I fail to see why it’s an “unfair” advantage, since Google is paying for the development of Chrome. It’s like saying that Apple plays unfair because it wants iPhone to be integrated with macOS, but leaves Android behind.

                                                    Since Google is the most popular search engine, and Chrome is the most popular browser, then optimizing their interaction seems like a sensible thing to do (everything is cheaper and faster). And if competition doesn’t want to stay behind, they should negotiate with Google to be included in the idea.

                                                    1. 10

                                                      That’s exactly not how it should be. First of all, Google paid for additional developer time to add to the general “connect to the default search engine” feature a “but only if it’s our search engine”. So the point is not valid here. Also Google and Chrome are not part of a closed eco system. So the Apple iOS example doesn’t work either. And the whole “they paid for it, so why would they allow competitors to benefit?” is a very short sighted idea. Imagine Google and big companies would generally be allowed to use their their power and money to make everything a closed system that only works with their own services. We would be back to the dark ages of the web, aka the nineties, where Microsofts IE was the driving force.

                                                      And in case you need another point of few: Google, as well as most if not all IT companies benefited a lot from Open Source software and contributions. The kind of software eco system Microsoft wanted to crush back in the days. Without those, Google, their competitors and most of todays IT companies would not be feasible. If course they don’t care. They take what they can take and make the best possible profit out of it. This is why we need laws that make competition fair.

                                                      1. 1

                                                        I don’t really like entering such response-to-an-argument debates, because they tend to never end, but here goes.

                                                        “but only if it’s our search engine”. So the point is not valid here.

                                                        It’s cheaper for them to only care about their search engine; they can actually measure how this feature affects their expectations and then pull out the functionality without anyone complaining about it. Also, if a bug pops out because this function doesn’t work with DuckDuckGo, but it still works with Google, then who should fix it? Should it support Yandex, Baidu and Ecosia? Should it support your own search engine? Should Google hire additional support people for this function alone? Who should create documentation for it? What QA team should deploy testing for it? Suddenly this function starts to be bigger (and more expensive) than initially thought.

                                                        Also Google and Chrome are not part of a closed eco system. So the Apple iOS example doesn’t work either.

                                                        Well, it’s really popular, and there’s no alternative with a similar quality for it, but I don’t think it makes it “public”. Can you extend google.com or use it somehow differently than it’s sold by Google? You can take Chrome and extend it, but that just means that it’s possible to implement this functionality on one’s own (in a fork).

                                                        Imagine Google and big companies would generally be allowed to use their their power and money to make everything a closed system that only works with their own services. […] This is why we need laws that make competition fair.

                                                        They do it all the time. If not in the products themselves, then with lobbying and with “buying laws” that make their life easier and pose problems to the rest. And then people can’t have nice things, because legally they’re not allowed to, only big corporations can.

                                                        And in case you need another point of few: Google, as well as most if not all IT companies benefited a lot from Open Source software and contributions.

                                                        I would argue that if an open source project declares its license as BSD, but has a different idea how it should be used, then I think it simply has applied the wrong license. You can’t say “you can do everything with the code”, but at the same time have some expectations that result in a situation that some people are using the code “in the wrong way”. State it in the license and the problem will go away.

                                                      2. 7

                                                        The key for me is that much like Internet Explorer before it, Chrome is essentially a pit into which Google throws huge amounts of engineering resources in order to ensure it controls the direction of the entire browser market. There’s little to argue that Chrome brings in any revenue at all for Google in of itself as a product - it exists to dictate the direction of web standards and to provide a vehicle which guarantees the continued dominance and tight integration of Google’s Search.

                                                        It really can’t be understated just how much engineering is continuously going into Chrome. Microsoft couldn’t keep up with Chrome’s release cycles and feature additions. Firefox is continuing to haemmorhage market share due to its increasing inability to keep up with Chrome. Safari is always behind in standards support compared to Chrome and that’s considering they often decline to support more complex features at all (though, like many others, I suspect they could if they weren’t more interested in preserving their App Store hegemony). Google won’t stop until it burns out or crushes what’s left of Firefox, and I imagine it will be deeply interested in lobbying efforts to “crack” iOS too.

                                                        1. 5

                                                          Unfairness is ill-defined, but here it seems to be a proxy for what should be forbidden by anti-trust law. Those laws are specifically designed to curtail actions that would be the “sensible thing to do” for a company with monopolistic powers. Do you reject anti-trust altogether?

                                                          1. 1

                                                            The thing is that I trust governments even less than I trust corporations. And with corporations at least I know they are driven by profit, which makes them more predictable. With governments, the politics are just hidden deals between powerful people. So if a government wants to control the market, then the first question I think of is who will control the government.

                                                            1. 3

                                                              It probably would save time to come out and say that you don’t believe in anti-trust, so that people can recognize that there is a more fundamental disagreement rather than some other confusion.

                                                              1. 2

                                                                I have never been allowed to vote for the chairman of a corporation.

                                                      1. 4

                                                        Can the tracking not be disabled in the application’s preferences menu?

                                                        1. 34

                                                          It is in fact disabled by default. This whole thing has been full of misinformation from what I’ve seen. A popular post was claiming the new versions recorded you through your microphone. Others said it would phone home if it saw you editing copyrighted audio.

                                                          1. 31

                                                            This entire affair brought out the worst in the community. I’m embarrassed by it.

                                                            I only read the CLA discussion some time ago, and it was horrible. The entire reason they wanted a CLA in the first place is to have some more flexibility in licensing: GPL2 is incompatibility with GPL3 and provides practical problems, and it prevents redistribution on e.g. Apple platforms.

                                                            That this is an organisation that has built their entire business on GPL3 software should give them some benefit of the doubt. But nope! Random conspiratorial nonsense all over the place.

                                                            Like most projects of this kind the people actually working on it are very few: 169 in the last 11 years (the furthest back the git repo goes), and this includes all the trivial “typo fixes” and such. The meat of the work is done by just 15 people or so, with most of it concentrated in just three. And all of the people who actually did the work actually signed the CLA.

                                                            You have people commenting “I will not be contributing any code under those terms” or “I think most contributors will not be okay with this, can say so for myself right now” and you check, and they have not contributed a single line of code. What the hell are you talking about? You’re not contributing code already. In that entire discussion I could find only two people: a translator who threatened to remove their translations (which you can’t do…), and someone who made some substantial contributions in 2010-2011 who had a nuanced in-between position.

                                                            The rest: just random people from the internet on a horse so high they need a space suit.

                                                            It’s kind off ironic that the fork got “raided” by 4chan because something not too dissimilar happened to Audacity.

                                                            1. 2

                                                              I only read the CLA discussion some time ago, and it was horrible. The entire reason they wanted a CLA in the first place is to have some more flexibility in licensing: GPL2 is incompatibility with GPL3 and provides practical problems, and it prevents redistribution on e.g. Apple platforms.

                                                              The project seems to be licensed under GPLv2 or later; wouldn’t that clear up any issues with GPLv3 compatibility? Also curious about the issue with Apple platforms: GIMP is GPL and works on Macs, so there is probably some nuance here.

                                                              1. 2

                                                                The project seems to be licensed under GPLv2 or later

                                                                It’s not.

                                                                1. 6

                                                                  Someone might want to tell them that, as their readme has said otherwise for (at least) the last 12 years:

                                                                  https://github.com/audacity/audacity/blame/master/README.txt#L48

                                                                  1. 2

                                                                    The LICENSE text has just GPL 2 and there are no file headers, so 🤷 Lawyers can argue which one “applies more”, but probably best to avoid that.

                                                                    Either way, the entire effort seems to be in good faith. I see no reason to doubt it.

                                                                    1. 8

                                                                      It’s not permissible to alter the GPL itself and still call it the GPL, so putting the “or later version” text in the statement of license in README and/or source files has been the long established practice. If there is some legal challenge to that, it would likely invalidate the intentions of many projects that use that. You’re right that’s a question for the lawyers if it comes to that, but my gut feeling is that they pretty clearly did exactly what people do when they intend to allow later versions, so would expect that to be the default interpretation.

                                                                      I haven’t followed this enough to have any clear sense of whether I’d consider what’s happening “in good faith,” but I certainly don’t assume that when companies swoop in to pay a bunch of money to acquire a community run project rather than working to establish/improve the existing governance.

                                                                      1. 3

                                                                        putting the “or later version” text in the statement of license in README and/or source files has been the long established practice

                                                                        It’s more than that - it’s described in section 9 of the GPL[v2] itself, which is what gives those READMEs force.

                                                                        Agree that it’s unclear for Audacity in particular since different pieces of texts seem to be saying different things. I’m not at all familiar with this project, but the LICENSE.txt appears to explicitly indicate “version 2” with no “or later” clause for the last four years. Applying section 9 of GPLv2, prior to that point the user could have chosen GPLv3, but this change appears to negate that intention. https://github.com/audacity/audacity/blame/master/LICENSE.txt

                                                                  2. 1

                                                                    If the CLA discussion was based on that premise, it certainly would be horrible.

                                                                2. 2

                                                                  “I only read the CLA discussion some time ago, and it was horrible. The entire reason they wanted a CLA in the first place is to have some more flexibility in licensing”

                                                                  I don’t blame people who see this as hostile. What a company did yesterday is not a guarantee for tomorrow. Maybe MuseScore is staffed and owned entirely by people who are pure of heart and have nothing but the best intentions towards FOSS. It’s a company that can be acquired by another company at some point with less Good Intent. CLAs like this should be treated as radioactive.

                                                                  The CLA says that you grant MUSECY SM LTD “the ability to use the Contributions in any way” which is not just flexibility, that’s “we can take this and distribute it as proprietary software.” If they only wanted flexibility to re-license under more acceptable FOSS licenses they could have written the CLA that way. Never sign a CLA or any legal agreement based on the assumption that the other party will Do The Right Thing. Assume that the other party is going to do any and everything the contract allows. In this case that would include deciding at some point in the future that they’re going to make Audacity closed source or open core or whatever.

                                                                  “And all of the people who actually did the work actually signed the CLA.”

                                                                  I wonder, did the people in question get paid for signing over this work? It might have something to do with their willingness to do so. (I’m not saying it’s bad for them to be paid. I’m happy to see people get paid for work on FOSS. But if we’re pointing to their signing the CLA as a justification for its goodness, it’d be good to know whether there was compensation for it or not.)

                                                                  Yes, people on the Internet who haven’t contributed also have opinions about it. Users do have an interest in the direction that Audacity takes.

                                                                3. 1

                                                                  @proctrap said that the crash reporting is opt-out, not op-in. Can we get some sources in here?

                                                                  Also worth pointing out that Audacity does in fact record you through your microphone. A link to the post would make it possible to evaluate whether it was malicious misinformation, or a joke.

                                                                  1. 9

                                                                    Here is the original telemetry PR - the original implementation was opt-in.
                                                                    Here is the followup to address the public reaction to #835

                                                                    • They changed their plans to use 3rd-party data collection and moved to self-hosting
                                                                    • They plan to introduce a dialog box on non-fatal errors where you can choose to send an error report
                                                                    1. 2

                                                                      Ignore me re: opt-in vs opt-out. I don’t have time to verify either way, but I had seen that correction posted several times elsewhere. And yes, I realize this is me doing what I complained about.

                                                                      Re: the microphone, this is mostly bad phrasing on my part. The author has since deleted the tweet, but from memory it was roughly “PSA: If you don’t want Audacity to send your microphone input to their new owners then don’t upgrade to 3.0.”, followed by a link to a news article. It had >2,500 retweets some time yesterday. The author later admitted in a reply that they made that up.

                                                                      1. 7

                                                                        The opt-in is just in the telemetry PR, in the PR description, in big bold letters. It’s not hard to verify. In fact, it’s quite hard to claim anything else.

                                                                1. 3

                                                                  I understand the appeal, and certainly would like more plain HTML/CSS websites around, but this doesn’t resonate with me.

                                                                  Part of what I like about Gemini is that it has aspects of a creative art project, quaint in it’s artificial limitations.

                                                                  As well, Gemini is new, and shows that we can move forward with the lessons we’ve learned. Restricting yourself to specific outdated versions of HTML etc just strikes me as regressive.

                                                                  1. 19

                                                                    Multiple of these are just the standard “I don’t understand floating point” nonsense questions :-/

                                                                    1. 5

                                                                      That doesn’t explain why a script language uses floating point as its default representation, let alone why that is its only numeric type.

                                                                      1. 4

                                                                        JavaScript has decimal numbers now fwiw, though I agree. Honestly I’ve been convinced that IEEE floating point is just a bad choice as a default floating point representation too. I’d prefer arbitrary size rationals.

                                                                        1. 2

                                                                          Arbitrary size rationals have pretty terrible properties. A long chain of operations where the numerator and denominator are relatively prime will blow the representation up in size.

                                                                      2. 5

                                                                        Indeed, same goes for the octal notation question (010 - 3 = ?)

                                                                        1. 7

                                                                          tbh the 010 octal format IS pretty awful. I don’t know what they were thinking putting that in C.

                                                                          1. 5

                                                                            well at least JS users have 0o10 - 0o5 now, if they find leading 0 octal notation to be confusing.

                                                                            1. 3

                                                                              Thanks for note, wasn’t aware of the ES2015 notation and MDN is helpful as always.

                                                                            2. 4

                                                                              I mean if you want fun 08 is valid JS, and that’s absurd :) (it falls back to decimal, nothing could go wrong with those semantics)

                                                                              1. 3

                                                                                Amusing, I’ve seen people write PHP with leading 0s before. Newer PHP rejects if there are invalid octal digits - fun! Putting the leading zeroes is common for people used to i.e COBOL/RPG and SQL; business programming where they’ve never seen C.

                                                                            3. 2

                                                                              really? only like ~5 of the 25 appeared to be floating point releated: 0.1 + 0.2, x/0 behavior, 0 === -0 and NaN !== NaN. Correct me if I’m wrong. Most of them seem to be about operators and what type of valueOf/toString behavior one gets when faced with such operators. Only two I got wrong were because I forgot +undefined is NaN and I was a bit surprised that one could use postfix increment on NaN (and apparently undefined?).

                                                                              1. 2

                                                                                Any arithmetic operation can be performed on NaN, but it always yields another NaN.

                                                                                The undefined one is a bit weird but kinda makes sense, it is indeed not a number.

                                                                                I actually think what’s weirder is how javascript will sometimes give you basically an integer. x|0 for example. The behavior makes a lot of sense when you know what it is actually doing with floating point, but it is still just a little strange that it even offers these things.

                                                                                But again I actually think it is OK. I’m a weirdo in that I don’t hate javascript or even php.

                                                                              2. 1

                                                                                i don’t see where is the contradiction there. JS numbers are IEEE 64-bit floating point numbers, so any weirdness/gotcha in IEEE floating point is also a weirdness/gotcha in JS too

                                                                                i know that many (most) languages also use floating point numbers by default, but that doesn’t floating point gotchas any less weird, maybe just more familiar to already-seasoned programmers :)

                                                                              1. 14

                                                                                It’s almost like Google is acknowledging that a browser isn’t the best place for non-trivial applications.

                                                                                1. 4

                                                                                  I have yet to encounter any GUI API (web or otherwise) that does digital typography decently. Does anyone know of one that, for example, supports the notion of a baseline grid? See also: font size is useless; let’s fix it.

                                                                                  1. 4

                                                                                    Because digital typography for the masses is a bad idea. The whole concept of showing a paper page on a screen as a canvas (no pun intended) and use typographic elements as your artist brush is intricate per se.

                                                                                    I think the average Joe would be better served with something in the lines of markdown if only it was what they first had exposure to. WYSIWYG editors have this aura of being simple and direct but their complexity explodes in your face after less than a handful of elements.

                                                                                    1. 1

                                                                                      what exactly do you mean by GUI API?

                                                                                      1. 2

                                                                                        I’m using “API” as an umbrella term. Over the years I’ve played with a variety of tools, sometimes called “APIs” or “SDKs” or “toolkits” or, in the case of the web, an amalgam of standards… which include APIs. Whatever you call them, I’m thinking of tools developers use to build software applications with graphical user interfaces (GUI). Here are some examples of what I mean:

                                                                                        • HyperCard + HyperTalk
                                                                                        • Swing
                                                                                        • Qt
                                                                                        • BabylonJS GUI
                                                                                        • And, of course, native web APIs

                                                                                        There are others that I’m curious about but am less familiar with (SwiftUI comes to mind). I’m genuinely curious to know if any of them give developers the means to lay out text using principles that have established in the graphic design world for almost a hundred years now by luminaries such as Robert Bringhurst or Josef Müller-Brockman. All of the tools I’ve used seem to treat typography as an afterthought.

                                                                                    2. 3

                                                                                      I think that’s overly pessimistic. The specific problem here is trying to embed one docment layout system in another. Few apps need to customize the specifics of eg. text layout to nearly the same extent as Google docs.

                                                                                      And though I empathize with the idea that it needn’t be this way, I haven’t found many better systems for application distribution than the web. Though maybe I really do just need to sell my soul to QT.

                                                                                      1. 6

                                                                                        Your argument about “I haven’t found many better systems for application distribution than the web” is somewhat defeated by the very nature of web browsers.

                                                                                        Google distributes an application to multiple platforms with regular automated updates. It’s called Chrome. It’s a POS memory hogging privacy abusing whore of satan, but that’s not really related to it being native or not - Google manages to push those qualities into browser based ‘apps’ too.

                                                                                      2. 1

                                                                                        But instead of knocking a few layers off the stack and starting again from something akin to the webrender part of what would have been Servo, they’re just re-inventing a lower layer on top of the tower of poop that is the DOM.

                                                                                      1. 2

                                                                                        The bit about GOTO is literally the last thing mentioned in the transcript, and that’s all it is—mentioned as being “great” without going into any real detail. Personally, I think it sounds horrible, but since it’s not described much past the concept, I can’t say for sure.

                                                                                        1. 2

                                                                                          They are referring to Algebraic Effects, which are something like goto or call/cc and are getting a lot of attention on the PL community atm.

                                                                                        1. 14

                                                                                          Nobody else is going to mention how incomprehensively idiotic it is that browsers allow JavaScript to fuck with the OS clipboard like this?

                                                                                          1. 5

                                                                                            I don’t find it incomprehensively idiotic to allow a whole class of web applications to be possible. Any native app can “fuck with the OS clipboard” like this, so this theoretical attack can come from anywhere. Shells should (and, in some cases, seem to) be smart enough to not auto-execute on paste, without the user’s confirmation or permission.

                                                                                            The web is a relatively secure runtime for a lot of software that covers a lot of real needs for a lot of people.

                                                                                            1. 5

                                                                                              incomprehensively idiotic

                                                                                              That seems a bit unnecessarily inflammatory. “Click here to copy this text” is a feature that tons of people use and enjoy.