1. 12

    I have to wonder whether wide-spread adoption of Java applets might have led to an outcome qualitatively better than the modern web. I mean, the Java runtime was intended to be an application platform, whereas the web is a document delivery system abused and contorted to make do as an application platform.

    1. 12

      Except we had widespread adoption of java applets and the web platform turned out to be a better application platform. On the desktop we’re running VS Code (the web platform) rather than Eclipse (Java).

      I wrote Java applets professionally in the 90s and then web apps. Even back in the pre dynamic html days native web apps were better for most interesting stuff.

      1. 4

        we had widespread adoption of java applets

        We did?

        My memory isn’t what it used to be but I can’t remember a single instance of seeing this in the wild.

        1. 4

          I recall Yahoo using these for apps/games and what not.

          1.  

            Not widespread like today where a large fraction of websites run JS on load. But I did run across pages here and there that would present an applet in a frame on the page, and you’d wait for it to load separately.

            1.  

              They were supported in all popular browsers. Java was widely taught and learned. There definitely were lots and lots of applets deployed but compared to the web they were bad for actually building the applications people wanted to use.

              1.  

                I remember quite a few. Maybe you didn’t really notice them? Even today I occasionally run across a site with an applet that won’t load, especially older sites for demonstrating math/physics/electronics concepts. It also used to be a popular way to do remote-access tools in the browser, back when you couldn’t really do any kind of realtime two-way communication using browser APIs, but you could stick a vnc viewer in an applet.

                1.  

                  Aha; now that you mention it I do remember using a VNC viewer that was done as an applet, and also an SSH client. So I don’t think I ever used a Java applet on my own computer, but I did use a couple in university when I was stuck on a Windows machine and didn’t have anything better around.

                2.  

                  Runescape Classic xD

              2. 9

                I have to agree with ianloic. Applets just didn’t work very well. They weren’t part of the web, they were a (poorly designed) GUI platform shoehorned into a web page with very limited interconnection. And they were annoyingly slow at the time.

                Flash was a much more capable GUI but still badly integrated and not web-like.

                With HTML5 we finally got it right, absorbing the lessons learned.

                1. 8

                  With HTML5 we finally got it right, absorbing the lessons learned.

                  Now, instead of a modular design with optional complexity (user installs/loads given module only when needed), we have bloated web browsers consisting of 20+ millions lines of code with complexity that is mandatory often even for simple tasks (e.g. submit a form with some data, read an article or place order in an e-shop).

                  1. 6

                    Very strongly agree.

                    Back when Flash was widespread, it didn’t seem that popular - it was a delivery mechanism for overzealous advertising that jumped all over content. People were happy to embrace the demise of Flash because Flash was a liability for users.

                    What we have today are synchronous dialog boxes that jump all over content which are very difficult to remove because they’re indistinguishable from the content itself. The “integration” has meant it can no longer be sandboxed or limited in scope. The things people hated about Flash have become endemic.

                    The web ecosystem is not doing a good job of serving users today. I don’t know the mechanism, but it is ripe for disruption.

                    1.  

                      Flash was also a delivery mechanism for games and videos that entertained millions, and educational software that probably taught more than a few people. If you think games, videos, and education beyond what flat HTML can provide are not “valid” that’s fine, but Flash filled a role and it served users.

                      1.  

                        I didn’t mean to suggest that all uses of flash are not “valid”; if there was no valid use, nobody would intentionally install it. I am suggesting that it became misused over time, which is why Steve Jobs didn’t encounter too much resistance in dropping it.

                        But the real point from franta which I strongly agree with is being a plugin model it was relatively easy for users to enable when the content really needed it, and leave disabled in other cases. Personally I had two browser installs, one with flash and one without. That type of compartmentalization isn’t possible with HTML5.

                    2.  

                      Optional complexity is not the right choice in this context. Nobody wants to design an experience where most users are just met with complex plug-in installation instructions. One of the best parts of the HTML5 ecosystem is that it’s largely possible to make websites which work on most of the browsers your users are actually going to use.

                      I agree that the complexity of “HTML5” is a problem. Maybe it would be nice to have two standards, one “simplified” standard which is basically Google’s AMP but good and standardized, and one heavy-weight standard. Simpler websites like news websites and blogs could aim to conform to the simplified standard, and simple document viewer browsers could implement only the simplified standard. But it definitely 100% wasn’t better when the “web” relied on dozens of random proprietary closed-source non-standard plug-ins controlled by single entities with a profit motive.

                    3.  

                      I think that’s an overstatement. We haven’t gotten it right yet. Browser APIs are getting decent, but HTML+CSS is not a felicitous way to represent a UI. It’s a hack. Most everything to do with JavaScript is also a hack, although on that front we’ve finally started to break the “well, you have to write JS, or transpile to JS, because JS is the thing browsers have” deadlock with WASM, which finally offers what Java and Flash had a quarter century ago: compact bytecode for a fairly sensible VM.

                    4.  

                      The biggest problem was that Java wasn’t integrated with the DOM. The applet interface was too impoverished.

                      jQuery had a nice tight integration that was eventually folded into the browser itself (document.querySelector). And if you look at modern frameworks and languages like React/preact, Elm, etc. you’ll see why that would continue to be a problem.

                      They use the DOM extensively. Although interestingly maybe the development of the virtual DOM would have been a shim or level of indirection for Java to become more capable in the browser.

                      The recent Brendan Eich interview has a bunch of history on this, i.e. relationship between Java, JavaScript, and the browser:

                      https://lobste.rs/s/j82tce/brendan_eich_javascript_firefox_mozilla

                      1.  

                        It was in fact perfectly possible to manipulate the DOM from an applet (although at some level you did still need to have the applet visible as a box somewhere; I don’t think it was possible or at least frictionless to have “invisible applets”).

                        I would instead say the biggest problem was the loading/startup time; the JVM was always too heavy-weight; there was a noticable lag while applets started up; early on it would even freeze the whole browser. There were also a lot of security issues; the Java security model wasn’t great (it was fine in principle, but very difficult to get right in practice).

                        Now, funnily enough, the JVM can be much more light-weight (the “modules” effort helps, along with a raft of other improvements that have been made in recent JDKs) and the startup time is much improved, but it’s too late: applets are gone.

                        1.  

                          I don’t think it was possible or at least frictionless to have “invisible applets”

                          it totally was. Make them 1x1 pixel large and use css to position them off screen. I have used that multiple times to then give the webpage access to additional functionality via scripting (applets could be made accessible to JS)

                          Worse: the applets could be signed with a code signing cert which gave them full system access, including JNA to FFI call into OS libraries.

                          Here is an old blog post of mine to scare you: https://blog.pilif.me/2011/12/22/grave-digging/

                          1.  

                            It was in fact perfectly possible to manipulate the DOM from an applet

                            How? I don’t recall any such thing. All the applets I used started their own windows and drew in them.

                              1.  

                                OK interesting. It looks like this work was done in the early 2000’s. I think it must have lagged behind the JS implementations but I’m not sure. In any case jQuery looks a lot nicer than that code! :)

                          2.  

                            In that interview, Brendan noted that JavaScript was async, which helped adoption in a UI world. It’s true, it made it nearly impossible to block a UI on a web request.

                            1.  

                              Yes good point. IIRC he talks about how JavaScript was embedded directly in Netscape’s event loop. But you can’t do that with Java – at least not easily, and not with idiomatic Java, which uses threads. As far as I remember Java didn’t get async I/O until after the 2000’s, long after Javascript was embedded in the browser (and long after Python).

                              So yeah I would say those are two absolutely huge architectural differences between JavaScript and Java: integration with the DOM and the concurrency model.


                              This reminds me of this subthread with @gpm

                              https://lobste.rs/s/bl7sla/what_are_you_doing_this_weekend#c_f62nl3

                              which led to this cool experiment:

                              https://github.com/gmorenz/async-transpiled-xv6-shell

                              The question is “who has the main loop”? who can block? A traditional Unix shell wants to block because wait() for any process is a blocking operation. But that conflicts with GUIs which want to have the main loop.

                              Likewise Java wants the main loop, but so does the browser. JavaScript cooperates better by allowing callbacks.

                              When you have multiple threads or processes you can have 2 main loops. But then you have the problem of state synchronization too.

                        1. 6

                          Despite an immense degree of criticism and mockery, PHP continues to be a highly usable and regularly improving language in an under-served niche. Being the implementation language of Wordpress alone makes it a hugely important programming language, and I’m happy to see it continue to grow and change.

                          1. 5

                            in an under-served niche

                            I’m curious what you think that niche is exactly, and how/why it’s under-served. I’m not necessarily disagreeing, but my gut feeling is that is less true than it used to be.

                            1. 4

                              I’m curious what you think that niche is exactly

                              It gives the people mocking it something to mock, so they can ignore their own languages’ lack of power and flexibility relative to Common Lisp ;-P

                            2. 4

                              I’m not going to bash on PHP, as I find it at least reasonably pleasant to work in, but I don’t see what niche it serves that Perl, Ruby, and Python don’t; from my perspective, it’s one of a small family of similar languages, as opposed to being very distinct in its own right.

                              1. 3

                                I think the niche is (at least in part) “web-oriented script that you can drop straight into your htdocs and hit refresh to see changes immediately”. Ruby and Python tend not to serve that (tend to be used through application servers), Perl a little more so.

                                1. 1

                                  I’m not sure that’s nearly as compelling a story as it used to be. From what I’ve seen:

                                  1. Many PHP codebases have moved towards frameworks that are much more similar to what ruby and python tend to use with a centralized application, url routing service, view handlers, etc… While it’s certainly still possible to do the classic “inline scripts in your markup” approach, it seems to be something that the modern PHP community is moving pretty strongly away from, and is treated as an antipattern in many of these systems.
                                  2. Having a LAMP stack set up and running for you out of the box on every hosting option has become less common than it used to be, while it’s simultaneously become easier to get other stacks prebuilt in a reasonable default config w/ container and vps images.
                            1. 5

                              Betteridge’s law strikes again.

                              One of the key features of a blockchain, which the author tries to handwave away, is that every link in the chain is verifiable, and unalterable. The author tries to claim that because each commit carries a reference to its parent, it’s a “chain of blocks”, but it’s not so much a chain as just an order. You can edit the history of a git repo easily, reparent, delete, squash, and perform many other operations that entirely modify the entire chain. It was kinda made that way.

                              1. 12

                                The technical properties of git’s and common block chain data structures are relatively similar.

                                You can also fork a bitcoin block chain and pretend that your fork is the canonical one. The special bit about block chains is that there’s some mechanism for building agreement about the HEAD pointer. Among other things, there’s no designated mover of that pointer (as in a maintainer in a git-using project), but an algorithm that decides which among competing proposals to take.

                                1. 16

                                  They are technically similar because both a blockchain and a git repo are examples of a merkle tree. As you point out though the real difference is in the consensus mechanism. Git’s consensus mechanism is purely social and mostly manual. Bitcoin’s consensus mechanism is proof of work and mostly automated.

                                  1. 2

                                    Please stop referring to “Proof of _” as a consensus mechanism. It is an anti-sybil mechanism, the consensus mechanism is called “longest chain” or “nakomoto consensus” - you can use a different anti-sybil mechanism with the same consensus mechanism (but you may lose some of the properties of bitcoin).

                                    The point is that there are various different combinations available of these two components and conflating them detracts from people’s ability to understand what is going on.

                                    1. 2

                                      You are right. I was mixing definitions there. Thanks for pointing it out. The main point still stands though. The primary distinction between a blockchain and git is the consensus mechanism and not the underlying merkle tree datastructure that they both share.

                                    2. 1

                                      Mandatory blockchain != bitcoin. Key industrial efforts listed in https://wiki.hyperledger.org/ are mostly not proof-of-work in any way (the proper term for this is permissioned blockchain, which is where industrial applications are going).

                                      1. 2

                                        You are correct. I don’t disagree at all. I used bitcoin as an example because it’s well known. There are lots of different blockchains with different types of consensus mechanisms.

                                  2. 2

                                    You can make a new history but it will always be distinct from the original one.

                                    I think what you’re really after is the fact that there is no one to witness that things like the author and the date of a commit are genuine – that is, it’s not just that I can edit the history, I can forge a history.

                                    1. 1

                                      what was all that hullabaloo about git moving away from SHA-1 due to vulnerabilities? why where they using a cryptographic hash function in the first place?

                                      what you said makes sense, but it seems to suggest this SHA-1 thing was a bit of bikeshedding or theater

                                      1. 2

                                        Git uses a cryptographic hash function because it wants to be able to assume that collisions never occur, and the cost of doing so isn’t too large. A collision was demonstrated in SHA-1 in 2017.

                                        1. 3

                                          SHA-1 still prevents accidental collisions. Was Git really designed to be robust against bad actors?

                                          1. 2

                                            ¯_(ツ)_/¯

                                            1. 1

                                              The problem is that it was never properly defined what properties people expect from Git.

                                              You can find pieces of the official Git documentation and public claims by Linus Torvalds that are seemingly in contradiction to each other. And the whole pgp signing part does not seem to be very well thought through.

                                          2. 2

                                            Because you can sign git commits and hash collisions ruins that.

                                            1. 1

                                              ah that makes some sense

                                          3. 1

                                            Technically you haven’t really made the others disappear. They are all still there just not easily viewed without using reflog. All you are really doing is creating a new branch point and moving the branch pointer to the head of that new branch when you do those operations. But to the average user it appears that you have edited history.

                                          1. 1

                                            There are also more use-cases for client-side certificates that seem rather compelling, such as an alternative to user passwords. Web browser support for client-side certificates totally sucks, but that is a solvable problem.

                                            For the record, I have no intention of using this approach for the SourceHut API. This thought simply occurred to me, and I want to hear what you think. Why aren’t we using client-side certificates?

                                            I have wanted some kind of public-key-crypto replacement for user passwords for years. The private key could even be stored on a hardware token, for greater security. Without shared secrets, things like haveibeenpwned wouldn’t need to exist.

                                            Compared to something like SSH, TLS is pretty terrible, with lots of unfortunate complexity. I think part of the reason TLS tooling is so user-hostile is that the underlying complexity leaks into the tooling. I don’t know whether it can be helped. Maybe that’s a discussion we need to have, given wide-spread TLS adoption. How can we make this stuff approachable to people without doctorates in cryptography?

                                            With SSH you have a public key and a private key, and that’s most of what you need to know. You need to have a little awareness of public key types. But you usually aren’t going to be confronted with X.509, PKCS #whatever, and all of the other stuff that leaks into TLS tooling.

                                            Orthogonally to this discussion, PKI is a mess.

                                            I’ve always been a bit hostile to the “HTTPS all the things” mentality. That is partially because I’m more of a “transparent society”, “information wants to be free” sort of person, rather than a cypherpunk. My other reason is that I’m not fond of TLS.

                                            1. 7

                                              “Information wants to be free” isn’t a hope, it’s a threat: Your medical information wants to be free in the same way the water behind a dam wants to break through and flood all the towns downstream. The dam has to be maintained lest that desire be fulfilled to everyone’s detriment.

                                              1. 4

                                                “information wants to be free” sort of person

                                                Information can’t be free if your ISP can tamper with any information you receive ;) If HTTPS didn’t achieve its current “all the things” status, this bullshit would’ve gotten so much worse.

                                                1. 1

                                                  Here in the US, at least, there are laws against tampering with postal mail. I don’t see a moral difference between someone tampering with snail mail and a service provider tampering with unencrypted web traffic. Perhaps the same laws should apply?

                                                  And secrecy cuts both ways. The same encryption that protects my information can also prevent me from snooping on or monkeying with devices or programs on my network that I either distrust or trust minimally.

                                                  We’re seeing this same argument around things like DNS over HTTPS. I have legitimate reasons for intercepting and modifying DNS traffic on my network. In my case it’s an allergy to advertising, so I’ve seeded dnsmasq with some blocklists. Behind dnsmasq, I run my own recursor (unbound), in preference to using somebody else’s recursive resolvers. My point is, I would be very upset by my browser circumventing my policies around DNS in the name of privacy or whatever.

                                                  Sorry for going off on so many tangents; I’ll go back to lurking. This is a discussion worth having, but it’s not quite salient to the topic at hand.

                                              1. 1

                                                Is this course available to anyone online? All I can access is the syllabus page. Also, is this affiliated/funded with the university? Seems like a possibly controversial course topic.

                                                1. 8

                                                  Seems like a possibly controversial course topic.

                                                  I don’t know if this is what you had in mind, but it’s what everyone else is going to have in mind:

                                                  The Urbit platform was conceived and first developed in 2002 by Curtis Yarvin.

                                                  That name pinged something in me, so I clicked the link:

                                                  Curtis Guy Yarvin (born 1973), also known by the pen name Mencius Moldbug, is an American far-right blogger.[4] Yarvin and his ideas are often associated with the alt-right, despite his and the efforts of other Dark Enlightenment thinkers to distance themselves from it.[5][6] From 2007 to 2014 he authored a blog called “Unqualified Reservations” which argued that American democracy is a failed experiment,[7] and that it should be replaced by monarchy or corporate governance.[8] He is known, along with fellow neo-reactionary Nick Land, for developing the anti-egalitarian and anti-democratic ideas behind the Dark Enlightenment.

                                                  Hello, Moldbug, my old “friend”, you’ve come to fuck with me again.

                                                  Wait, it gets worse:

                                                  Yarvin has links with the website Breitbart News, the former White House chief strategist Steve Bannon, and with the billionaire investor Peter Thiel.[9] His ideas have been particularly influential among radical libertarians, and the public discourses of prominent investors like Thiel have echoed Yarvin’s project of seceding from the US to establish tech-CEO dictatorships.[10][11] Journalist Mike Wendling has called Yarvin “the alt-right’s favorite philosophy instructor”.[12] Bannon, in particular, has read and admired his work.

                                                  Yeah, this is cancel bait and no mistake.

                                                  1. 4

                                                    Stick to technical commentary and please don’t post off-topic political axe-grinding and critique.

                                                    1. 9

                                                      Okay, let’s go for the technical commentary, even though it ties in directly with Yarvin’s political pet theories: The system is strictly hierarchical where higher tiers exert enormous powers over lower tiers. If you’re into serfdom LARPing, feel free to be an Urbit serf, otherwise maybe look for something else.

                                                      1. 4

                                                        Okay, let’s dig into that more: how does that differ from the normal internet? What happens when Cloudflare or Google want you off the internet?

                                                        1. 4

                                                          Sure, google can take you down off the list of search results and cloudflare can remove you from their service (making you much more vulnerable). Google could also use their horrific amounts of money to tell my ISP to shut me off, but this is really bad and should not be possible.

                                                          I have an Urbit planet, though, and my understanding is that I am totally reliant on my star (approx. to an ISP?) for connection to the wider network. As in, if I act in a way that my star doesn’t like, they can get rid of me. And if my star acts in a way that my galaxy doesn’t like, they can get rid of them, which gets rid of me too! At which point I have to use my much-touted “right of exit”, which is currently completely manual– there’s no workflow for this.

                                                          1. 1

                                                            I’m not sure what distinction you’re making between a “workflow” and a “manual process”. If you depend on some provider of compute or network resources, and they deplatform you for any reason (including political reasons), you have to manually react to it by finding a new provider if you don’t want your compute process to suddenly stop working. This is the case whether your upstream provider is an Urbit star, or AWS.

                                                            That said, there’s no reason why programmers can’t build tools to automate parts of this process. The Kubernetes ecosystem, for instance, has tools that make it easier to build a cloud-agnostic site, which makes it possible to switch between cloud compute providers with minimal downtime if and when the one you use decides to cut you off (or if another one is cheaper, or any other reason you might want to switch providers). Urbit is a young network yet, and there’s a lot of useful tooling that has yet to be developed, but you could imagine a software product for the Urbit ecosystem that makes tentative agreements with multiple stars to provide connectivity to your planet, and automatically switches to a new one if your current star cuts you off.

                                                            1. 2

                                                              Sorry, what I mean is you literally have to contact Tlon and have them help you change stars. If the thing that rescues feudalism from failure is this ability to exit, why can’t I just do it whenever I want?

                                                              If you depend on some provider of compute or network resources, and they deplatform you for any reason (including political reasons), you have to manually react to it by finding a new provider if you don’t want your compute process to suddenly stop working.

                                                              Right, and I’m saying this is a bad thing. This is also accidental to the design of the internet. Urbit’s design seems to be explicitly centered around being able to deplatform at-will, and I think this is kind of weird.

                                                              1. 2

                                                                Sorry, what I mean is you literally have to contact Tlon and have them help you change stars. If the thing that rescues feudalism from failure is this ability to exit, why can’t I just do it whenever I want?

                                                                https://urbit.org/using/operations/using-bridge/#escaping-your-sponsor <- changing sponsors is an Ethereum smart contract transaction that doesn’t require Tlon’s involvement in any way, just the new sponsor’s. They currently offer to manually help people find new sponsors, which works because the network is currently small and new.

                                                      2. 7

                                                        The technical commentary is so damning that it’s surprising that people would prefer to hear it. Here’s my favorite example: Urbit’s implementation has incorrect and unsafe behavior for Booleans; they invented their own “loobean” type which is always backwards, and under-specified its behavior.

                                                        1. 3

                                                          It’s neither incorrect nor unsafe on its own. It is very unintuitive, and doesn’t interact well with C, I’ll grant you that! But it’s a self-consistent 1-byte enumerated type with values {true, false}.

                                                          1. 2

                                                            I see this as fundamentally a problem with C that any program written in C has. There isn’t actually a way to specify a boolean type, only a numeric type at least 8 bits wide, where the 0 value has different semantics in branching constructs than other values. (This of course is similar to how most CPU architectures implement branch instructions). Ideally, you would represent a loobean as an ADT with exactly two variants, but C doesn’t give you the tools to do this. The Urbit project is working on moving its runtime from a C program to a Haskell program, which strikes me as a good idea.

                                                            1. 1

                                                              It seems like they explain it pretty well in that link. It’s dumb, in my opinion, but they seem to say explicitly to be comparing it with their provided values.

                                                            2. 4

                                                              I’m not commenting on the politics per se, just on the fact the politics are going to cause problems.

                                                              I see that as fairly neutral. Even Yarvin would agree his politics are controversial, I think.

                                                              1. 3

                                                                Do you not see how that is somehow even worse?

                                                                1. 2

                                                                  So, you think a meta commentary about politics is on topic despite the fact that politics is off topic?

                                                                  What’s really a shame is that the moderators can’t just delete these walls of text, because people sink so much into writing them despite their being off topic for lobsters. Just look at this garbage fire of a thread about the ethics of using Firefox. So many words expended, 0 opinions changed.

                                                            3. 3

                                                              Unsure if it’s helpful (since I think the material is mostly the same), but perhaps the Github?

                                                              1. 2

                                                                There are links to individual lecture notes and class assignments that seem to be working for me.

                                                              1. 1

                                                                Alright, let’s do it for “micro services”: go!

                                                                1. 1

                                                                  I’m eager to do it for such buzzwords as “email” and “RAM” and “keyboard” which would be more in line with the author’s intent with this post.

                                                                1. 4

                                                                  Removing terms of art from your writing and thinking won’t improve anything. You still need to express the concepts, and communicate them to others, and communicate them to the yourself of six months from now, so you can’t avoid some way of referring to them. All removing the specific terms does is force you to create complex, elliptical circumlocutions to state what others can say in two words; even if you discount verbosity, that still requires others (or, as I mentioned, the you of six months from now) to disentangle whatever heap of neologisms you’ve come up with to state something others can say in a short, fixed phrase, all the while wondering what, exactly, is so all-fired different and special about the idea you’re trying to express that you can’t state it in a comprehensible fashion.

                                                                  Sometimes it’s necessary to remove a word or phrase from your stock of them, for example when a term comes to be seen as insulting or when it’s simply no longer apt. For example, “policeman” as a fixed term is no longer up to the task of referring to referents who may not be male; its time has come and gone, and “police officer” is much more accurate and, at this point, more popular as well. However, the phrase “public domain” is still the simplest, most comprehensible, least jargon-laden way to talk about works not covered by copyright. Replacing it does nobody any favors.

                                                                  1. 6

                                                                    I think the point of this article is that by removing some terms from your vocabulary, you’re forced to think what you actually want to say and clarify what you mean, instead of using a “shorthand” which doesn’t necessarily convey all that much.

                                                                    Of course, such shorthand – or jargon – is also useful in many cases, since it allows for easier communication, but a lot of these terms are quite fuzzy. What does “open source” mean? Well, ask a bunch of people and you’re likely to come up with a few different answers: some will point at the Open Source Definition, others will simply say “the source is available”, others will say something about community ownership or some such and that “over the wall” Open Source like Chrome isn’t true Open Source, and perhaps some more.

                                                                    And even if we could get everyone to agree on a solid definition, then we’re still left with a situation where “Open Source” often doesn’t really capture all that much; to quote my comment from last week:

                                                                    I have a few projects where I work on in my spare time for my own purposes, and I’ve very clearly said “Thanks for the bug report, I’ll fix it when I feel like it” on a number of occasions (in pretty much those words, with a little bit of context). Sometimes I feel like it the next day, sometimes much later. Sometimes never. On other projects expectations are a bit higher: one of my projects is paying the bills right now.

                                                                    I’ve recently come to think that we just need new terms for this; “Open Source” or “Free Software” (whatever you prefer) just doesn’t capture any of this. Most projects fall in three categories: a business who open source something, someone who makes something in their spare time and puts it online “because why not?”, and people work on it in their spare time and really like being maintainers for these kind of things (rather than just working on it for their own purposes).

                                                                    But perhaps we don’t really need new terms for this, but just say “This is the source code for a hobby project I work on in my spare time” rather than “This is my Open Source project”, and “ACME Inc. released the source code for Product Foo for [reason X]” rather than “Product Foo from ACME Inc. is Open Source”. This is simple plain language that anyone can understand, and actually conveys a lot for information too.

                                                                    I do something similar with logical fallacies: I will never say “that is a strawman” or point out an ad hominem by name, but instead say “I don’t think that’s an accurate representation of what they said, instead, they meant […]”. While it’s more or less the same, the latter is just a much more useful way to have a conversation.

                                                                    1. 1

                                                                      Thanks. I’m not a native English speaker, so I feel this on my skin daily. I really appreciate well written technical prose. There’s reason and precision in jargon and specific terms that need to be used.

                                                                      And while I often simplify the jargon for my clients as op suggests, I can’t avoid thinking this is part of a large cultural problem. IMHO exacerbated by the “Twitter attention span”. People seems too afraid to search terms in a dictionary or thesaurus, to ask, or to invest the concentration necessary.

                                                                      Seems to me that we keep catering to the minimum common denominator . Which might be a worthwhile goal for a blog post, but with a distribution large enough is going to be ridiculously low. Perhaps we should invest in education. Prize intellectual honesty, curiosity and asking questions. Instead of the ninja/unicorn/guru figure. Instead of trying to explain quantum mechanics to people that need to be reminded that “objects in mirror are closer than they appear”.

                                                                    1. 14

                                                                      Quoting from the article:

                                                                      Argument: You can type out messages

                                                                      Surely, it’s not like you will open a terminal on your cell-phone and then type in SIP like this to call your friend.

                                                                      INVITE sip:1001@10.0.0.1:2780;transport=udp SIP/2.0

                                                                      SNIP

                                                                      While reading this, I had the distinct impression that it might be written by an application developer rather than a systems programmer, system administrator, or network engineer. I speak HTTP/1.1 pretty well. For that matter, I speak SMTP pretty well, too. If you speak SMTP, you can speak similar IETF protocols like NNTP and POP3 without much extra effort. They have a family resemblance, like Spanish and Portuguese.

                                                                      That ability has helped me quite a few times as an admin, but it also proved invaluable while implementing application-layer protocols.

                                                                      The article is thought-provoking. I remain on the fence about which is better: text or binary. Maybe the answer is both, and maybe I’d have a deeper appreciation of binary protocols if I had the right tooling.

                                                                      1. 5

                                                                        I’d have a deeper appreciation of binary protocols if I had the right tooling.

                                                                        Yeah, I kinda like text protocols sometimes too (though they are a real pain to correctly parse. Like there’s usually special rules for edge cases that are easy to forget.), but consider the case of assembly language.

                                                                        I can read a little bit of machine code off a hex dump…. but not much since there’s basically never any need since I can assemble/disassemble just about anything so easily.

                                                                        A binary protocol that came with such a translation thing to/from some text format would probably be the best of both worlds. And then it can be validated before sending to help catch typos too.

                                                                        1. 7

                                                                          Binary protocols have to be parsed, too: Assuming you can just bamf them into a struct is assuming that no transmission errors occurred, no errors occurred in the sending process, and no errors occurred in the machine the sending process was running on. Even if you strictly discount such things as endianness differences and differences in word sizes, there’s still parsing to be done.

                                                                          1. 4

                                                                            Binary protocols have to be parsed, too

                                                                            Indeed, my advice for people is often to do it byte by byte, then no more endianness problem, word size problem, etc. And things like variable length members easier to handle then too. But it still tends to be much easier to do correctly than text format parsing since there’s usually fewer weird cases to consider.

                                                                            1. 2

                                                                              Agreed assuming that one is working at a low enough layer that they actually need to consider this stuff. I’ve spent a good amount of my career working on avionics hardware & software, and a significant amount of that time was spent staring at a digital scope hooked up to a data bus trying to figure out what was going wrong before a payload even got to the point where I could try to slam it into a (properly packed and versioned) struct.

                                                                              However, there definitely are streamlined ways to perform quick error checking on binary payloads while they are “on the wire”. For example, parity bits and other checksum techniques. And, most of the time, this error checking is being performed at a much lower layer than the developer is actually working in.

                                                                              It is sometimes the case that nuanced data that would otherwise need to be parsed using costly string functions can be communicated more efficiently in a binary protocol. Bitwise (flag) lookup tables come to mind – for example, one can communicate 32 different flags in a single integer – and each of which can be checked extremely efficiently using bitwise operators.

                                                                              Also, from the experience of creating a couple of real-time systems (for enterprise, avionics, and multiplayer video games), binary protocols can often be a lot “nicer” to parse. If you can trust that the payload is not corrupt, then you can simply stream/scan and count – or, even better, blit and mask – rather than perform weird splits and finds while fighting off-by-one errors.

                                                                              1. 2

                                                                                Assuming you can just bamf them into a struct is assuming that no transmission errors occurred, no errors occurred in the sending process, and no errors occurred in the machine the sending process was running on.

                                                                                Adding a checksum to a binary protocol is trivial compared to adding it to a text-based one.

                                                                              2. 4

                                                                                This is one of the reasons why I try to use standardized self-describing binary protocols like CBOR or messagepack when feasible. The more they get used the more incentive there is for people to make tools like jq that work with them.

                                                                                …actually, a hex-editor type program that could display and manipulate CBOR structures would be pretty neat– no no I have enough side projects brain please stop.

                                                                              3. 3

                                                                                I write web apps for a living, and I know how to do HTTP “by hand” and have used it for debugging. Same with SMTP. I also encourage people who want to learn backend web development to try out writing a very basic HTTP/1.1 server in their language of choice and communicating with it, to get a feel for what needs to go on.

                                                                                1. 1

                                                                                  But for how long, now that HTTP/2 and HTTP/3 are a thing [1]?

                                                                                  [1] Thanks be to our new Internet Overlord, Google.

                                                                                  1. 1

                                                                                    A great tool for this is netcat (a.ka. nc). Even better is that it comes as a standard CLI utility on macOS and many Linux distros.

                                                                                1. 2

                                                                                  Just a strange feeling: not even the simplest things like time and current weather (grade) we can obtain from our advanced technologies. So what good they serve?

                                                                                  1. 9

                                                                                    It’s not a lie though, you are obtaining the time. It’s just rounded to the nearest second instead of rounded down, which is a pretty intuitive thing.

                                                                                    1. 3

                                                                                      I hadn’t noticed until it was pointed out and it’s great. It always feels ‘wrong’ when you start a timer at (to use the example) 5s and the first thing you see is 4.something. I can imagine there were arguments about implementing this though.

                                                                                      1. 5

                                                                                        There could be an argument in favour of rounding up too. Starts with a full second 5, then the very moment you see 0, it’s over. Very intuitive.

                                                                                        1. 9

                                                                                          Yeah, I’m pretty sure this is how most people speak a countdown out loud. “Five…four…three…two…one…” and then “zero” or “time” or “go” means it’s over. You wouldn’t say “zero” if there was still any time left.

                                                                                          1. 1

                                                                                            this makes the most sense to me, if they aren’t showing milliseconds, it ‘ending’ on zero seems far more reasonable, e.g. https://i.imgur.com/Y1AlKks.gif

                                                                                          2. 2

                                                                                            I’ve always used this rounding up approach. The article touches on it but dismisses it as not useful when using it for hours and minutes. Of course, in a rounding up approach, you only want to ever round up the smallest unit you are displaying and continue to round down the others.

                                                                                            There is some philosophical argument about showing the rounded up time, however. If the timer shows 1s you might be inclined to believe there is at least a whole second left. With the rounding down approach, this holds true. For the rounding to nearest and rounding up approaches, however, the timer shows something different. Showing a value of 3s in those cases only indicates that you have no more than 3s left before the countdown expires.

                                                                                            My intuitive understanding of what a timer means is more inline with the presentation given by rounding down, but it is definitely strange to think that hitting 0 is not the end. I suppose that’s why I prefer the rounding up approach in the end even if I find it mildly misleading.

                                                                                      2. 4

                                                                                        I can get the current time and weather from my technology fine. What are you talking about?

                                                                                      1. 3

                                                                                        What a wonderful collection of nontrivial software written for a huge variety of systems. It’s almost a Rosetta stone, for languages, and APIs, not to mention getting “the same” program running on systems with wildly varying capabilities. It’s also a useful program in itself for retrocomputing hobbyists: If there’s a Kermit binary on the emulated system, and the emulator supports some kind of virtual serial line, you can get files on and off the emulated system without a lot of effort.

                                                                                        1. 5

                                                                                          This person’s stream-of-consciousness style drives me crazy 🤯. I’m not going to spend 20 minutes reading a post with no idea what the point is eventually going to be. I reserve that for writers like Thomas Pynchon, whom I will allow to digress for 20 pages about Turkic languages, or colonialism in South Africa, because he’s Thomas Fscking Pynchon. This guy, I’m not so sure.

                                                                                          He had a decent, if obvious, point about compile-time checks saving time over the program’s lifecycle, but then I gave up after a few screenfuls about SSH attacks and HTTP parsing. I assume that’s going to tie into his grand theme later on, but I’d rather go find something that doesn’t bury the lede in a coal mine.

                                                                                          Plus, his cartoon asides aren’t as funny as Why The Lucky Stiff’s were.

                                                                                          1. 6

                                                                                            Style and comics are a matter of taste, I will give you that. What remains, to me, is that Amos lists three statements:

                                                                                            1. Programming in Rust requires you to think differently
                                                                                            2. It is harder to write any code at all in Rust
                                                                                            3. It is easier to write “correct” code in Rust

                                                                                            Most of the article is centered on proving the last point, by going through a lengthy example with NodeJS and Go only to come back to Rust in the end to demonstrate said point. I for one appreciate long form, in-depth content like this.

                                                                                            1. 1

                                                                                              Programming in Rust requires you to think differently

                                                                                              I hate this, because it presumes a lot about how the reader thinks in the first place. And if the author of such a statement is going to make sweeping assumptions about how I think, then they’re likely to make sweeping assumptions elsewhere too.

                                                                                              1. 0

                                                                                                If they’re aiming at correctness, a language like Haskell is better; Rust is, ultimately, a compromise with correctness and speed on current machines, and it dumps correctness too often to be safe in any real sense. Rust’s focus on “types” which merely specify the size in bits (making them fail to be types, as they do nothing to catch invalid operations) proves that it’s a systems programming language, as opposed to one with any emphasis on correctness beyond the superficial.

                                                                                                1. 11

                                                                                                  Rust’s focus on “types” which merely specify the size in bits (making them fail to be types, as they do nothing to catch invalid operations)

                                                                                                  Um, where did you hear this? That’s not right at all.

                                                                                                  1. 6

                                                                                                    Did you read the article?

                                                                                                    1. 4

                                                                                                      It took me a bit to understand where you might be standing (and unflag the comment).

                                                                                                      Still, I vehemently disagree: Rust type system might be weaker than Haskell’s (yes, no HKT and any way to do monads, no tons of advanced type system extensions), but it’s so much more than just specifying bit sizes. It’s the first time we have ADTs in a semi-mainstream systems programming; traits are direct translation of Haskell typeclasses. Borrow checker is a unique development that only now finds its way into GHC in much more experimental form.

                                                                                                      Haskell, on the other hand, has quite many non-typesafe footguns like non-exhaustive pattern matching, partial functions, laziness (which is not reflected in the type system at all, poisons it with bottom everywhere, explodes into space leaks, sneaks in lazy I/O, makes reasoning about runtime a nightmare) and still not expressive enough to avoid occasional Template Haskell and verify monad laws mechanically.

                                                                                                  2. 4

                                                                                                    every one of his articles reads like this. I’m digging it for like a page or two and then he goes into some extremely specific corner case that just reads like he found a bug and he has a massive axe to grind about it. I want to like his writing more than I do, he seems to be pointed in the right direction.

                                                                                                  1. 18

                                                                                                    I certainly would like rust to become even more successful. But I feel like zig is going to take the lead in replacing C eventually, based on my limited knowledge. It’s far easier to integrate with existing C than rust is already. It has even easier ways of having multiple allocators (stack,pool etc) and allows for seamless async-await as far as I know. This makes it even better for usage in embedded environments and the harsh c world of Drivers, Kernels and so on.

                                                                                                    Rust is a little bit too heavy or constraining it seems for those bare metal workloads and zig can just place itself as drop in replacement. Sure rust gives you even more guarantees, while zig feels like a tidy C in that aspect. But this may be more desirable than to fit your stuff into rusts totally different world. Or writing loads of unsafe code, while 99% of your Linux Kernel may already be a bunch of unsafe hacks to allow the speed and integration it has.

                                                                                                    On the other side are the people that enjoy strong typing but don’t want to interact with the borrow checker, here Nim may be more of an option. Meanwhile Deno/Typescript, Ruby and Python are still staying strong in that field.

                                                                                                    And replacing numpy with a rust-ish library sounds nice. But we shouldn’t forget that there are still loads of Fortran libs underneath those heavily utilized python libs.

                                                                                                    This may sound pessimistic so I’d really like to get some different opinions on my thoughts.

                                                                                                    1. 5

                                                                                                      This may sound pessimistic so I’d really like to get some different opinions on my thoughts.

                                                                                                      Sure.

                                                                                                      Rust is a little bit too heavy or constraining it seems for those bare metal workloads…

                                                                                                      There are a few examples of Rust being used in “bare metal” environments. I wouldn’t say it’s constraining to the point that “bare metal” software can’t be written in it. Rust is billed as a “systems programming language”, after all.

                                                                                                      Sure rust gives you even more guarantees, while zig feels like a tidy C in that aspect. But this may be more desirable than to fit your stuff into rusts totally different world. Or writing loads of unsafe code, while 99% of your Linux Kernel may already be a bunch of unsafe hacks to allow the speed and integration it has.

                                                                                                      I didn’t fully understand this point. That valuing performance over safety guarantees is a trade-off worth making?

                                                                                                      On the other side are the people that enjoy strong typing but don’t want to interact with the borrow checker, here Nim may be more of an option. Meanwhile Deno/Typescript, Ruby and Python are still staying strong in that field.

                                                                                                      Garbage collection is certainly another viable approach to the problem of memory safety. Though, some may argue that GC pauses are inappropriate for an embedded system running some sort of real-time application.

                                                                                                      And replacing numpy with a rust-ish library sounds nice. But we shouldn’t forget that there are still loads of Fortran libs underneath those heavily utilized python libs.

                                                                                                      I believe Fortran is relatively safe. IIRC the speed of Fortran arises from aliasing not being allowed in the language.

                                                                                                      Zig is cool, but the size of its user base is much smaller than Rust’s, ergo I expect more effort to be poured into the Rust language.

                                                                                                      1. 2

                                                                                                        That valuing performance over safety guarantees is a trade-off worth making?

                                                                                                        Sometimes it is. Sometimes, if you don’t prioritize performance, the code is incorrect, and the fact the code is safer doesn’t make it correct. Just buying a faster processor isn’t always a solution, either.

                                                                                                      2. 7

                                                                                                        Yeah, Rust is more of the C++ replacement than C.

                                                                                                        1. 14

                                                                                                          Rust has attracted a lot of people (including me) who wanted a better C, and don’t think that C++ is a better C.

                                                                                                          I agree that zig is closer to being a direct C replacement. However, after using Rust I also got used to quality-of-life improvements it brings, so there’s no going back for me :)

                                                                                                          1. 4

                                                                                                            But D though… >_<

                                                                                                          2. 2

                                                                                                            I am unsure if Zig can take the lead in replacing Rust. Successfully replacing a language such as C, in my opinion, can only be a combination of (1) a strong value proposition, (2) ability to gain traction within a developer community, (3) gain traction in larger organisations. I believe the first aspect, both Rust and Zig has. What I believe Rust has, that makes it a prime candidate for replacing C in some ares, is that it has a very strong developer community that is develops integrations into wide variety of developer tools (e.g. IntelliJ Rust support), a strong ecosystem (crates.io, cargo) and advocates highly for it. In addition, it gains tractions within larger organisations and allows people to work paid on the Rust ecosystem. While Zig might be better suited, in my opinion, other factors play a significant role where Rust is really strong atm, in addition to have a strong value proposition.

                                                                                                          1. 19

                                                                                                            Atlassian uses GitHub for all its projects. I think it keeps Bitbucket for existing customers that still pay but probably ships no features as it’s a waste of time. I am always surprised how so many companies still use Atlassian when for every single product they have, a better alternative exists.

                                                                                                            1. 8

                                                                                                              Jira is the most configurable issue tracker i know.

                                                                                                              Confluence is the best wysiwyg wiki i know.

                                                                                                              For Bitbucket I’m not sure, but it might also win for configurability.

                                                                                                              1. 28

                                                                                                                Jira is the most configurable issue tracker i know.

                                                                                                                That’s why it’s so bad. It makes busywork a full time job.

                                                                                                                1. 5

                                                                                                                  An old go-to joke of mine is that I’d like to work at Atlassian for a year just to see the world’s only correctly-configured Jira install.

                                                                                                                  1. 2

                                                                                                                    I dunno. A lot of other tooling assumes a lot about workflows that you might not think about because it suits your workflow. I work in the games industry at a small shop. The server team, web team, gameplay teams, QA teams, art teams, content writing teams, and translation teams all have very different workflows, so the configurability is helpful. We have a yearly release cycle so we tweak the Jira workflows about once a year. But we also use BitBucket and it does indeed suck a whole lot, as does Confluence.

                                                                                                                  2. 11

                                                                                                                    How configurable do you need your issue management to be? Linear does pretty much everything one may need for issue tracking and does it fast.

                                                                                                                    For Confluence, I had personal bad experience where I dreaded adding content to it because of its wysiwyg editor amongst horrible search and again super slow UI.

                                                                                                                    Things may have changed though.

                                                                                                                    1. 5

                                                                                                                      Linear is probably great for software projects. I think Jira is used much more broadly to track any given process in enterprises.

                                                                                                                      1. 2

                                                                                                                        Yes, JIRA is also used basically as a project management toolkit that goes beyond issue tracking. Epics, boards, service tickets are all things I’ve seen used at a huge international corporation.

                                                                                                                        That doesn’t mean it’s good, just what it’s used for. I think GitLab does a lot of this stuff.

                                                                                                                      2. 2

                                                                                                                        It isn’t just about issue management being configurable, it’s also about reporting and statistics-collecting being configurable. If your boss wants this report done this way, helping them deal with disappointment isn’t always the optimal answer, and Enterprise Software is Middle-Management-Ware first and foremost.

                                                                                                                        1. 1

                                                                                                                          Linear doesn’t even have on-premise installs, does it?

                                                                                                                          1. 1

                                                                                                                            Atlassian is phasing out on-premise installs of Jira.

                                                                                                                            https://www.atlassian.com/blog/announcements/journey-to-cloud

                                                                                                                            On February 2, 2021 Pacific Time (PT), the following changes will go into effect:

                                                                                                                            • End of new server license sales: You can no longer purchase or request a quote for a new server product.
                                                                                                                            • Updates to server prices: We will implement new prices for server renewals and upgrades.

                                                                                                                            On February 2, 2024 PT, the following change will go into effect:

                                                                                                                            • End support for all server products: This means that support and bug fixes will no longer be available for your server products.
                                                                                                                            1. 1

                                                                                                                              Have a guess why people using Jira are looking at alternatives that have a comparable feature set, one of the features being on-premise installs.

                                                                                                                              1. 1

                                                                                                                                My point exactly.

                                                                                                                        2. 6

                                                                                                                          Does anyone have any recommendations for issue management that aren’t online-only? We’re using Jira now, but since Atlassian has decided to stop developing the on-premises variant we’re in need of something new (eventually, we’ve got a couple of years to transition).

                                                                                                                          Both Asana and Linear (which got recommended in this thread) seem to be online only.

                                                                                                                          1. 2

                                                                                                                            there’s always bugzilla…

                                                                                                                            1. 3

                                                                                                                              Upstream Bugzilla is very far from the nice experience you get on bugzilla.mozilla.org though. You have to work a lot to get it to be not really ugly.

                                                                                                                            2. 1

                                                                                                                              Why do you guys need on-prem? Regulatory issues?

                                                                                                                              1. 7

                                                                                                                                We’d like to keep our secrets where we can see them, I suppose.

                                                                                                                                Edit: and also not be auto-updated to newer versions of a tool that could mess up our internal workflow with no chance of going back to a version that worked the way we liked it. Or have the provide go out of business. Or other similar issues.

                                                                                                                                1. 1

                                                                                                                                  Redmine?

                                                                                                                                2. 4

                                                                                                                                  Yes. Storing critical data on other peoples’ computers is simply not an option.

                                                                                                                                  1. 4

                                                                                                                                    Amen. It’s nice to use other peoples’ computers sometimes, for “unimportant” things. (Scare quotes used there, because I include things that are only unimportant owing to careful contingency planning that makes it so in that bucket.)

                                                                                                                                    But for critical, core things, the question should be “what have you done to make it OK for this to live in the cloud?” Not “why do you need on-prem?”

                                                                                                                                    1. 3

                                                                                                                                      I used to work in a place where adopting new tools was pretty straightforward if you needed them, but they required a reasonable bit of planning ahead, after the company got burned many years before when a software package they used got retired and a whole product line got delayed because there was no way to test them on time. There was a small sub-section in the proposal that read “Migration Path” and basically required you to list how you’d move to another solution should the current one stop working for whatever reason (company goes under, licensing costs become prohibitive etc.) Due to that sub-section the company was basically fully on-prem.

                                                                                                                                      When the expected lifetime of a company is in the 3-5 years range (ship something, get acquired) you can use pretty much anything from anywhere, but these guys had been in business for a very long time. They’d outlived virtually all of their suppliers, sometimes by decades.

                                                                                                                                      1. 1

                                                                                                                                        Same story here. Dropping/rejecting a lot of dependencies based on “we are unsure whether this stuff will exist in 20 years/built by Google”.

                                                                                                                                3. 1

                                                                                                                                  My team is also looking into alternatives to JIRA and also wants to keep it on-prem. I would be curious as well as to what solutions others come up with.

                                                                                                                                  1. 2

                                                                                                                                    Paid GitLab? We use it even as an internal forum.

                                                                                                                                    1. 1

                                                                                                                                      We actually are already using paid gitlab on prem. Not sure if thats being considered.

                                                                                                                                  2. 1

                                                                                                                                    Fossil might be worth a look? It’s from the SQLite folks I think.

                                                                                                                                    https://www.fossil-scm.org/

                                                                                                                                    (It does a lot more than issue tracking though.)

                                                                                                                                  3. 1

                                                                                                                                    Jira is the most configurable issue tracker i know.

                                                                                                                                    I recommend to check out Asana. It comes pretty close.

                                                                                                                                    1. 1

                                                                                                                                      Asana doesn’t even have on-premise installs, does it?

                                                                                                                                        1. 0

                                                                                                                                          Did you click on the link?

                                                                                                                                          (Assuming you did, guess why people using Jira are looking at alternatives with a comparable feature set, one of the features being on-premise installs?)

                                                                                                                                          1. 1

                                                                                                                                            Because Jira’s UX sucks. Which is what the submission is about. Except it’s about Bitbucket.

                                                                                                                                            I get the point you’re making but self-hostedness didn’t come up so far in this thread. Only UX and flexibility.

                                                                                                                                            So if this is a requirement for you that’s fine and I acknowledge you can’t use Asana. Just stop implying I did not read the submission or am missing the point of the discussion.

                                                                                                                                            1. 2
                                                                                                                                              1. 3

                                                                                                                                                self-hostedness didn’t come up so far in this thread

                                                                                                                                                Let me rephrase: I was responding to a poster that did not bring up self-hosted as requirement or apprechiated feature. I would not respond to a statement about Jira being the most configurable issue tracker if I didn’t consider Asana to be comparable in that regard.

                                                                                                                                  4. 2

                                                                                                                                    The hosted version of bitbucket (as opposed to bb server which is a completely separate thing for self hosting) is surely on life support at this point.

                                                                                                                                    Then again, I think it’s hard to say it’s ever not been on life support, with issues like this one being open 10 years without even commitment to implement, much less actual implementation.

                                                                                                                                    1. 4

                                                                                                                                      For a while BitBucket offered some pretty decent competition to GitHub; for example the whole “copying code” thing from this article was pretty borked on GitHub too up until 2 or 3 years ago. Even though BitBucket was always a “GitHub clone” some features were done better in BitBucket IMHO. It had stuff like proper code reviews way before GitHub had.

                                                                                                                                      But at some point it was pretty clear GitHub was on the winning side and they seemed to have just given up. Some features even regressed and became worse. It’s a shame in way, because it had a lot of potential and could have been what GitLab is today. The Atlassian acquirement was both a blessing and a curse, but ultimately more curse than blessing.

                                                                                                                                  1. 2

                                                                                                                                    This is roughly how my analysis prof explained the birth of topology: removing the properties of space, layer by layer, until you’re left with only the bare necessities required to do analysis (i.e. define limits)– the concept of ‘open neighborhood’ essentially. But I don’t know if that’s actually accurate historically

                                                                                                                                    1. 2

                                                                                                                                      Insisting on a historical development cripples education, destroys history, or both: It prevents a more logical development of the topic from being used, and it does great violence to history by paring it down into something a course specialized on some other topic can digest without serious diversions.

                                                                                                                                      1. 1

                                                                                                                                        Well I agree, but I don’t really see how that’s relevant to what I said. This was just something that my prof. mentioned. I’d single out the course itself as probably the most sensibly constructed one I’ve ever attended, and in line with the idea that you should present the logic of the thing the best you can and not focus on the history much.

                                                                                                                                    1. 11

                                                                                                                                      Making things plain text and giving images good descriptions is accessible.

                                                                                                                                      Making a website as per current fashion while making it accessible is a nightmare, sure.

                                                                                                                                      1. 45

                                                                                                                                        Setting aside feelings one way or the other, posting this because the default behavior changing is bound to bite somebody in the next month or two. If anybody knows what minor version is going to start doing this, post here so we can know what to check git --version against. It appears this is landing prior to git 3.0.

                                                                                                                                        Quoting from the mailing list discussion:

                                                                                                                                        So we need to make sure existing users know that they can add:
                                                                                                                                        
                                                                                                                                        [init]
                                                                                                                                            defaultBranch = master
                                                                                                                                        
                                                                                                                                         to their ~/.gitconfig if they want the legacy behavior
                                                                                                                                        

                                                                                                                                        In case you need to support legacy scripts or muscle memory.

                                                                                                                                        git config --global init.defaultBranch master may also work, but haven’t tried it on my machine.

                                                                                                                                        1. 19

                                                                                                                                          [init] defaultBranch = master

                                                                                                                                          Adding this to my gitconfig now to avoid future issues…

                                                                                                                                          1. 15

                                                                                                                                            Wait, I thought that init.defaultBranch was the compromise, to avoid renaming the default branch in Git, while still allowing those who feel uncompfortable by it to avoid it as much as possible?

                                                                                                                                            Are there any statistics or scientific attempts to qualify how much of a problem this is? It’s probably my fault, but I find it hard to imagine that if someone is in the need for version control, will learn all the basics up until the point where they see the word “master”and give up, not because of direct racism, but racism by association.

                                                                                                                                            Non-technical issues like these are never easy, but there should at least be some discission where one position is designated as the morally superior before a word is said.

                                                                                                                                            1. 27

                                                                                                                                              main is shorter, simple, and has no negative connotations whatsoever. This is an easy thing to do and it makes people feel welcome

                                                                                                                                              1. 22

                                                                                                                                                Semi-serious question: How do we know that? I’m going to guess that the people who decieded to use “master” in version control systems didn’t do this out of mallace, but just because the phrase seemed appropriate. So how can we be sure that main won’t eventually fall our of favour? I remember that at the beginning of 2015 Elementary OS wanted to release a new version called “Isis”, afaik in reference to the egyptian god, but then the terror group in ISIS gaiend power and a more or less inncoent name became very controversial.

                                                                                                                                                And does “shorter” and “simpler” even matter? Almost everyone uses autocompletion in some form or another, and it’s not something you use as often as “git commit”.

                                                                                                                                                1. 17

                                                                                                                                                  If we knew the future the world would be a better place ;) In the absence of perfect prescience, we will have to be guided by the voices of today.

                                                                                                                                                  1. 5

                                                                                                                                                    Ok, fair enough, but let’s twist the question again: How do we know that everyone has a seat at the table? What if there is a language or a culture where main has a different meaning (a simple but unoffensive example is in Germany, where Main is a river)? Apparently there were no black people, or people “decendents of slavery” to be exact (because not all back people were slaves) were present when the term “master” came into use, to correct this issue early on. But then on the other hand, if I remember correctly, make still uses tabs instead of general indentation, beacuse Stuart Feldman didn’t want to disrupt his userbase of at most a few dozen users.

                                                                                                                                                    1. 4

                                                                                                                                                      Of course, given that “git” itself is an offensive term in the UK, I insist that the whole project must be immediately renamed.

                                                                                                                                                      1. 6

                                                                                                                                                        false equivalence bad-faith troll

                                                                                                                                                      2. 2

                                                                                                                                                        What are you hoping to achieve with this thought experiment?

                                                                                                                                                        1. 6

                                                                                                                                                          I intend to show that the argument is internally inconsistent. We cannot simultaniously assume a kind of standpoint theory, by which there is always a posibility that a term is (objectivly) wrong, but at the same time be able to suggest an (objective) replacment for a (subjective) offense.

                                                                                                                                                          A simpler understanding, that does not run into these problems is that offense is determined by intent, not by the nature or the etomology of a word.

                                                                                                                                                          At the same time, I don’t think that people advocating for this change are arguing on this level. Any reference to this logic is handwaving, but the motivation appears to be something else, which I would either guess to be some kind of at best false pragmatism or at worse opportunism.

                                                                                                                                                          1. 2

                                                                                                                                                            (I apologize if I misinterpret your comment, English is not my first language and I am trying to understand your comment)

                                                                                                                                                            a group X used a terminology to undermine/subjugate a group Y in the past, the group X is much smaller now but it still exists.

                                                                                                                                                            the change happening here is removing that specific terminology because group Y today is reminded of the past treatment.

                                                                                                                                                            and is your argument is that, since we don’t know that the new terminology wasn’t used to undermine any group in the past, the change is fruitless as we might need to change it again?

                                                                                                                                                            or that since the terminology was also used in other contexts by people not in group X, it should be okay to continue using it?


                                                                                                                                                            As I am neither a member of group X or group Y, my opinion is that if the change results in more people being comfortable using tool, we should definitely do it.

                                                                                                                                                            1. 4

                                                                                                                                                              First of all, and I don’t know why this has to be said: Slavery didn’t exist because it was called slavery, it existed because the society reproduced the conditions under which people were slaves.

                                                                                                                                                              and is your argument is that, since we don’t know that the new terminology wasn’t used to undermine any group in the past, the change is fruitless as we might need to change it again?

                                                                                                                                                              or that since the terminology was also used in other contexts by people not in group X, it should be okay to continue using it?

                                                                                                                                                              I explained the further in a sibling comment, that on the terms of the argumentation, it is imposible to say that main is better than master, because perspectives cannot be compared or have any common point of reference. Since this discussion is not based on any hard evidence, we cannot derive any emperical conclusion like “this will make more people comfortable”, since we are talking about idealized, aggregated perspectives, produced by a worldview that has ever increasing problems to explain anything that is happening, hence the focus on such things like “master/main”.

                                                                                                                                                          2. 5

                                                                                                                                                            I find it not to be only a “thought experiment”. The questions are on point. No data (if any, I would like to see it) to back up claims that people are offended by these words results in such major changes for everyone. At least that needs to be pointed out.

                                                                                                                                                            1. 3

                                                                                                                                                              OP is leaning back in their armchair imagining the theoretical universe in which the broader German community is coping with the upsetting rivered associations with “main” as the new default git branch. I suggest they apply their philosophical leanings to the actual real world in which it turns out a sizeable community of real live humans prefer to dispose of master/slave language where possible in discussions with their terminal.

                                                                                                                                                              1. 5

                                                                                                                                                                Please re-read my comment, the “main” example was just to give an example due to limited perspectives, we cannot know what our actions or decisions mean from other perspectives. I explicity said it was harmless, but if you want something better, consider @caleb’s example.

                                                                                                                                                                I suggest they apply their philosophical leanings to the actual real world in which it turns out a sizeable community of real live humans prefer to dispose of master/slave language where possible in discussions with their terminal.

                                                                                                                                                                How can you know that? Where are the statistics? Where are the polls? How did we figure this out? When did we figure this out? This is just postulated, and nobody goes into it. And I have a hunch that this is because if you were to actually find out what most people belive, that it would not be what you want to think they do. But that’s just by unprooven hypothesis.

                                                                                                                                                                1. 2

                                                                                                                                                                  I’m not going to debate you because you’re displaying a preference for thought experiment over an engagement in reality, which not only suggests a closed mind, but also that you simply don’t have sympathy for the real issue at hand. @caleb’s “example” is a much less veiled form of the same type of trolling you’re unwilling to let go of.

                                                                                                                                                                  You wish to model reality, but no modeling is required to understand this issue. We’re here because we’re here. This is a real conversation which is taking place in the real world for several years now. You’re attempting to place the burden of proof of the existence and size of a community on that exact community itself, which is existentially large and significant enough to make the issue stick broadly across numerous open source projects, GitHub, and now the git project itself.

                                                                                                                                                                  This is just completely illogical. If you want to go do your own research and develop some set of quantitative metrics in an attempt to quantize a complex social issue which is unfolding as we speak, then go ahead and do so. It’s not going to change what’s happening.

                                                                                                                                                                  1. 5

                                                                                                                                                                    As already stated, I just want to explain why the position is incoherent, and as everyone knows, ex falso, quod libet. You have already dismissed everyone who is questioning it as a troll, declare the issue as obviously setteled and then proceed to moralize it by claiming those who don’t agree have no sympathy for the real issue at hand – but of course, we are have a closed mind. I am honestly disgusted by this kind of behaviour, this dishonesty and the smug superiority you emit. Please stop and consider what you are doing, and why you feel the need to behave the way you do.

                                                                                                                                                                    1. 2

                                                                                                                                                                      You wish to model reality, but no modeling is required to understand this issue. We’re here because we’re here. This is a real conversation which is taking place in the real world for several years now. You’re attempting to place the burden of proof of the existence and size of a community on that exact community itself, which is existentially large and significant enough to make the issue stick broadly across numerous open source projects, GitHub, and now the git project itself.

                                                                                                                                                                      This could be accomplished by a small group of PR professionals who don’t actually care about racism, but recognize a potential upside for their company while the cost of changing a default is distributed throughout the open source community.

                                                                                                                                                                      The real story here is that GitHub made the change unilaterally, and git followed suit. One might consider the depth of anti-racist feeling that would drive a company to make this change while continuing to partner with ICE, DOD, and police departments around the country.

                                                                                                                                                          3. 6

                                                                                                                                                            i was there when we named elementary OS Isis and i was also there when we named it Freya.

                                                                                                                                                            from what i remember, no one was concerned about optimizing the name, we were more concerned about not hurting people who themselves or their families had been impacted by Isis.

                                                                                                                                                            I am 110% proud of our decision.

                                                                                                                                                            (taking the elementary OS dev hat off)

                                                                                                                                                            I found main to be a better choice, i am used to using mainline at work now (because of perforce legacy repos) and don’t even notice a difference.

                                                                                                                                                            1. 2

                                                                                                                                                              So how can we be sure that main won’t eventually fall our of favour

                                                                                                                                                              Then we just change it again?

                                                                                                                                                              1. 3

                                                                                                                                                                But considering that the same would apply again, ad infinitium, we cannot say we will ever find a good name. And at then, what is the point? Either we go on forever renaming every time someone complains, at technical expense, or we claim that this renaming is more important than others, because one offended group is more important than others, which I don’t think that the people arguing for this want to argue.

                                                                                                                                                                1. 5

                                                                                                                                                                  we cannot say we will ever find a good name

                                                                                                                                                                  I don’t think anyone is claiming that main will be the perfect name forever. If at some point in the future main becomes offensive, then we could change it again. I haven’t found any evidence that would lead me to believe that git would be changing the branch name on a monthly or yearly basis, so I don’t think there is a high cost here.

                                                                                                                                                                  forever renaming every time someone complains, at technical expense

                                                                                                                                                                  Uh, we work in software. Everything changes all the time at technical expense. Updating your dependencies could break your app (even if the API doesn’t change), products get deprecated, new products get created. I don’t see this much backlash against Apple changing their CPU architecture and that’s gonna cause a lot more trouble than this change.

                                                                                                                                                                  But that makes sense because the real issue here is ideology, wokes vs anti-wokes. We’re just pretending it’s technical. I think it’s fine to argue the ideological issue. I don’t think people are automatically racist for not liking the change. I just don’t think the technical argument holds much water.

                                                                                                                                                                  1. 1

                                                                                                                                                                    I don’t know how Apple is going to handle the migration, but I suppose they have tooling to make it easier, the kind of tooling Git lacks.

                                                                                                                                                                    Those conversations might also be more private.

                                                                                                                                                                    As for tech expenses, you’re correct in that everything comes at an expense.

                                                                                                                                                                    Is it therefore justified to impose more of it on others?

                                                                                                                                                                    Maybe that’s an important ideological question as well?

                                                                                                                                                                    This doesn’t have to be all about how git has a master branch to signify “the master copy”.

                                                                                                                                                                    See also: how master hosts usually perform more work than slave hosts (to counter American slavery connotations) or how offensive “blanket exception handling” and “collaborators” should be (in cultures treated with “less thought” than American slavery).

                                                                                                                                                              2. 1

                                                                                                                                                                Changing it alone is more welcoming than any harm from the word itself.

                                                                                                                                                                1. 1

                                                                                                                                                                  This I don’t get. Could you explain what you mean?

                                                                                                                                                              3. 34

                                                                                                                                                                Master is more precise, traditional, doesn’t break anything, and has no negative connotation in this context, or most other contexts.

                                                                                                                                                                Main does not make me feel welcome, it makes me feel like I’m being forced to bend the knee to a mob that can’t or willfully choose to not understand English. It makes me embarrassed to be in this field. Admitting that feeling means I deserve to feel bad anyway though, so whatever.

                                                                                                                                                                1. 12

                                                                                                                                                                  Tradition should not hold back progress. There are more descriptive names out there. For example allow/deny is better than black/whitelist, parent/child is better than master/slave. I understand people are resistant to change and humans are creatures of habit (energy conservation) but this is a simple name change where there’s more advantages than not and people will get over it after a few weeks.

                                                                                                                                                                  1. 21

                                                                                                                                                                    parent/child is better than master/slave

                                                                                                                                                                    Not if it brings up memories of child abuse.

                                                                                                                                                                    1. 4

                                                                                                                                                                      Sorry about your child abuse, or are you simply virtue signaling? If you feel strongly about it then you can message the maintainers of the software you use to alter the names, otherwise why bring up a “whataboutism” argument.

                                                                                                                                                                      1. 7

                                                                                                                                                                        That you consider it valid shows the futility of choosing names to please everybody.

                                                                                                                                                                        The master slave relationship is not the same as the primary secondary relationship, nor the parent child relationship. Sometimes master slave actually describes the subject matter.

                                                                                                                                                                        And sometimes the master copy of some source code should live on the master branch. Many people only commit to master when they are certain of their work, while they use another branch as their main branch. Kind of presumptuous, calling the default branch the main branch, isn’t it.

                                                                                                                                                                    2. 16

                                                                                                                                                                      Sure, but it should hold this back.

                                                                                                                                                                      1. 1

                                                                                                                                                                        Sure, but it should hold this back.

                                                                                                                                                                        Not when there are demonstrably better names that are not, traditionally, associated with one-sided power dynamics, it shouldn’t.

                                                                                                                                                                        If “main” makes you feel less welcome, then there’s something wrong with your capacity for feeling.

                                                                                                                                                                        1. 9

                                                                                                                                                                          Hold on, it’s not possible to win an argument about inclusiveness by saying that the other person is broken. Or even pretend that there is only one way to view things. We have to learn to communicate better and see the other person’s point of view.

                                                                                                                                                                          1. 1

                                                                                                                                                                            No, @yawpitch is quite on-point. This isn’t about “winning an argument”. Those with any decent capacity for nuance, critical thought, and self-reflection will note that “main” draws fewer negative associations than “master”. Those with unconfronted reactionary cultural/emotional anger stemming from the strawman “woke mob” fantasy will come up with a contorted bad-faith “arguments” a such as “the word ‘main’ makes me feel unwelcome”. You gotta call bullshit when you see it.

                                                                                                                                                                            1. 4

                                                                                                                                                                              Maybe. Or it’s also an opportunity to learn. People can have different points of view, and still, be good people. <3

                                                                                                                                                                            2. 0

                                                                                                                                                                              First off, this isn’t an argument about inclusiveness, it’s at best a debate about semantics, and since there’s no cognizable or remotely valid viewpoint that can distinguish “master” in the “traditional” sense being described above from its root association with human bondage, it’s not even a very sensible debate. No such valid viewpoint, with no pretense involved, exists: the word has several long-standing definitional meanings and the one involved here is fundamentally and absolutely inseparable from the notion of master / slave dynamics by which it derives any meaning whatsoever to the cause of version control. To try and empathize with any countering point of view is absurd … it’s a word, its meaning is simply a fact, and that fact is not open to meaningful and intellectually honest dispute, without descending into the interminable Hell of “alternative facts”.

                                                                                                                                                                              The semantic dispute thus settled the only question, then, is is the community, right now, okay with that semantic baggage being carried further forward, or is the community prepared to make a break from that historical association? Personally I’d say that’s also a moot point … it’s been de facto settled by Github and the very reason the patch detailed above exists is because the network pressures of the downstream are driving an upstream change because YES the community is ready to not be exclusive any longer.

                                                                                                                                                                              What remains is for individuals who are not comfortable with that linguistic and cultural evolution to, frankly, grow up and un-break themselves of their lack of empathy … the point of view of the “tradition” argument has been heard to death, it does not need more empathy heaped upon it.

                                                                                                                                                                              I stand by my point: if you – and I’m using the most generally inclusive meaning of “you” here – feel that you’re somehow more included by “master” and less included by “main” then something is deeply and dangerously flawed with your emotional apparatus. The only colorable arguments against this minor default change are inertial, as in you either don’t want to invest the time required to update existing repos or you don’t want to engage in the effort needed to reprogram some muscle memory for future ones. Those are the available arguments. They’re just not very good ones.

                                                                                                                                                                              1. 7

                                                                                                                                                                                Maybe OP doesn’t know everything you do. Git is being used all over the world, in different types of cultures, and this seems like an American problem at heart. If they feel like this change is being trusted upon them, and on top of that they get vilified when they want to talk about it, it’s not really helpful to generate a common understanding. It doesn’t mean that they are broken, they just have a different context from you.

                                                                                                                                                                                I feel like a better line of discussion would be to give out concrete instances where this word has been a problem. Or actually, even ask why OP feels like they do.

                                                                                                                                                                                1. 4

                                                                                                                                                                                  OP made their context quite clear with their phrasing:

                                                                                                                                                                                  Master is more precise

                                                                                                                                                                                  … only when understood as an explicit reference to master/ slave dynamics …

                                                                                                                                                                                  traditional

                                                                                                                                                                                  … which is automatically a claim of being “inside” the dominant cultural context …

                                                                                                                                                                                  doesn’t break anything

                                                                                                                                                                                  … privileges the idea that the status quo isn’t already broken, which it is if you find the master / slave connotation at all problematic …

                                                                                                                                                                                  and has no negative connotation in this context

                                                                                                                                                                                  … no negative connotation to OP; the phraseology has an extremely negative connotation to me, and I am most certainly not alone: you keep suggesting I need to apply more empathy to someone who’s denying my very existence…

                                                                                                                                                                                  or most other contexts.

                                                                                                                                                                                  … can someone please enumerate the many and varied contexts in which master / slave has no negative connotation from the perspective of anyone who has been a slave, or whose family history was affected by slavery. I can affirm that I’ve personally got a great many friends in a great many contexts – including well outside of America – who see the problem with “master” as default.

                                                                                                                                                                                  I don’t need to understand why OP feels like they do … I need only identify that the feeling itself is unworthy of consideration in the political choice at hand… it is impossible for any rational being that both understands English and is armed with minimal historical context to see “main” as more exclusionary and historically problematic than “master”, hence we need not engage with any such view that happens to be espoused at all, except to point out its obvious and manifest flaws.

                                                                                                                                                                                  1. 2

                                                                                                                                                                                    I guess I didn’t get notifications for this continuing discussion. I’m on mobile and also don’t really care to keep this going, but I do want to clarify that I mean more precise in the sense of “master recording” or “master copy”, as in the source of truth from which copies are derived.

                                                                                                                                                                                    I can’t tell if you already read it that way, and believe that usage to itself be derived from slavery, or just think I’m directly defending the master/slave dynamic.

                                                                                                                                                                                    1. 3

                                                                                                                                                                                      Both of those usages — arguably they’re the same usage — rely in their entirety on the master / slave semantic for their meaning. Indeed no semantic value can be extracted from either without knowing that relationship exists, at least implicitly. A replication master makes no sense without duplication slaves, and that’s exactly what we called them in the bygone days of glass / nickel masters in optical pressing and tape in replication farms. Even before tape and indeed wax cylinders the master mold of foundry and pottery days was there to be used to direct the toil of those making exact copies, as it were, slavishly, with no independent freedom allowed in the work. They’re utterly inextricable from the historical institution they took as their model.

                                                                                                                                                                                      As I’ve said before there’s is not now, nor ever can be, any legitimate argument to be made that separates usage in version control from the historical idea of the privileged master and the slave(s) that follow.

                                                                                                                                                                                    2. 0

                                                                                                                                                                                      it is impossible for any rational being that both understands English and is armed with minimal historical context to see “main” as more exclusionary and historically problematic than “master”, hence we need not engage with any such view that happens to be espoused at all, except to point out its obvious and manifest flaws.

                                                                                                                                                                                      I’m totally with you, though based on the extent of some of the involved philosophical gymnastics into symbology, original intent, and sociology on the “other side” thrown in the face of the simple actual sizeable live human community looking to stop promoting “master” I’ve gotta conclude that these folks are ultimately motivated by a certain emotional bias…

                                                                                                                                                                          2. 7

                                                                                                                                                                            In many uses of master/slave in computer related things, it is actually a poor analogy. Often a “master” does all the work with the “slave” sitting idle waiting to step in only if needed, Other terms like prime and replica can be a better fit anyway. parent/child has a connotation of the parent spawning the child which works for, e.g. processes but not in other cases. In the case of git, there isn’t even a corresponding “slave” concept, only “branches” - In my mind, I wouldn’t even connect that use of the term master to slavery, but I’m not American. In any case, the subversion term “trunk” was better to begin with.

                                                                                                                                                                            1. 4

                                                                                                                                                                              Trunk is a good term. I can understand a change to Trunk.

                                                                                                                                                                              In the book 1984, a major plot point is the reduction of language to reduce the complexities of expressable thought. Words meaning only one thing, like master only meaning “of a slave,” is an example of this language reduction.

                                                                                                                                                                              1. 3

                                                                                                                                                                                The master name in git was derived from master/slave terminology, see https://mail.gnome.org/archives/desktop-devel-list/2019-May/msg00066.html

                                                                                                                                                                                The name trunk like in SVN is ok but I still think calling it main is better overall because of it’s shortness and detachment from it’s controversial origin.

                                                                                                                                                                                1. 2

                                                                                                                                                                                  Saw, am very not convinced by his sources that it is master slave, even in bitkeeper.

                                                                                                                                                                                  Trunk is much better than main. One is descriptive.

                                                                                                                                                                              2. 1

                                                                                                                                                                                Principal/agent makes a lot more sense than parent/child for workflows.

                                                                                                                                                                                1. 2

                                                                                                                                                                                  Not bad, certainly makes sense under certain delegation workflow contexts.

                                                                                                                                                                              3. 1

                                                                                                                                                                                Master is not more precise.

                                                                                                                                                                              4. 15

                                                                                                                                                                                As we’ve seen, you can never make people feel welcome–you can only make it more or less costly to join.

                                                                                                                                                                                1. 13

                                                                                                                                                                                  the spanish main was the site of centuries of brutal colonialism

                                                                                                                                                                            1. 6

                                                                                                                                                                              Funny I was literally just writing down this kind of list for a presentation I had to make for one of my courses.

                                                                                                                                                                              This is what I wrote:

                                                                                                                                                                              • CPU :: Everything is a memory address
                                                                                                                                                                              • Unix :: Everything is a stream
                                                                                                                                                                              • Lisp :: Everything is a symbol (as in ‘symbolic computation’)
                                                                                                                                                                              • Erlang :: Everything is an actor
                                                                                                                                                                              • Prolog :: Everything is a relation
                                                                                                                                                                              • Haskell :: Everything is a function
                                                                                                                                                                              • Mathematics :: Everything is a set
                                                                                                                                                                              1. 10

                                                                                                                                                                                Lisp :: Everything is a symbol (as in ‘symbolic computation’)

                                                                                                                                                                                In lisp, everything is a cons cell, an atom (‘symbol’), or nil.

                                                                                                                                                                                CPU :: Everything is a memory address

                                                                                                                                                                                On a CPU, there are usually two or three types of operands (depending on if RISC or CISC): registers, immediates, and (only on CISC) memory operands.

                                                                                                                                                                                Memory operands are composed of a combination of registers and immediates. The point being that you take a value which is nominally an integer and treat it as a memory address in a specific context. So I don’t think it’s very useful to say that everything is a memory address.

                                                                                                                                                                                Unix :: Everything is a stream

                                                                                                                                                                                Streams are a very important part of unix, but they’re not the totality. In the unix programming language, functions are called ‘processes’ and data comes from ‘files’ (though “stream,” as you call it, is perhaps the clearer word). Data and data structures are (arguably) more important than the transformations we define on them, but the process model is an indisputably an integral part of unix.

                                                                                                                                                                                Haskell :: Everything is a function

                                                                                                                                                                                In untyped lambda calculus, everything is a function. Haskell has types, as well as laziness and boatloads of other junk.

                                                                                                                                                                                Mathematics :: Everything is a set

                                                                                                                                                                                I think this one is the truest, if perhaps also the most literal.

                                                                                                                                                                                1. 3

                                                                                                                                                                                  Nice, thanks for diving in. I knew some were inaccurate as I wrote them but got the general idea across, I should have added tcl’s ‘everything is a string’, I think that holds up pretty well.

                                                                                                                                                                                  1. 1
                                                                                                                                                                                    Mathematics :: Everything is a set
                                                                                                                                                                                    

                                                                                                                                                                                    (or a category or a type)

                                                                                                                                                                                    (although at least type theory really rejects the idea that everything is X, by explicitly saying that ⊤ is different from ⊥, and ne’er the twain shall meet)

                                                                                                                                                                                    (I don’t know about category theory)

                                                                                                                                                                                  2. 5
                                                                                                                                                                                    • APL :: Everything is an array
                                                                                                                                                                                    1. 3

                                                                                                                                                                                      Smalltalk :: Everything is an object

                                                                                                                                                                                      Pascal :: Everything is a procedure

                                                                                                                                                                                      Plan 9 :: Everything is a file system

                                                                                                                                                                                      1. 1

                                                                                                                                                                                        Mathematics :: Everything is a set

                                                                                                                                                                                        And all sets are categories.

                                                                                                                                                                                        1. 1

                                                                                                                                                                                          Matter and pattern is what the universe is made of, these words are etymologically related to the words ‘mother’ and ‘father’ for a reason.

                                                                                                                                                                                          Math represents one with elements (in sets) and the other with morphisms (in categories). One implies the other as we know, so the universe is built on circular reasoning :)

                                                                                                                                                                                          1. 4

                                                                                                                                                                                            Your etymology is highly suspect, as is all reasoning derived from it.

                                                                                                                                                                                            1. 0

                                                                                                                                                                                              You don’t like to have fun? I think this is a nice perspective and it has given me something so I figured I’d share it..

                                                                                                                                                                                              I agree that it’s all ‘highly suspect’ - I wouldn’t base any important decisions on such “reasoning” ;)

                                                                                                                                                                                              But at least for ‘pattern’ we have ‘patron’ as a root which comes from ‘father’, with such old words it’s hard to make any strong claims.

                                                                                                                                                                                              1. 1

                                                                                                                                                                                                Nothing you say is accurate.

                                                                                                                                                                                                1. 1

                                                                                                                                                                                                  Nothing you say is substantial.

                                                                                                                                                                                      1. 15

                                                                                                                                                                                        The author presents code equivalent to char* p = malloc(8); char* q = p + 4; *q; and argues that it’s not useful to null-check q — because if malloc() returns NULL, then q would be 0x4, not 0x0 (thus passing the null check).

                                                                                                                                                                                        However, this is begging the question — q is only able to have an invalid but non-null value after neglecting to null-check p in the first place.

                                                                                                                                                                                        I don’t find the article convincing. Just because memset() needs to be usable with any mapped address (which might include 0x0) doesn’t mean that we shouldn’t check for NULL ever.

                                                                                                                                                                                        1. 10

                                                                                                                                                                                          While his example of passing 0x4 might be bogus, the overall message isn’t. He’s not saying “never check for NULL” (because his sample function dup_to_upper() does check for NULL when it calls malloc()) but the immediate reflex to check the input pointer for NULL won’t really help when there are a large number of invalid addresses that aren’t NULL that could be passed in.

                                                                                                                                                                                          The point he made was better made in the book Writing Solid Code. That book changed how I code C, and now, instead of:

                                                                                                                                                                                          char *foo(char *s)
                                                                                                                                                                                          {
                                                                                                                                                                                            if (s == NULL)
                                                                                                                                                                                              return NULL;
                                                                                                                                                                                            ...
                                                                                                                                                                                          }
                                                                                                                                                                                          

                                                                                                                                                                                          but instead:

                                                                                                                                                                                          char *foo(char *s)
                                                                                                                                                                                          {
                                                                                                                                                                                            assert(s != NULL);
                                                                                                                                                                                            ...
                                                                                                                                                                                          }
                                                                                                                                                                                          

                                                                                                                                                                                          In my mind, unless I have a very good reason, passing in NULL to a function is a bug. Checking for NULL and returning an error is quite possibly hiding a real bug. Why are you passing NULL? How did that NULL get there in the first place? Are you not checking for NULL elsewhere?

                                                                                                                                                                                          1. 2

                                                                                                                                                                                            Out of interest, why assert() instead of using the ptr and allowing the SEGV signal handler and/or core give you similar info?

                                                                                                                                                                                            1. 9

                                                                                                                                                                                              Some reasons off the top of my head:

                                                                                                                                                                                              • To catch the null pointer as soon as possible. Otherwise, it may be propagated further and cause a segfault much farther away, which is harder to debug. Much more so if a null/corrupt pointer is stored in some data structure instead of just passed to callees, since the stack trace is no longer useful in that case.
                                                                                                                                                                                              • To document the expectations of the function to future developers.
                                                                                                                                                                                              • You can redefine ASSERT() in debug builds to fail unit tests if they are running, which is more dev-friendly than crashing your test system.
                                                                                                                                                                                              1. 1

                                                                                                                                                                                                The “find the NULL as soon as possible” makes most sense to me. I guess I was thinking that using it (straight away) would provide this, but I agree we may do non-dangerous things (like storing it somewhere) before we deref it.

                                                                                                                                                                                                Thank you.

                                                                                                                                                                                                1. 1

                                                                                                                                                                                                  Beside future developers, they’re also useful for documenting expectations for static analysis tools. The Clang static analyzer, for example, takes them into account.

                                                                                                                                                                                                2. 1

                                                                                                                                                                                                  Some systems are configured to allow mapping memory at NULL, which would open up a potential NULL ptr deref vulnerability wherein arbitrary data was stuffed at 0x0.

                                                                                                                                                                                                3. 2

                                                                                                                                                                                                  I love using assert. It’s simple and concise. In a project I wrote to integrate with Pushover, I use assertions at the beginning of any exported function that takes pointers as arguments.

                                                                                                                                                                                                  Sample code:

                                                                                                                                                                                                  EXPORTED_SYM
                                                                                                                                                                                                  bool
                                                                                                                                                                                                  pushover_set_uri(pushover_ctx_t *ctx, const char *uri)
                                                                                                                                                                                                  {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	assert(ctx != NULL);
                                                                                                                                                                                                  	assert(uri != NULL);
                                                                                                                                                                                                  	assert(ctx->psh_uri == NULL);
                                                                                                                                                                                                  
                                                                                                                                                                                                  	ctx->psh_uri = strdup(uri);
                                                                                                                                                                                                  	return (ctx->psh_uri != NULL);
                                                                                                                                                                                                  }
                                                                                                                                                                                                  

                                                                                                                                                                                                  Also: I almost always use calloc over malloc, so that I know the allocation is in a known state. This also helps prevent infoleaks for structs, including compiler-introduced padding between fields. Using calloc does provide a little perf hit, but I prefer defensive coding techniques over performance.

                                                                                                                                                                                                  1. 1

                                                                                                                                                                                                    The one issue with using calloc() is that a NULL pointer on a system does not have to be all-zero (C standard, POSIX requires a NULL pointer to be all zeros). Yes, in source code, a literal 0 in a pointer context is NULL, but internally, it’s converted to whatever the system deems a NULL address.

                                                                                                                                                                                                    I’ve used a custom malloc() that would fill memory with a particular value carefully selected per architecture. For the x86, it would fill the memory with 0xCC. As a pointer, it will probably crash. As an unsigned integer, it’s a sizable negative number. As an unsigned integer, it’s a large number. And if executed, it’s the INT3 instruction, aka, breakpoint. For the Motorola 68000 series, 0xA1 is a good choice—for all the above, plus it can cause a misaligned read access for 16 or 32 bit quantities if used as an address. I forgot what value I used for MIPS, but it was again, for the same reasons.

                                                                                                                                                                                                  2. 2

                                                                                                                                                                                                    The use of assert() here goes against sanitary program behaviour. Returning an error (while printing out useful information) is preferable (for example in Koios I used an enum for errors, null is represented as KERR_NULL) because the program can then act on that and save state, even if some of it might be non-useful, saving as much as is possible is just generally good behaviour. It also allows you to do more with that. Maybe you want to recheck assumptions and reload data, or some other kind of error-avoidance/compensation.

                                                                                                                                                                                                    How would you like it, as a user, if Firefox or Libreoffice, or other programs in which people tend to commonly work, just up and failed for (to the user) no observable reason?

                                                                                                                                                                                                    I don’t see how this is good guidance for anything but the simplest of C programs.

                                                                                                                                                                                                    edit: I forgot about NDEBUG.

                                                                                                                                                                                                    But that in effect makes the check useless for anything but (isolated) testing builds.

                                                                                                                                                                                                    Checking for NULL and returning an error is quite possibly hiding a real bug.

                                                                                                                                                                                                    I really don’t see how. Reporting an error and trying to compensate, either by soft-crashing after saving state, or using other / blacklisting data-sources, is not ‘hiding’ a bug. It’s the bare minimum any program should do to adapt to real world cases and scenarios.

                                                                                                                                                                                                    1. 4

                                                                                                                                                                                                      The use of assert() here goes against sanitary program behaviour. Returning an error (while printing out useful information) is preferable (for example in Koios I used an enum for errors, null is represented as KERR_NULL) because the program can then act on that and save state, even if some of it might be non-useful, saving as much as is possible is just generally good behaviour. It also allows you to do more with that. Maybe you want to recheck assumptions and reload data, or some other kind of error-avoidance/compensation.

                                                                                                                                                                                                      Assertions are intended for catching bugs not recoverable errors. An error that isn’t recoverable or was unexpected has occurred and it isn’t safe to continue program execution.

                                                                                                                                                                                                      How would you like it, as a user, if Firefox or Libreoffice, or other programs in which people tend to commonly work, just up and failed for (to the user) no observable reason?

                                                                                                                                                                                                      Many large systems including Firefox, the Linux kernel, LLVM, and others use a combination of assertions and error recovery.

                                                                                                                                                                                                      Assertion usage is one of the rules in NASA’s The Power of Ten – Rules for Developing Safety Critical Code.

                                                                                                                                                                                                      1. Rule: The assertion density of the code should average to a minimum of two assertions per function. Assertions are used to check for anomalous conditions that should never happen in real-life executions.
                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                        An error that isn’t recoverable or was unexpected has occurred and it isn’t safe to continue program execution.

                                                                                                                                                                                                        A null pointer error doesn’t automagically invalidate all of the state that the user put into the program expecting to get it out again.

                                                                                                                                                                                                        Many large systems including Firefox, the Linux kernel, LLVM, and others use a combination of assertions and error recovery.

                                                                                                                                                                                                        Of course.

                                                                                                                                                                                                        Assertion usage is one of the rules in NASA’s The Power of Ten – Rules for Developing Safety Critical Code. […]

                                                                                                                                                                                                        Right, but that’s not the usage of the above null check, which advocates for never saving state on null, ever.

                                                                                                                                                                                                      2. 2

                                                                                                                                                                                                        If the documentation says “this function requires a valid pointer”, why would I bother checking for NULL and returning an error? It’s a bug if NULL is passed in. The assert() is there just to make sure. I just checked, and when I pass NULL to memset() it crashed. I’m not going to blame memset() for this, as the semantics of the function don’t make sense if NULL is passed in for either of its functions.

                                                                                                                                                                                                    2. 6

                                                                                                                                                                                                      I just want to salute you for using “begging the question” to describe circular reasoning. I don’t often see that original meaning in the wild.

                                                                                                                                                                                                      1. 2

                                                                                                                                                                                                        Assuming NULL is 0x0 is wrong. Of course. The article’s entire argument falls down right there.

                                                                                                                                                                                                        1. 2

                                                                                                                                                                                                          On what architectures is NULL not 0x0? I can’t seem to think of any off-hand.

                                                                                                                                                                                                          1. 3

                                                                                                                                                                                                            Multics has it be -1, AFAIK. Probably not anything with non-integer pointers either like x86 segmentation.

                                                                                                                                                                                                            1. 1

                                                                                                                                                                                                              Here’s a good page on exactly that question: http://c-faq.com/null/machexamp.html

                                                                                                                                                                                                        1. 34

                                                                                                                                                                                                          There are no inline links (every link goes on its own line), no formatting, and no inline images

                                                                                                                                                                                                          So it’s borderline useless for all but the simplest use cases, and even there it does a very subpar job. I’d like to have an inline image every now and then, or organize things in some multi-column layouts or the like, or a table. 19th century newspapers could do this, and if your technology can’t emulate typography produced on a daily basis – often in a hurry – 150 years ago then your tech is rather limited.

                                                                                                                                                                                                          These protocols keep shooting themselves in the head with stuff like this, not even in the foot because this entire thing is dead on arrival for all but a few niche tech folk.

                                                                                                                                                                                                          1. 17

                                                                                                                                                                                                            I see this a lot, and I really, really wish that the people making this case would actually try to use Gemini for what it is before bringing their preconceptions into it. Easily a full third of the people I’ve spoken to about Gemini immediately start talking about some $FEATURE that they would add to it - and I’ve heard a lot of different features. Do you see the problem with this? This is just a recipe for re-inventing the bloat of the web.

                                                                                                                                                                                                            You must first use, then understand, then change the software. You can’t skip steps one and two. It is possible to express yourself within these constraints (you’re already expressing yourself within some fairly arbitrary constraints right now, for instance, imposed by Lobsters’ strict markdown rules), and you should first apply a little bit of creativity to the new medium before you try to bend the medium to your will. We don’t really want it bent, we’re doing something different for a reason.

                                                                                                                                                                                                            By the way, your comment can be losslessly represented in Gemtext.

                                                                                                                                                                                                            1. 7

                                                                                                                                                                                                              Easily a full third of the people I’ve spoken to about Gemini immediately start talking about some $FEATURE that they would add to it - and I’ve heard a lot of different features. Do you see the problem with this? This is just a recipe for re-inventing the bloat of the web.

                                                                                                                                                                                                              I’d argue that this is because the problems it solves are inherently complex, so any good solution to it will be complex as well. That doesn’t mean I don’t think the web can’t be improved or made simpler – it’s an organically grown mess of 25 years – but it will never be replaced by a dead-simple solution such as Gemini.

                                                                                                                                                                                                              And yeah, my Lobsters comments can be expressed in Gemini without much loss (except the inline links thing), but Lobsters isn’t my website though and I wouldn’t be able to express my fairly simple website on Gemini, or a fairly simple site as Wikipedia. And even the entire Lobsters website would be a worse UX in Gemini as it precludes any sort of design.

                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                Gemini does not preclude any sort of design, not at all - it just gives the responsibility for design to the client, not to the server.

                                                                                                                                                                                                                1. 2

                                                                                                                                                                                                                  But isn’t this very limiting? Like, it would work for your blog, but in its current iteration adding a table would already be difficult, never mind something more advanced like the fivethirtyeight election forecast and results.

                                                                                                                                                                                                                  I suppose it all depends what your vision for Gemini is; if you want it to replace large parts of the web then it’s got basically 0 chance in its current state; if you just want some alternative to use yourself and like-minded people, then sure, go for it.

                                                                                                                                                                                                                  1. 1

                                                                                                                                                                                                                    Of course Gemini doesn’t preclude design: It’s a networking protocol. You can use it to move HTML and JS and CSS and images and whatever else just fine.

                                                                                                                                                                                                                    Attempting to conflate a protocol with a document format is wrong.

                                                                                                                                                                                                                    1. 1

                                                                                                                                                                                                                      The specification also includes a document format, as well as a networking protocol.

                                                                                                                                                                                                                      Arguably, things would have been clearer if they were separated out more clearly, but this would kind of defeat the point of Gemini. The networking protocol and document format are intended to be used together.

                                                                                                                                                                                                                2. 6

                                                                                                                                                                                                                  It seems interesting; to make it clear, I do hate tracking too, as well as inaccessibility & various Flash-equivalents of today. And dependency on the complexity tower of Chrome/Firefox/… So I’m certainly curious about alternatives to the current status quo.

                                                                                                                                                                                                                  I do understand that the protocol seems to allow for a lot of expression, and more “slow-food” style, relaxed consumption. Yet, I cannot escape immediately having a feeling of loss. If I understand this correctly, with no mathematical equations support, I would not be able to write or consume an article trying to explain Shor’s algorithm. With no graphs support, I assume whenever I’d want to display graphs, I’d have to resort to ASCII-Art as a workaround, with necessarily limited precision (for example, no smooth curves or complex 3D surfaces). Finally, I assume I would not be able to write or consume an article about typography, or bysantine icons. Or am I wrong?

                                                                                                                                                                                                                  Having the concerns mentioned above, I’m immediately starting to think about possible workarounds. I am assuming people would start resorting to “rich clients” - for example, with support for rendering of some kinds of mathematical equations. This, I am guessing, would quickly lead to on-site recommendations like: “This page requires support for LaTeX-Super-Renderer-3.7”. De-facto becoming in-band signaling of the kind Gemini apparently tries to dispell by “only allowing one field in response, the mimetype”. But wouldn’t people start doing that anyway, and start writing such plugins anyway, and start de-facto reinventing HTML anyway? With the likes of Flash plugins of yore raising from the dead in new clothes?

                                                                                                                                                                                                                  With regards to just graphs and images, I believe it could be somewhat easier actually. I am now reminded of the days of my childhood, when books in my country were mostly in black and white, with a few pages in the center being in color, and being referenced to by the b&w pages (“See illustration 7.b.”). I imagine something like that could work with images being listed, or linked, or attached (?) at the end of a Gemini page. But even then, I don’t think that would be usable for math-heavy documents. And from glancing through the few links around here, it’s not fully clear to me if any images at all, even at the end of a document, are expected to be supported? (Though mimetypes support kinda seems to hint at allowing this?)

                                                                                                                                                                                                                  So, with the ideal of simplicity sounding theoretically interesting and alluring, at the same time I’m concerned about losing access to, especially, maths-related content. (Assuming that some image-heavy, yet comparatively sparse in that regard, content could be possibly approximated with a list of image links at the end, referenced from the main article. Which kinda already sounds like a hack, that would probably soon lead to reintroducing inline images via specialized clients…) That feels like a pity to me.

                                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                                    I do understand that the protocol seems to allow for a lot of expression, and more “slow-food” style, relaxed consumption. Yet, I cannot escape immediately having a feeling of loss. If I understand this correctly, with no mathematical equations support, I would not be able to write or consume an article trying to explain Shor’s algorithm. With no graphs support, I assume whenever I’d want to display graphs, I’d have to resort to ASCII-Art as a workaround, with necessarily limited precision (for example, no smooth curves or complex 3D surfaces). Finally, I assume I would not be able to write or consume an article about typography, or bysantine icons. Or am I wrong?

                                                                                                                                                                                                                    I’ve brought this issue about math up in the past, but remember, nothing is stopping you from using HTML or PDF. Gemini uses Gemtext as a lowest-common-denominator form of markup, but if you are writing a client, you can always built in HTML support or shell out to something else that does.

                                                                                                                                                                                                                  2. 5

                                                                                                                                                                                                                    I think that the reason that people keep trying to suggest features is that Gemini is marketed as a replacement for “the web”, but designed (and only useful) as just a plain text delivery mechanism - there’s (rightly) some cognitive dissonance going on.

                                                                                                                                                                                                                    That is, “the web” includes plain text, hypertext, rich documents, audio/video media, and interactive content. I don’t think that most people expect Gemini to implement the last two, but there’s some reasonable expectation that something trying to replace “the web” should at least be able to represent reasonably interesting documents - such as scientific papers, which Gemini clearly cannot.

                                                                                                                                                                                                                    Perhaps if proponents of Gemini stopped trying to claim that it could actually replace anything but the tiniest slice of the web that is pure, plain text (not hypertext, as inline links are really important), you would stop getting people talking about adding features.

                                                                                                                                                                                                                    Edit: that is, there’s no “preconception” going on here. GP post is responding to the argument that Gemini is a viable replacement for the web by pointing out that it is missing critical features for actually acting as a sane replacement, which has no “preconception” - it’s just a statement of fact. You cannot replace the web without inline links, formatting, or inline images, full stop.

                                                                                                                                                                                                                    1. 1

                                                                                                                                                                                                                      You cannot replace the web without inline links, formatting, or inline images, full stop.

                                                                                                                                                                                                                      As a matter of fact, you can. Full stop.

                                                                                                                                                                                                                      1. 7

                                                                                                                                                                                                                        …that’s so obviously false that I shouldn’t need counterexamples, but here they are:

                                                                                                                                                                                                                        https://graphicallinearalgebra.net/2015/04/26/adding-part-1-and-mr-fibonacci/

                                                                                                                                                                                                                        http://foldr.org/mw/emacs/

                                                                                                                                                                                                                        http://507movements.com/

                                                                                                                                                                                                                        https://lobste.rs/

                                                                                                                                                                                                                        https://www.av8n.com/physics/clifford-intro.htm

                                                                                                                                                                                                                        None of these sites, or the majority of the thousands of other bookmarks that I have, can be replaced without inline links, formatting, or images.

                                                                                                                                                                                                                        Linked files do. Not. Cut. It.

                                                                                                                                                                                                                        Not only are linked (vs. inline) files objectively and meaningfully different (and, therefore, you cannot replace the web with them), but they are inferior from an information-processing standpoint. From both a practical and theoretical level, you cannot replace the web with Gemini as it currently stands. People will not use it, they are not equivalent, and I, personally, will discourage people from using it - it is a cognitive anti-tool, similar to a reverse printing press. Useful for implementors, terrible for anyone who actually wants to read documents and exchange information that will actually help them to learn and reason.

                                                                                                                                                                                                                        1. 0

                                                                                                                                                                                                                          I can provide another counter-example: you had 5 links in your comment, none of which were inlined, despite having access to inline links on lobsters.

                                                                                                                                                                                                                          You can’t place identical content on Gemini as you can on the web. You can reformat your content for the new medium. Nothing transitions between mediums without change.

                                                                                                                                                                                                                          Gemini replaces a subset of the web, which I stated in the opening article and have re-iterated dozens of times.

                                                                                                                                                                                                                          1. 4

                                                                                                                                                                                                                            I can provide another counter-example: you had 5 links in your comment, none of which were inlined, despite having access to inline links on lobsters.

                                                                                                                                                                                                                            …that’s not a counter-example. I never claimed that you can’t replace any of the content on the internet, which is what that statement would be a counter-example to. Perhaps you should take a logic course. Edit: that was too aggressive, my apologies.

                                                                                                                                                                                                                            Edit: I claimed that you cannot replace “the web”, which implies replacing the majority of the content at least, and all of the content at most.

                                                                                                                                                                                                                            You can’t place identical content on Gemini as you can on the web. You can reformat your content for the new medium.

                                                                                                                                                                                                                            …and, as it should be very clear, that re-formatting process is (1) lossy and (2) causes a significant decrease in readability and information processing - meaning that it is not a replacement. The format of the web is part of the web, therefore you cannot replace the web with Gemini.

                                                                                                                                                                                                                            Gemini replaces a subset of the web, which I stated in the opening article and have re-iterated dozens of times.

                                                                                                                                                                                                                            You have tried to claim that Gemini can replace anything but the tiniest trivial slice of the web that is pure, un-hyperlinked plain-text - which, as shown above, is false. The format of the web is part of the web. The content and the medium are entwined.

                                                                                                                                                                                                                            1. 2

                                                                                                                                                                                                                              Anything with “less features” is lossy, but that’s not correlated with a “significant decrease in readability”. On the other hand, putting the presentation entirely into the client’s control is a significant win for readability, because the user can configure fonts, contrast, and layout to their preferences and usability needs. The screen reader experience, for instance, is WAY better. Inline links and inline formatting are less accessible to some.

                                                                                                                                                                                                                              1. 4

                                                                                                                                                                                                                                Anything with “less features” is lossy

                                                                                                                                                                                                                                Only true in the most needlessly pedantic sense. You can easily build systems with a small set of carefully-chosen features that still implement the vast majority of the functionality of larger systems that were poorly-built. This…does not describe Gemini. Gemini picked a basis of features that do not allow it to implement more complex functionality or richer documents.

                                                                                                                                                                                                                                that’s not correlated with a “significant decrease in readability”

                                                                                                                                                                                                                                Not in general, sure - but in the case of Gemini, it’s pretty clear that there is a significant decrease in readability (and, therefore, cognitive processing ability). Requiring users to click through to a separate document for each image, animation, or individual mathematical equation is extremely unreadable for anything with a reasonable density of those things - while “only” being merely slightly less readable for documents with only a few of those objects.

                                                                                                                                                                                                                                On the other hand, putting the presentation entirely into the client’s control is a significant win for readability the user can configure fonts, contrast, and layout to their preferences and usability needs

                                                                                                                                                                                                                                You can already almost entirely control presentation with major browsers for the current web, through userscripts and stylesheets.

                                                                                                                                                                                                                                Moreover, HTML is actually structured, unlike Gemtext, so I have anchor points and document metadata that I can use to exert more control over my content than with unstructured Gemtext - so your statement is actually untrue.

                                                                                                                                                                                                                                The screen reader experience, for instance, is WAY better.

                                                                                                                                                                                                                                Modern web gives you more options to make a good screen reader experience - such as image alt text. Is it really inconsistently used? Sure, but that’s not a technical problem, that’s a social one - a social one that manifests itself in an equally bad way with Gemini, because Gemtext doesn’t have any way to bind accessibility-related metadata to document structure, because there is no document structure.

                                                                                                                                                                                                                                Inline links and inline formatting are less accessible to some.

                                                                                                                                                                                                                                Expanding links and controlling inline formatting are very basic features for screen readers.

                                                                                                                                                                                                                                So, to summarize, modern web gives you a much richer interface for screen readers, as well as a better interface for people who don’t use screen readers (which is the majority).

                                                                                                                                                                                                                                Gemtext is straight-up less conducive to thought and information transfer.

                                                                                                                                                                                                                                1. 2

                                                                                                                                                                                                                                  I think “significant decrease in readability” is interpreted a little too literally here.

                                                                                                                                                                                                                                  Many of the documents linked by fouric would be way more inconvenient to read if they were adapted to fit in gemini’s limitations because of how heavily they rely on tables, anchor links to a specific part of the same document, and inline images (especially with how inconsistent most clients available today are at dealing with non-gemtext content types).

                                                                                                                                                                                                                                  I personally am a big fan of how gemtext files only ever result in a single request due to the lack of stylesheets, scripting, and inline resources, and have pushed back on the adoption of HTML and Markdown as alternate document content types because I think that is a valuable part of the protocol. I’m also not delusional: the stance I hold also directly limits the mass appeal of gemini as a technology, because normal people who just want to read these kinds of documents are unlikely to accept what seems like massive inconvenience for technical reasons they don’t fully understand. They’ll just stick to the Web.

                                                                                                                                                                                                                                  I am willing to put up with that inconvenience as a reader and writer of gemtext content because I think the other benefits of gemini are worth it, but I don’t expect anyone who isn’t another disillusioned Web developer to get on board quite as easily.

                                                                                                                                                                                                                      2. 2

                                                                                                                                                                                                                        How would metafilter-style writing look, with lots of inline links? Examples appreciated.

                                                                                                                                                                                                                        1. 7

                                                                                                                                                                                                                          You just wouldn’t have lots of inline links. You’d have a separate list of references, perhaps. Here are some examples of Gemini posts I have written with lots of links:

                                                                                                                                                                                                                          https://portal.drewdevault.com/2020/11/01/What-is-Gemini-anyway.gmi

                                                                                                                                                                                                                          https://portal.drewdevault.com/2020/10/22/Firefox-the-embarassment-of-FOSS.gmi

                                                                                                                                                                                                                          https://portal.drewdevault.com/2020/10/01/Spamtoberfest.gmi

                                                                                                                                                                                                                          Let me put it this way: how would inline links work in a newspaper, book, or magazine? The answer is: they wouldn’t, and you just work within those limitations. That doesn’t mean the medium is bad.

                                                                                                                                                                                                                      3. 6

                                                                                                                                                                                                                        19th century newspapers could do this, and if your technology can’t emulate typography produced on a daily basis – often in a hurry – 150 years ago then your tech is rather limited.

                                                                                                                                                                                                                        Not arguing against you, but when it comes to web browsers, then they still haven’t learnt to properly hyphenate text. Another thing we could do 150 years ago. One of the reasons (another being rather poor support for rendering maths, or, in the case of Chromium, complete lack of it) I’m relieved whenever I get to read a PDF generated from LaTeX instead of a webpage.

                                                                                                                                                                                                                        1. 5

                                                                                                                                                                                                                          You can manually hyphenate with soft hyphens like you did 150 years ago just fine.

                                                                                                                                                                                                                          Automating hyphenation is nearly impossible. LaTeX certainly requires some manual help.

                                                                                                                                                                                                                          1. 2

                                                                                                                                                                                                                            If I use soft hyphens, then copying He&shy;re are rhi&shy;nos. to terminal results in He re are rhi nos. visually, because it copied the text with the soft hyphens even though everything was on a single line.

                                                                                                                                                                                                                            LaTeX certainly requires some manual help.

                                                                                                                                                                                                                            It never required it when I used it. When you enable correct language support, it should just work.

                                                                                                                                                                                                                            1. 3

                                                                                                                                                                                                                              That’s because your terminal is 1970s computer technology.

                                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                                No. That’s because I copied text, but received bytes instead.

                                                                                                                                                                                                                                FWIW it doesn’t happen with hyphenate: auto in CSS, but that’s only supported by Firefox, so it’s irrelevant.

                                                                                                                                                                                                                              2. 2

                                                                                                                                                                                                                                150 years ago you couldn’t copy manually-hyphenated text from your newspaper in to your terminal.

                                                                                                                                                                                                                                1. 2

                                                                                                                                                                                                                                  I thought this analogy was cute for a little bit. But seriously, why is 150 years ago the standard? Are we really that painfully nostalgia-blind that we can’t recognize there’s a medium point between the old and the new?

                                                                                                                                                                                                                                  1. 3

                                                                                                                                                                                                                                    It isn’t my standard, and frankly I don’t really care what we could / couldn’t do 150 years ago because I don’t believe it matters in the context of what are we doing, trying to do, and can’t do today.

                                                                                                                                                                                                                            2. 4

                                                                                                                                                                                                                              Firefox does hyphenation with hyphens: auto; if you set the document language.

                                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                                Does Gemini support setting the document language?

                                                                                                                                                                                                                                1. 2

                                                                                                                                                                                                                                  A quick search on the specification shows it does. So hyphenation working on gemini or not would be a matter of the client implementing it.

                                                                                                                                                                                                                              2. 2

                                                                                                                                                                                                                                Well, 150 years ago it was a manual process, and not an automatic one :-) I regularly insert &shy for this on my website by the way. But yeah, I agree that the lack of a universally supported hyphenate: auto has been long overdue (only Firefox supports it, and it doesn’t even do a great job at it, although I don’t know if there are technical reasons that prevent it from doing a better job; I think I saw someone on HN detail some issues with automatic hyphenation on the web years ago, but I forgot what they were).

                                                                                                                                                                                                                                Math rendering has also been supported by Firefox for 15 years with MathML, but for some reason Chrome doesn’t (but Safari does). Actually, looks like they removed it in Chrome years ago, although it looks like there’s work to add it back soon-ish.

                                                                                                                                                                                                                                1. 1

                                                                                                                                                                                                                                  Actually, along with Firefox, some versions of Chrome (Android & Mac) support auto hyphenation, and Safari has it hidden behind a prefix: https://caniuse.com/css-hyphens I feel that together these may cover enough of the market to make it worth adding to web pages.

                                                                                                                                                                                                                                  If you want to see a quick and stupid demo, here’s my very unfinished Hugo theme I’m working on developing: https://www.maximumethics.dev/blog/2020/07/my-first-post/ If you shrink the viewport width until it’s skinny like a phone, you’ll see the longer 90 chars “alphabet” line break to hyphenate (on the aforementioned supported browsers), as well as random words in the text.

                                                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                                                    Ah yeah, it’s just the desktop version that doesn’t support it for some weird reason; I forgot about that detail.

                                                                                                                                                                                                                                    I suppose it depends what you use it for: most of the time I really wanted auto hyphenation is for comparatively narrow pieces of text and/or for text-align: justify (e.g. a sidebar or info box). In those cases the hyphenation (manual or automatic) is pretty much a must-have rather than a nice-to-have, because without it it just looks ugly. Your site, on the other hand, looks fairly decent without hyphenation even on smaller screens, but it won’t hurt to add it for browsers that support it.

                                                                                                                                                                                                                                  2. 1

                                                                                                                                                                                                                                    Math rendering has also been supported by Firefox for 15 years with MathML, but for some reason Chrome doesn’t (but Safari does). Actually, looks like they removed it in Chrome years ago, although it looks like there’s work to add it back soon-ish.

                                                                                                                                                                                                                                    That’s what I was on about. If something isn’t available in Chrome, it’s irrelevant these days. I’ve been aware that “it looks like there’s work to add it back soon-ish” for quite some time now. I don’t have hope.

                                                                                                                                                                                                                                2. 5

                                                                                                                                                                                                                                  I think the idea is that the publisher delivers only the information, not the presentation. This constraint allows for greater user control over presentation, for example one might configure Gemini to lay out news articles (maybe on a site by site basis) in a column style, to suit their preferences. I think it’s an interesting idea as a way of making better typesetting more widely available to content published on sites without the budget / know-how to tune their CSS for readability.

                                                                                                                                                                                                                                  I agree that Gemini would be better off if it supported inline images. That’s pretty often part of the information layer.

                                                                                                                                                                                                                                  1. 6

                                                                                                                                                                                                                                    I think the idea is that the publisher delivers only the information, not the presentation.

                                                                                                                                                                                                                                    Wait! That is HTML! (as compared to PDF)

                                                                                                                                                                                                                                    1. 6

                                                                                                                                                                                                                                      Not really, HTML still focuses a lot on presentation. Headers, side bars, footers, nagivation line, footnotes, etc. are all concepts foreign to the browser, that have to be manually re-implemented in the markup language, again and again. That’s actually what I think that protocols like Gemini misunderstand: HTTP/HTML is not too systamatically complicated (at most it’s “organically” complicated), it’s actually too simple. If for example the <head> section had made it possible to describe how a web-page is navigated, it would have been possible for the browser to render that part of the site, leaving the <body> to be actual content. It’s something you see with other simple languages too: Scheme has various implementations, that implement a common core, but diverge in their additional libraries, that are regarded as useful, but do not allow for code to be portable. So too, had HTTP/HTML has the foresight to recognize what people would want from websites (which is probably too much to ask), or at least the foresight to allow a certain degree of extensibility, a lot of implementation-specific complexity could have probably been avoided.

                                                                                                                                                                                                                                      So the issue might not be “simplicity vs compexity”, but “what kind of complexity”.

                                                                                                                                                                                                                                      1. 3

                                                                                                                                                                                                                                        Years ago I came across a browser extension that would build a navigation bar if it found certain <link> tags in the header. I modified my blogging engine to automatically add said links. Sadly, the extension no longer runs (because of course the extension mechanism changed—at least twice—since then) but I still generate the data in the vain hope it’ll be useful again.

                                                                                                                                                                                                                                    2. 5

                                                                                                                                                                                                                                      A strict separation of information and presentation is something that sounds great in theory, but doesn’t really work all that well in practice once you move beyond the simple use cases, or use cases that are pre-defined and supported in some way.

                                                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                                                        I don’t know if this was part of the design goal - from what I can see, Gemini doesn’t have any sort of mechanism to describe or annotate what content/information is being delivered, which would make any presentation strategy necessarily heuristic, as there would be no way to delineate e.g. where the “author” of the article is.

                                                                                                                                                                                                                                        1. 1

                                                                                                                                                                                                                                          I guess you’d just put that information into the document itself.

                                                                                                                                                                                                                                          One underappreciated tag in HTML is the <address> tag, which is a nice place to put stuff like author, publication date, etc.

                                                                                                                                                                                                                                          1. 1

                                                                                                                                                                                                                                            I’m not quite sure what you mean - when you say “just put that information into the document itself” do you mean in a machine-readable format? Because if so, that’s not part of the Gemini text spec - which is the thing being discussed. Adding tags like <address> would be extending the Gemini spec to add features, which is what proponents of it are fiercely against.

                                                                                                                                                                                                                                            1. 1

                                                                                                                                                                                                                                              No, I just meant to add something like

                                                                                                                                                                                                                                              • Author: Gustaf Erikson
                                                                                                                                                                                                                                              • Date: 3 Nov 2020

                                                                                                                                                                                                                                              in the body of the text somewhere.

                                                                                                                                                                                                                                      2. 4

                                                                                                                                                                                                                                        As it has been stated on the mailing list, “you can always serve up text/html or text/markdown, you aren’t limited to text/gemini.” There are sites out there serving up images and even music.

                                                                                                                                                                                                                                        1. 12

                                                                                                                                                                                                                                          Well, that’s not really what’s advocated for in this post (or on the Gemini website as far as I could see), and serving HTML over Gemini just sounds like a s/HTTP/Gemini/, and you can serve text or Markdown over HTTP as well. I don’t really see the point if you’re going to serve HTML over Gemini.

                                                                                                                                                                                                                                        2. 4

                                                                                                                                                                                                                                          I’m just going to drop a link to the FAQ page, in the hopes that it’ll answer some questions here.

                                                                                                                                                                                                                                          1. 3

                                                                                                                                                                                                                                            I’m sick of how complex html+css+js gets, and how complicated extracting the actual content can be, in order to view it on “unusual” platforms (small screens. ereaders, etc.), where a good experience depends on the client controlling the presentation of the content. Something like gemini could be the solution to that, but I have to say, the lack of inline images is a deal-breaker for me.

                                                                                                                                                                                                                                            I view multi-column layouts as part of the presentation, not the content (I don’t want two columns of text on a phone screen: if I do want two columns of text on the desktop, I can write that into the client), but the images are part of the content.

                                                                                                                                                                                                                                            I did wonder whether technically a gemini-ish client could fetch urls which look like they point to images and display them inline, but this is explicitly banned by the specification:

                                                                                                                                                                                                                                            Clients can present links to users in whatever fashion the client author wishes, however clients MUST NOT automatically make any network connections as part of displaying links whose scheme corresponds to a network protocol (e.g. gemini://, gopher://, https://, ftp://, etc.).

                                                                                                                                                                                                                                            I can sort of see what they’re aiming for, presumably trying to avoid the sort of nonsense some websites have become, where the initial request just gets a jumble of html elements that require the client to fetch and execute tons of javascript before they can be assembled into something resembling content, but I think they should have made an exception for images (They could still leave it up to the client whether it displays inline images or not).

                                                                                                                                                                                                                                            Interestingly, gemini probably works really well with screen readers, until you get to an image link (or any link for that matter), at which point it depends entirely on whether the author bothered to provide a caption, or explain what the link is as part of the text (Although that’s arguably no worse than html, where the existence of alt text doesn’t mean that it is always used or used correctly).

                                                                                                                                                                                                                                            1. 5

                                                                                                                                                                                                                                              Another reason to not allow non-user-initiated network connections is that’s abused to track users (Facebook pixel etc).

                                                                                                                                                                                                                                              IMHO this could be sufficiently solved by allowing additional requests to the same domain as the document request.

                                                                                                                                                                                                                                              1. 4

                                                                                                                                                                                                                                                One big reason I’m excited about Gemini is the possibility of escaping the web’s bloat, which we need to do in order to reduce energy usage / emissions in the climate crisis. For this reason, I support Gemini’s decision to ban inline images. If you have inline images, next people will want inline video, and soon even if Gemini is “simpler” it’s using as much storage+bandwidth+processing as a web page.

                                                                                                                                                                                                                                                Inlining images, especially from other locations, is also a plausible method for sneaking user tracking back into the protocol, and I also approve of Gemini’s strong efforts towards privacy. I also hate ads even when they don’t track people, I’d love to live someplace where billboards are banned so I can escape the constant background hum of marketing. Eliminating inline images is also a great way to reduce the annoyance of advertising.

                                                                                                                                                                                                                                                I’m going to have to agree with everyone in this thread that refusing to implement inline links was a mistake, though. That was one of the biggest problems I had with Gopher, and I was hoping Gemini would do a better job with hypertext.

                                                                                                                                                                                                                                                1. 4

                                                                                                                                                                                                                                                  Inlining images, especially from other locations, is also a plausible method for sneaking user tracking back into the protocol, and I also approve of Gemini’s strong efforts towards privacy.

                                                                                                                                                                                                                                                  It’s a very difficult balance to strike between simplicity and functionality. You could probably avoid trackers by, as @m_eiman says, only allowing additional requests from the same domain as the original document.

                                                                                                                                                                                                                                                  Alternatively, you could create/use a format which embeds the images directly in the original document (similar to how pdf or epub does). Some might argue that this is inefficient, as you need to serve multiple copies of the image data if it appears on multiple pages. However, in this context, it could be seen as a feature, as we don’t want the kind of images (such as ads) which aren’t actually “part of the document”.

                                                                                                                                                                                                                                                  There will always be some people who abuse any protocol, but not having inline images is very limiting and means it isn’t any good for a significant portion of (what I consider) “good content that doesn’t need javascript/css”.

                                                                                                                                                                                                                                              2. 1

                                                                                                                                                                                                                                                I’d like to have an inline image every now and then

                                                                                                                                                                                                                                                Might I ask what’s wrong with merely providing a link to the image?

                                                                                                                                                                                                                                                or a table.

                                                                                                                                                                                                                                                This can be easily done with some ASCII art (which is what you do for Markdown, anyways) coupled with a preformatted block.

                                                                                                                                                                                                                                                1. 10

                                                                                                                                                                                                                                                  This can be easily done with some ASCII art…

                                                                                                                                                                                                                                                  But ASCII art is pretty much the quintessence of mixing presentation and content, which is very specifically what Gemini seeks to avoid. It can’t wrap or scroll differently on small devices, it can’t be extracted (easily and reliably) to a machine-readable data format, and it isn’t accessible because there’s no semantic information about the table structure.

                                                                                                                                                                                                                                                  1. 3

                                                                                                                                                                                                                                                    You’re right. I kinda hope some kind of table syntax does make it into the Gemini spec after all.

                                                                                                                                                                                                                                                  2. 3

                                                                                                                                                                                                                                                    I need to click a link to an image? It seems pretty obvious to me that this is worse UX than just displaying it.

                                                                                                                                                                                                                                                    ASCII art relies on a monospaced font, which I don’t really like for reading text. I think Lobsters would be significantly worse if it was all monospaced text for example. It also relies on a certain screen size, which doesn’t work for smaller screens (or very big ones, for that matter). I mean, it kinda works but it’s a hack.

                                                                                                                                                                                                                                                    1. 2

                                                                                                                                                                                                                                                      I need to click a link to an image? It seems pretty obvious to me that this is worse UX than just displaying it.

                                                                                                                                                                                                                                                      Yeah. You’re completely right, this is worse UX. I’m beginning to think of proposing an inline-image syntax for the gemini spec.

                                                                                                                                                                                                                                                      ASCII art relies on a monospaced font, which I don’t really like for reading text.

                                                                                                                                                                                                                                                      I admit I was wrong. ASCII tables are a hack, I suppose. Hopefully the simple table syntax I’m thinking of right now makes it into the spec!

                                                                                                                                                                                                                                                      I think Lobsters would be significantly worse if it was all monospaced text for example. It also relies on a certain screen size, which doesn’t work for smaller screens (or very big ones, for that matter). I mean, it kinda works but it’s a hack.

                                                                                                                                                                                                                                                      FYI there are gemini clients that support variable-width fonts.

                                                                                                                                                                                                                                                      1. 4

                                                                                                                                                                                                                                                        FYI there are gemini clients that support variable-width fonts.

                                                                                                                                                                                                                                                        I tried to use it with Gopher years ago (I hacked up an existing client), and many sites don’t really work all that well because they assume stuff will be displayed as monospaced text (such as tables you mentioned, but also things like code examples, or other alignment things).

                                                                                                                                                                                                                                                        Gemini is a bit of an improvement because the spec at least recognizes that proportional text exits and has “code blocks”, but it also leaves much to the clients. In other words: I wouldn’t be surprised if people would just keep using it as they used Gopher, and the weird (and IMO, broken) way line wrapping works in Gemini doesn’t help either. I suppose time will tell how it will be used in practice (but as mentioned, I don’t think it will be used much in practice beyond a few “Hacker blogs” like Drew’s).

                                                                                                                                                                                                                                                        One of the big mistakes of HTML was, ironically, to “leave it up to the clients” which resulted in a big mess which had to be unified so that people could get a reasonably consistent experience irregardless of which browser they use, but that just unified the mess instead of clearing it up.

                                                                                                                                                                                                                                                    2. 1

                                                                                                                                                                                                                                                      I use HTML to add tables to my Markdown content.

                                                                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                                                                        I personally find HTML’s table syntax difficult to read and use.

                                                                                                                                                                                                                                                        1. 4

                                                                                                                                                                                                                                                          Yep, I usually whip up a quick Perl script with the (deprecated) CGI module to generate it from plain text ;)

                                                                                                                                                                                                                                                    3. 1

                                                                                                                                                                                                                                                      Gemini is only a protocol, but the specification also propose a basic text/gemini format as a de-facto document type. It however supports any mimetype, including text/html:

                                                                                                                                                                                                                                                      5 The text/gemini media type
                                                                                                                                                                                                                                                      5.1 Overview

                                                                                                                                                                                                                                                      In the same sense that HTML is the “native” response format of HTTP and plain text is the native response format of gopher, Gemini defines its own native response format - though of course, thanks to the inclusion of a MIME type in the response header Gemini can be used to serve plain text, rich text, HTML, Markdown, LaTeX, etc.

                                                                                                                                                                                                                                                      You could totally sent the following HTML document over gemini:// and enjoy inline images:

                                                                                                                                                                                                                                                      <html>
                                                                                                                                                                                                                                                        <body>
                                                                                                                                                                                                                                                        <p>My favorite cat picture:</p>
                                                                                                                                                                                                                                                        <img src="gemini://domain.tld/cat.png" />
                                                                                                                                                                                                                                                        </body>
                                                                                                                                                                                                                                                      </html>
                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                      It would then be up to the gemini client to process this document, fetch required resources (the cat picture) and render it nicely for you. The advantage of the gemini protocol here is that it would put a limit on the HTML subset one could put in a document. For example, <form> tags won’t be any useful. There would also be no need for <script> tags, as they wouldn’t be able to “phone home” over gemini.

                                                                                                                                                                                                                                                      One of the biggest problem of the web is that the HTTP protocol itself grew in an enormous monster that’s impossible to understand, where sometimes the headers of a requests can be 10 times bigger than the content itself.

                                                                                                                                                                                                                                                    1. 12

                                                                                                                                                                                                                                                      Gemini is a network protocol for exchanging hypertext documents

                                                                                                                                                                                                                                                      … and this is where he loses me. Gemini is a network protocol. It doesn’t force you to send any specific kind of documents in response to requests. That means it will be used to send any kind of document whatsoever the moment it gets at all popular, and lose whatever properties the non-HTML hypertext format has which make it so attractive to him when everyone else uses Gemini to send HTML with CSS and Javascript and, oh yeah, images and videos. There’s a reason Web browsers caught on in the first place: They could speak multiple protocols and parse (or otherwise handle) multiple kinds of document. Trying to confuse and conflate a protocol with a document format is, therefore, fuzzy thinking which grates on me.