1.  

    I’m wondering why no body has mentioned the runtime cost of such construct in a fully interpreted dynamic typed language such as python.

    1.  

      Probably because it is very minuscule. After all, you work through the cases in the same order as you would go though if-elif-else, with about the same amount of checks, so from a runtime cost this is similar to the runtime cost of unpacking that already exists in the language anyway and is pretty popular.

    1. 15

      Pattern matching has been available in functional programming languages for decades now, it was introduced in the 70s. (Logic programming languages expose even more expressive forms, at higher runtime cost.) It obviously improves readability of code manipulating symbolic expressions/trees, and there is a lot of code like this. I find it surprising that in the 2020s there are still people wondering whether “the feature provides enough value to justify its complexity”.

      (The fact that Python did without for so long was rather a sign of closed-mindedness of its designer subgroup. The same applies, in my opinion, to languages (including Python, Go, etc.) that still don’t have proper support for disjoint union types / variants / sums / sealed case classes.)

      1. 41

        Pretty much every feature that has ever been added to every language ever is useful in some way. You can leave a comment like this on almost any feature that a language may not want to implement for one reason or the other.

        1. 13

          I think it makes more sense in statically typed languages, especially functional ones. That said, languages make different choices. For me, Python has always been about simplicity and readability, and as I’ve tried to show in the article, at least in Python, structural pattern matching is only useful in a relatively few cases. But it’s also a question of taste: I really value the simplicity of the Go language (and C before it), and don’t mind a little bit of verbosity if it makes things clearer and simpler. I did some Scala for a while, and I can see how people like the “power” of it, but the learning curve of its type system was very steep, and there were so many different ways to do things (not to mention the compiler was very slow, partly because of the very complex type system).

          1. 17

            For the record, pattern-matching was developed mostly in dynamically-typed languages before being adopted in statically-typed languages, and it works just as well in a dynamically-typed world. (In the ML-family world, sum types and pattern-matching were introduced by Hope, an experimental dynamically-typed language; in the logic world, they are basic constructs of Prolog, which is also dynamically-typed – although some more-typed dialects exist.)

            as I’ve tried to show in the article, at least in Python, structural pattern matching is only useful in a relatively few cases

            Out of the 4 cases you describe in the tutorial, I believe your description of two of them is overly advantageous to if..elif:

            • In the match event.get() case, the example you show is a variation of the original example (the longer of the three such examples in the tutorial), and the change you made makes it easier to write an equivalent if..elif version, because you integrated a case (from another version) that ignores all other Click() events. Without this case (as in the original tutorial example), rewriting with if..elif is harder, you need to duplicate the failure case.
            • In the eval_expr example, you consider the two versions as readable, but the pattern-version is much easier to maintain. Consider, for example, supporting operations with 4 or 5 parameters, or adding an extra parameter to an existing operator; it’s an easy change with the pattern-matching version, and requires boilerplate-y, non-local transformations with if..elif. These may be uncommon needs for standard mathematical operations, but they are very common when working with other domain-specific languages.
            1.  

              the change you made makes it easier to write an equivalent if..elif version

              Sorry if it appeared that way – that was certainly not my intention. I’m not quite sure what you mean, though. The first/original event example in the tutorial handles all click events with no filtering using the same code path, so it’s even simpler to convert. I added the Button.LEFT filtering from a subsequent example to give it a bit more interest so it wasn’t quite so simple. I might be missing something, though.

              In the eval_expr example, you consider the two versions as readable, but the pattern-version is much easier to maintain. Consider, for example, supporting operations with 4 or 5 parameters, or adding an extra parameter to an existing operator;

              I think those examples are very hypothetical – as you indicate, binary and unary operators aren’t suddenly going to support 4 or 5 parameters. A new operation might, but that’s okay. The only line that’s slightly repetitive is the “attribute unpacking”: w, x, y, z = expr.w, expr.x, expr.y, expr.z.

              These may be uncommon needs for standard mathematical operations, but they are very common when working with other domain-specific languages.

              You’re right, and that’s part of my point. Python isn’t used for implementing compilers or interpreters all that often. That’s where I’m coming from when I ask, “does the feature provide enough value to justify the complexity?” If 90% of Python developers will only rarely use this complex feature, does it make sense to add it to the language?

              1.  

                that was certainly not my intention.

                To be clear, I’m not suggesting that the change was intentional or sneaky, I’m just pointing out that the translation would be more subtle.

                The first/original event example does not ignore “all other Click events” (there is no Click() case), and therefore an accurate if..elif translation would have to do things differently if there is no position field or if it’s not a pair, namely it would have to fall back to the ValueError case.

                You’re right, and that’s part of my point. Python isn’t used for implementing compilers or interpreters all that often.

                You don’t need to implement a compiler for C or Java, or anything people recognize as a programming language (or HTML or CSS, etc.), to be dealing with a domain-specific languages. Many problem domains contain pieces of data that are effectively expressions in some DSL, and recognizing this can very helpful to write programs in those domains – if the language supports the right features to make this convenient. For example:

                • to start with the obvious, many programs start by interpreting some configuration file to influence their behavior; many programs have simple needs well-served by linear formats, but many programs (eg. cron jobs, etc.) require more elaborate configurations that are DSL-like. Even if the configuration is written in some standard format (INI, Yaml, etc.) – so parsing can be delegated to a library – the programmer will still write code to interpret or analyze the configuration data.
                • more gnerally, “structured data formats” are often DSL-shaped; ingesting structured data is something we do super-often in programs
                • programs that offer a “query” capability typically provide a small language to express those queries
                • events in an event loop typically form a small language
            2. 12

              I think it makes more sense in statically typed languages, especially functional ones.

              In addition to the earlier ones gasche mentioned (it’s important to remember this history), it’s used to pervasively in Erlang, and later Elixir. Clojure has core.match, Racket has match, as does Guile. It’s now in Ruby as well!

              1.  

                Thanks! I didn’t know that. I have used pattern matching in statically typed language (mostly Scala), and had seen it in the likes of Haskell and OCaml, so I’d incorrectly assumed it was mainly a statically-typed language thing.

                1.  

                  It is an important feature of OCaml.

                  1.  

                    I am aware - was focusing on dynamically typed languages.

                2. 6

                  For me, it is the combination of algebraic data types + pattern matching + compile time exhaustiveness checking that is the real game changer. With just 1 out of 3, pattern matching in Python is much less compelling.

                  1.  

                    I agree. I wonder if they plan to add exhaustiveness checking to mypy. The way the PEP is so no hold barred makes it seem like the goal was featurefulness and not an attempt to support exhaustiveness checking.

                    1.  

                      I wonder if they plan to add exhaustiveness checking to mypy.

                      I don’t think that’s possible in the general case. If I understand the PEP correctly, __match_args__ may be a @property getter method, which could read the contents of a file, or perform a network request, etc.

                3. 10

                  I find it surprising that in the 2020s there are still people wondering whether “the feature provides enough value to justify its complexity”.

                  I find it surprising that people find this surprising.

                  Adding features like pattern matching isn’t trivial, and adding it too hastily can backfire in the long term; especially for an established language like Python. As such I would prefer a language take their time, rather than slapping things on because somebody on the internet said it was a good idea.

                  1.  

                    That’s always been the Scheme philosophy:

                    Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary.

                    And indeed, this pays off: in the Scheme world, there’s been a match package floating around for a long time, implemented simply as a macro. No changes to the core language needed.

                    1.  

                      No changes to the core language needed.

                      I’m sure you recognize that this situation does not translate to other languages like in this case Python. Implementing it as a macro is just not feasible. And even in Scheme the usage of match macros is rather low. This can be because it is not that useful, but also might be because of the hurdle of adding dependencies is not worth the payoff. Once a feature is integrated in a language, its usage “costs” nothing, thus the value proposition when writing code can be quite different.

                  2. 7

                    I agree about pattern matching and Python in general. It’s depressing how many features have died in python-ideas because it takes more than a few seconds for an established programmer to grok them. Function composition comes to mind.

                    But I think Python might be too complicated for pattern matching. The mechanism they’ve settled on is pretty gnarly. I wrote a thing for pattern matching regexps to see how it’d turn out (admittedly against an early version of the PEP; I haven’t checked it against the current state) and I think the results speak for themselves.

                    1. 5

                      But I think Python might be too complicated for pattern matching. The mechanism they’ve settled on is pretty gnarly.

                      I mostly agree. I generally like pattern matching and have been excited about this feature, but am still feeling out exactly when I’ll use it and how it lines up with my intuition.

                      The part that does feel very Pythonic is that destructuring/unpacking is already pretty pervasive in Python. Not only for basic assignments, but also integrated into control flow constructs. For example, it’s idiomatic to do something like:

                      for key, val in some_dictionary.items():
                          # ...
                      

                      Rather than:

                      for item in some_dictionary.items():
                          key, val = item
                          # ...
                      

                      Or something even worse, like explicit item[0] and item[1]. So the lack of a conditional-with-destructuring, the way we already have foreach-with-destructuring, did seem like a real gap to me, making you have to write the moral equivalent of code that looks more like the 2nd case than the 1st. That hole is now filled by pattern matching. But I agree there are pitfalls around how all these features interact.

                    2.  
                      for i, (k, v) in enumerate(d.items(), 1): pass
                      

                      looks like pattern matching to me

                      1.  

                        Go aims for simplicity of maintenance and deployment. It doesn’t “still don’t have those features”. The Go authors avoided them on purpose. If you want endless abstractions in Go, embedding Lisp is a possibilty: https://github.com/glycerine/zygomys

                        1.  

                          Disjoint sums are a basic programming feature (it models data whose shape is “either this or that or that other thing”, which ubiquitous in the wild just like pairs/records/structs). It is not an “endless abstraction”, and it is perfectly compatible with maintenance and deployment. Go is a nice language in some respects, the runtime is excellent, the tooling is impressive, etc etc. But this is no rational excuse for the lack of some basic language features.

                          We are in the 2020s, there is no excuse for lacking support for sum types and/or pattern matching. Those features have been available for 30 years, their implementation is well-understood, they require no specific runtime support, and they are useful in basically all problem domains.

                          I’m not trying to bash a language and attract defensive reactions, but rather to discuss (with concrete examples) the fact that language designer’s mindsets can be influenced by some design cultures more than others, and as a result sometimes the design is held back by a lack of interest for things they are unfamiliar with. Not everyone is fortunate to be working with a deeply knowledgeable and curious language designer, such as Graydon Hoare; we need more such people in our language design teams. The default is for people to keep working on what they know; this sort of closed-ecosystem evolution can lead to beautiful ideas (some bits of Perl 6 for example are very nice!), but it can also hold back.

                          1.  

                            But this is no rational excuse for the lack of some basic language features.

                            Yes there is. Everyone has a favorite feature, and if all of those are implemented, there would easily be feature bloat, long build times and projects with too many dependencies that depend on too many dependencies, like in C++.

                            In my opinion, the question is not if a language lacks a feature that someone wants or not, but if it’s usable for goals that people wish to achieve, and Go is clearly suitable for many goals.

                        2.  

                          Ah yes, Python is famously closed-minded and hateful toward useful features. For example, they’d never adopt something like, say, list comprehensions. The language’s leaders are far too closed-minded, and dogmatically unwilling to ever consider superior ideas, to pick up something like that. Same for any sort of ability to work with lazy iterables, or do useful combinatoric work with them. That’s something that definitely will never be adopted into Python due to the closed-mindedness of its leaders. And don’t get me started on basic FP building blocks like map and folds. It’s well known that Guido hates them so much that they’re permanently forbidden from ever being in the language!

                          (the fact that Python is not Lisp was always unforgivable to many people; the fact that it is not Haskell has now apparently overtaken that on the list of irredeemable sins; yet somehow we Python programmers continue to get useful work done and shrug off the sneers and insults of our self-proclaimed betters much as we always have)

                          1. 23

                            It is well-documented that Guido Van Rossum planned to remove lambda from Python 3. (For the record, I agree that map and filter on lists are much less useful in presence of list comprehensions.) It is also well-documented that recursion is severely limited in Python, making many elegant definitions impractical.

                            Sure, Python adopted (in 2000 I believe?) list comprehensions from ABC (due to Guido working with the language in the 1980s), and a couple of library-definable iterators. I don’t think this contradicts my claim. New ideas came to the language since (generators, decorators), but it remains notable that the language seems to have resisted incorporating strong ideas from other languages. (More so than, say, Ruby, C#, Kotlin, etc.)

                            Meta: One aspect of your post that I find unpleasant is the tone. You speak of “sneers and insults”, but it is your post that is highly sarcastic and full of stray exagerations at this or that language community. I’m not interested in escalating in this direction.

                            1. 6

                              less useful in presence of list comprehension

                              I’m certainly biased, but I find Python’s list comprehension an abomination towards readability in comparison to higher-order pipelines or recursion. I’ve not personally coded Python in 8-9 years, but when I see examples, I feel like I need to put my head on upsidedown to understand it.

                              1. 5

                                It is also well-documented that recursion is severely limited in Python, making many elegant definitions impractical.

                                For a subjective definition of “elegant”. But this basically is just “Python is not Lisp” (or more specifically, “Python is not Scheme”). And that’s OK. Not every language has to have Scheme’s approach to programming, and Scheme’s history has shown that maybe it’s a good thing for other languages not to be Scheme, since Scheme has been badly held back by its community’s insistence that tail-recursive implementations of algorithms should be the only implementations of those algorithms.

                                You speak of “sneers and insults”, but it is your post that is highly sarcastic and full of stray exagerations at this or that language community.

                                Your original comment started from a place of assuming – and there really is no other way to read it! – that the programming patterns you care about are objectively superior to other patterns, that languages which do not adopt those patterns are inherently inferior, and that the only reason why a language would not adopt them is due to “closed-mindedness”. Nowhere in your comment is there room for the (ironically) open-minded possibility that someone else might look at patterns you personally subjectively love, evaluate them rationally, and come to a different conclusion than you did – rather, you assume that people who disagree with your stance must be doing so because of personal faults on their part.

                                And, well, like I said we’ve got decades of experience of people looking down their noses at Python and/or its core team + community for not becoming a copy of their preferred languages. Your comment really is just another instance of that.

                                1. 7

                                  I’m not specifically pointing out the lack of tail-call optimization (TCO) in Python (which I think is unfortunate indeed; the main argument is that call stack matters, but it’s technically fully possible to preserve call stacks on the side with TC-optimizing implementations). Ignoring TCO for a minute, the main problem would be the fact that the CPython interpreter severely limits the call space (iirc it’s 1K calls by default; compare that to the 8Mb default on most Unix systems), making recursion mostly unusable in practice, except for logarithmic-space algorithms (balanced trees, etc.).

                                  Scheme has been badly held back by its community’s insistence that tail-recursive implementations of algorithms should be the only implementations of those algorithms.

                                  I’m not sure what you mean – that does not make any sense to me.

                                  [you assume] that the programming patterns you care about are objectively superior to other patterns [..]

                                  Well, I claimed

                                  [pattern matching] obviously improves readability of code manipulating symbolic expressions/trees

                                  and I stand by this rather modest claim, which I believe is an objective statement. In fact it is supported quite well by the blog post that this comment thread is about. (Pattern-matching combines very well with static typing, and it will be interesting to see what Python typers make of it; but its benefits are already evident in a dynamically-typed context.)

                                  1.  

                                    Again: your original comment admits of no other interpretation than that you do not believe anyone could rationally look at the feature you like and come to a different conclusion about it. Thus you had to resort to trying to find personal fault in anyone who did.

                                    This does not indicate “closed-mindedness” on the part of others. They may prioritize things differently than you do. They may take different views of complexity and tradeoffs (which are the core of any new language-feature proposal) than you do. Or perhaps they simply do not like the feature as much as you do. But you were unwilling to allow for this — if someone didn’t agree with your stance it must be due to personal fault. You allowed for no other explanation.

                                    That is a problem. And from someone who’s used to seeing that sort of attitude it will get you a dismissive “here we go again”. Which is exactly what you got.

                                    1.  

                                      and I stand by this rather modest claim, which I believe is an objective statement.

                                      Nit: I don’t think you can have an objective statement of value.

                                  2.  

                                    This is perhaps more of a feeling, but saying that Rust isn’t adopting features as quickly as Ruby seems a bit off. Static type adoption in the Python community has been quicker. async/await has been painful, but is being attempted. Stuff like generalized unpacking (and this!) is also shipping out!

                                    Maybe it can be faster, but honestly Python probably has one of the lowest “funding amount relative to impact” of the modern languages which makes the whole project not be able to just get things done as quickly IMO.

                                    Python is truly in a funny place, where many people loudly complain about it not adopting enough features, and many other loudly complain about it loudly adopting too many! It’s of course “different people have different opinions” but still funny to see all on the same page.

                                    1.  

                                      It is well-documented that Guido Van Rossum planned to remove lambda from Python 3

                                      Thank you for sharing that document. I think Guido was right: it’s not pythonic to map, nor to use lambdas in most cases.

                                      Every feature is useful, but some ecosystems work better without certain features. I’m not sure where go’s generics fall on this spectrum, but I’m sure most proposed features for python move it away from it’s core competency, rather than augmenting a strong core.

                                      1.  

                                        We have previously discussed their tone problem. It comes from their political position within the Python ecosystem and they’re relatively blind to it. Just try to stay cool, I suppose?

                                        1.  

                                          I really do recommend clicking through to that link, and seeing just what an unbelievably awful thing I said that the user above called out as “emblematic” of the “contempt” I display to Python users. Or the horrific ulterior motive I was found to have further down.

                                          Please, though, before clicking through, shield the eyes of children and anyone else who might be affected by seeing such content.

                                      2.  

                                        To pick one of my favorite examples, I talked to the author of PEP 498 after a presentation that they gave on f-strings, and asked why they did not add destructuring for f-strings, as well as whether they knew about customizeable template literals in ECMAScript, which trace their lineage through quasiliterals in E all the way back to quasiquotation in formal logic. The author knew of all of this history too, but told me that they were unable to convince CPython’s core developers to adopt any of the more advanced language features because they were not seen as useful.

                                        I think that this perspective is the one which might help you understand. Where you see one new feature in PEP 498, I see three missing subfeatures. Where you see itertools as a successful borrowing of many different ideas from many different languages, I see a failure to embrace the arrays and tacit programming of APL and K, and a lack of pattern-matching and custom operators compared to Haskell and SML.

                                    1.  

                                      I don’t think you can answer that properly for everyone right now, or it would be some kind of common knowledge.

                                      Let’s assume you take first year computer science students, who might be beginner coders. What’s the official goal here? Do some research, so the language they learn will not matter. Maybe it won’t even matter how well they code, depending on what they will do, maybe more math :P What is the actual goal? Produce an employable software developer. How high are the chances they will work with assembler versus some sort of high level language? I’m betting on high level language. (Last I checked universities were also going back and forth between imperative and functional, so maybe it’s between 3 and not 2 possibilities).

                                      I am not sure if there were a lot of actual studies of cohorts of students doing this or that, that would be the only thing I’d base some trust on, because every coder you ask will have an opinion and maybe some selection bias because it “worked for them”. But I think in the last 20 years there are less and less people who started bottom up (with assembler or C) and most started top down (with JS or python or PHP). Are they worse programmers? Could they have learned better? I don’t know.

                                      1.  

                                        What is the actual goal? Produce an employable software developer.

                                        At least in the case of Germany, the goal of Computer Science education is not to produce software developers, because if it were then what they do would be woefully inadequate. What they try to teach you is to become a computer scientist. Of course, many computer scientists become software developers but these with little to no experience outside university aren’t particularly better skilled than those that chose a different education path (like FH, self-study etc).

                                        So what would be the learning goal for a computer scientist? It sort of depends on what the subject is:

                                        1. Technical computer science: Things like allocation algorithms etc. makes obviously more sense in lower-level languages.
                                        2. Theoretical computer science: Things like recursion, complexity classes etc make more sense in higher-level languages.

                                        It really depends what you actually want to teach.

                                        1.  

                                          Thus my distinction. I firmly believe that even the universities have grasped the reality that 90%? 75%? of people who finish will not end up in academia.

                                          Also I’m not even saying they’re doing a good job of either “goal”, but it is what it is.

                                          1.  

                                            Much much higher than that if you’re talking about undergrads; generally CS grad students will know how to program coming in.

                                            1.  

                                              Should’ve clarified I come from an ancient time where we didn’t have those things at all German unis ;) I have one of last diplomas, a 9-12 semester degree which is like BSc+MSc. So I never think about a Master’s when talking about “graduate students”.

                                      1. 4

                                        Saying code comments are useless is a judgement from us as fluent readers of the code. It disregards the value comments have for someone less fluent than yourself who is either reading or writing code.

                                        If you’re trying to teach people a language that they don’t understand, you’re going to need to do a LOT more explaining:

                                        // Add a horizontal scroll bar
                                        hScrollBar = new JScrollBar(scrollBar, HORIZONTAL);
                                        add(hScrollBar, BorderLayout.SOUTH);
                                        

                                        May need to become:

                                        // Add a new horizontal scroll bar.
                                        // Horizontal scroll bars are what we call the GUI element that
                                        // allow you to move a widget's visible frame side to side instead
                                        // of vertically (see https://tutorial.com/diagram.jpg).
                                        //
                                        // 'new' is a keyword that indicates that the following word is a class
                                        // name, and that  the constructor `JScrollBar.JScrolBar()` is to be invoked.
                                        // This is used to initialize the scrollbar object, and set it up as horizontal.
                                        hScrollBar = new JScrollBar(scrollBar, HORIZONTAL);
                                        
                                        // The add() function is implicitly called on the `this` object, and takes both
                                        // the hScrollBar we created in the line above, the current container object,
                                        // and uses the BorderLayout.SOUTH constant to indicate that it goes on
                                        // the bottom of the container.
                                        add(hScrollBar, BorderLayout.SOUTH);
                                        

                                        The problem with these ‘useless comments’ is that they’re generally not sufficient to teach someone that is unfamiliar with reading code, and unhelpful for someone that is.

                                        1. 1

                                          Could you comment also mention what scrollBar is, why it is necessary and how it differs from hScrollBar? I have no experience with Java and would like the explanation of everything directly in the code.

                                        1. 4

                                          Personally, I’ve never liked the advice that writing obvious comments is bad practice—probably because I write obvious comments all the time.

                                          This is fun and games while it is correct but when you run across a comment that is claiming the opposite of what the code does, what now?

                                          // Add a horizontal scroll bar
                                          newScrollBar = new JScrollBar(scrollBar, VERTICAL);
                                          

                                          What’s the correct behaviour? Should you fix the comment? Should you fix the code? Should you leave it alone if you’re not directly affected by it? With just the code the problem isn’t really there since there is one source of truth. It might not be correct but at least there’s no contradictions because the code does what the code says it does.

                                          The problem with comments is, that they’re non-executable, so the person changing the code changes the code otherwise the change will not happen. But will they remember to change the comment? Maybe, maybe not. This isn’t even a hypothetical case, I’ve seen cases where the comment claimed the exact opposite behaviour than what the code did.

                                          1. 5

                                            What’s the correct behaviour? Should you fix the comment? Should you fix the code? Should you leave it alone if you’re not directly affected by it? With just the code the problem isn’t really there since there is one source of truth. It might not be correct but at least there’s no contradictions because the code does what the code says it does.

                                            I’ve found those cases incredibly useful, because they tell me the code diverged. Something changed; why? Does other code assume the scroll bar is horizontal? Was that code switched when this snippet was switched to vertical? Does this code/comment divergence help me track down the bug I’m searching for?

                                            Without the comment I wouldn’t know that something interesting happened and wouldn’t even think to git blame it, but now I know that there’s historical information here.

                                            1. 3

                                              I’ve found those cases incredibly useful, because they tell me the code diverged. Something changed; why?

                                              Usually, because I slipped as I was typing the comment. I use the wrong word all the time when speaking and writing, and need either some testing or a careful reader to notice.

                                              There’s nothing insightful to be gained from my thinkos and brain farts: they’re also in my multi-paragraph expository comments, but at least there you usually have enough context to realize “oh, Ori is a sloppy writer, and clearly meant this”.

                                              1. 2

                                                The thing is: for the most part, 99% of the cases, this is because the code was changed but the comment wasn’t (very much according to Occam’s Razor) so what you get out of this is wasting your time with needless investigation of something that’s not actually a problem and then fixing the comment or just removing it outright.

                                                1. 2

                                                  If you are certain the code is right and know the comment is wrong, then take 30 seconds to fix the comment to match the code and move on with your life. Not a big deal.

                                                  If you are uncertain whether the code is wrong or the comment is wrong, then that indicates a hole in your understanding. That hole would exist whether or not the comment was there. So thats a useful indicator that you should investigate further.

                                                  1. 1

                                                    The comment makes understanding that line actively more difficult. If you’re reading the code for the purpose of coming to some initial understanding of a codebase then you’re going in with holes in your understanding and this inconsistent comment creates yet another hole.

                                                    You’re suggesting that if I go to a random Github repo I’m not familiar with, start trying to read the code, and find a comment that is blatantly and objectively inconsistent with the code it’s attached to, that’s not actually a problem because if I just understood the codebase I’d know which to trust.

                                                    You’re onto something there. That’s exactly the point: if context makes it clear which to trust, then you don’t need both, you just need the (correct) code. If we can make the assumption the misleading comment won’t matter because anyone reading it will know that the comment is wrong, then what is the comment doing there at all?

                                            1. 4

                                              I used to work at a company where our team lead was insistent that every line of code be accompanied by a comment.

                                              The whole codebase looked something like this:

                                              // Increment x by 1
                                              x = x + 1;
                                              
                                              // Print x to the console
                                              console.log(x);
                                              
                                              // If x is 2
                                              if (x === 2) {
                                                
                                                // Print that x is 2
                                                console.log('x = 2');
                                              
                                              } else { // Else if x is not 2
                                              
                                                // Print that x is not 2
                                                console.log('x is not 2');
                                              
                                              } // End if x is 2
                                              

                                              If that wasn’t egregious enough, in the situations where a comment would actually be useful in understanding the code the comment attached to a particular line would contradict what the code was doing.

                                              All that to say, I’m unconvinced by the author’s argument that useless comments like this are useful to anyone.

                                              1. 9

                                                I also want to comment on this claim in particular:

                                                Comments which are at the same level of detail as the code may not be useful to you as a fluent reader and writer of code, but they are to someone like me who is still figuring out how to read and write code.

                                                I think that this is the wrong way of approaching teaching someone how to read code. If your primary purpose is education then, by all means, litter the code with explanatory comments, but it doesn’t make any sense to keep commenting every line of production code like this just so it’s accessible to someone who isn’t familiar with reading code.

                                                Teach them to read the code so that they don’t need redundant comments.

                                                1. 4

                                                  I agree that these comments aren’t useful but there’s an important asymmetry to consider:

                                                  • A novice programmer can easily remove comments that are pointless.
                                                  • Only a more experienced programmer can add missing comments that are necessary.

                                                  This means that I’d always encourage people to over-comment rather than under-commenting. That said, your example is actually doing both. Why is x being incremented by 1? What is the importance of 1 here? Why do we care if x is 2?

                                                  1. 4

                                                    But that’s actually the thing. Instead of writing these useless comments (“look, there’s a comment, so this is well commented code” the effort could be spent instead on useful comments explaining why. Sometimes even every line explaining why makes sense. Although in many cases refactoring the code helps a lot because e.g. good names of variables and functions can be a big boon to understandability and unlike comments they don’t bit-rot.

                                                    1. 2

                                                      Exactly this. If each line of code had a comment that actually provided some valuable insight that isn’t obvious from the code itself, I wouldn’t have such a problem with this style.

                                                      In my experience, the hard and fast rule that was put in place of having a comment for every line led me to just start ignoring every comment in sight. Useful comments no longer stand out as signposts because they’re buried under the weight of all the noisy ones.

                                                      I still maintain that code can (and should) be refactored for clarity prior to introducing a comment. For instance, in my contrived example above the conditional could be rewritten like so:

                                                      const enableSecretFeature = x === 2;
                                                      if (enableSecretFeature) {
                                                        // ...
                                                      } else {
                                                        // ...
                                                      }
                                                      

                                                      This provides the why behind what the code is doing, and it does so without needing a comment.

                                                1. 2

                                                  I’m thinking, this could be also an interesting watchface for a smartwatch. Too bad my Versa died 2 weeks ago.

                                                  1. 2

                                                    There are so many lessons to learn! The one I want to highlight is that even “exact” clocks are not perfect, and our analog components always have ranges and tolerances.

                                                    1. 2

                                                      I kept waiting for him to add some little caveat there, but he never did? Though I suppose with recent over-the-air networked vehicles, they could in principle all be running NTP/PTP (or perhaps more likely just using GPS time) to keep themselves synchronized to well within the threshold of human perception.

                                                      1. 1

                                                        Our computer clocks have such small ticks, drift wouldn’t be perceptible. Further, computers can alter their clocks, making any extrapolation of long term effects in the general case meaningless.

                                                        1. 2

                                                          [Disclaimer: I am by no means a computer time-keeping expert.]

                                                          Our computer clocks have such small ticks, drift wouldn’t be perceptible.

                                                          At the “real-world” scale of the duration a turn signal is typically on at a traffic light, sure, but if you just set up two cars next to each other and let them sit for days, weeks, months…it seems like it could eventually add up to something noticeable? Let’s say an offset starts to be perceptible at 100ms – exceeding that threshold after just a single day of running would only require your clock rates to differ by less than 0.0002%, if I haven’t screwed up my arithmetic.

                                                          [On a different-but-somewhat-relevant anecdotal tangent, a system I’m currently working on firmware for has a little microcontroller on its (2-bay) disk backplane that handles drive presence, status LEDs, etc. While the same controller manages both bays, I’ve noticed that the fault LEDs blink at slightly different rates – they’ll shift between in and out of phase with each other over the course of a minute or two (implying a frequency difference somewhere in the range of a few centihertz, I guess). I can’t imagine that was an intentional design choice, so I’d guess it’s probably just an artifact of some detail of the software running on that controller – nevertheless, it seems a “drift” of a sort crept in there even with (I’m pretty sure) a single clock.]

                                                          Also, I’m not clear on how the scale of the clock tick makes a difference – isn’t a given percentage difference in frequency going to produce the same amount of drift over a given amount of time regardless of what that frequency is? (e.g. a 1% difference in nominally 1GHz clocks will drift just as much over the course of a day as a 1% difference in nominally 1Hz clocks.)

                                                          Further, computers can alter their clocks, making any extrapolation of long term effects in the general case meaningless.

                                                          Well, what I was sort of trying to hint at with my earlier comment was that this would, I think, depend on the exact algorithm used for controlling the blinking. If it’s something like

                                                          loop {
                                                            sleep(interval);
                                                            toggle_light_state();
                                                          }
                                                          

                                                          and sleep()‘s semantics are analogous to Linux’s CLOCK_MONOTONIC_RAW, then clock alterations won’t enter the picture and you’ll be entirely at the mercy of whatever environmental/manufacturing variations affect the frequency of your physical clock source. If you were to instead schedule the next clock toggle event at a point in time determined by CLOCK_REALTIME, then (as I was sort of implying previously) you can of course bring NTP or whatever else to bear and should be able to achieve “good enough” synchronization over arbitrary timescales.

                                                        2. 1

                                                          I am not sure why he would add such a caveat. Yes, of course they could align to some microsecond and then the cars of the same make would be exactly aligned but… why would you do that? That doesn’t seem to be anyone’s requirement. Additionally that would make the whole thing worse, because creates a delay on the first blink because you need to wait for the first “blinking slot”. Also the chip needs a clock now, whereas before a simple quartz as a timer was enough, thus making it orders of magnitude more complicated.

                                                          1. 1

                                                            but… why would you do that?

                                                            This seems like a question about the premise of the whole video in the first place…I don’t think anyone’s trying to derive any practical utility from this, it’s just an OCD-esque excuse to delve into the implementation details of a blinking light.

                                                            Also the chip needs a clock now, whereas before a simple quartz as a timer was enough, thus making it orders of magnitude more complicated.

                                                            I mean…with the blinking controlled by software in more recent cars as described in the video (probably in the context of some fairly sophisticated embedded systems I’d guess), it’s already gotten orders of magnitude more complicated. If your light-blinking control system is already running internet/GPS-connected Linux, it may just be a matter of which clockid you pass to clock_nanosleep().

                                                            1. 1

                                                              Unfortunately he doesn’t show the most modern/current version of the part but even then I doubt that it is more than an MCU with a quartz, no Linux, no Internet, no GPS. Sure, it is controlled by a more sophisticated system via CAN bus, so in theory they could do do clock sync over CAN or even control the entirety of the blinking via a Linux running somewhere but replacing a realtime system with one that doesn’t even do soft realtime feels a bit wonky.

                                                              Heck, last time I drove a car cars didn’t have GPS to begin with, not in the blinker nor anywhere else :)

                                                      1. 5

                                                        Warning: all of the videos on this channel are extremely addictive. He manages to squeeze out interesting bits out of the most mundane and uninteresting bits and that’s quite an achievement. I couldn’t care less about most of the topics he talked about, but I gladly click every single one of them because there is always a delightful bit about technology being applied in creative ways.

                                                        1. 1

                                                          It’s surprisingly hard to find an easy to use memory leak detection tool

                                                          For Linux (and I ported it to FreeBSD) KDE’s heaptrack is excellent.

                                                          1. 3

                                                            In that case it wouldn’t help because SumatraPDF is explicitly a Win32-only app, so unless you want to do leak detection under Wine this is a no-go.

                                                            1. 1

                                                              What’s wrong with valgrind, asan, bdw…?

                                                              1. 1

                                                                Nothing. Where did I say there’s something wrong with other tools? :) Heaptrack is great because of its UI.

                                                            1. 0

                                                              Is bashing Google and selling itself in name of Privacy the only business model of DDG? they could just say it’s a good email service with many features that people actually care about.

                                                              1. 1

                                                                But it is not an email service. It is more of a filtering proxy.

                                                              1. 2

                                                                The instances are always iterable; this can make it difficult to add fields, because adding a new field will break code that uses unpacking.

                                                                Aren’t tuples iterable by default, which come to think of it from the perspective of people expecting product types is just… pretty weird? To me it sounds like a problem with Python tuples in general.

                                                                1. 109

                                                                  Independently of what burntsushi decides, I think that the following concrete actions would be in order:

                                                                  1. Remove the last half-sentence of the banner that explains how to delete your account. Having it as the last part of the message adds a lot of weight ot it: after you read the banner it’s the main thing you remember, the oddly detailed explanation of how to erase yourself.

                                                                  2. Reformulate the rest of the banner to indicate that this is a heuristic that may be wrong. It’s important when providing hints from data to tell people explicitly that we know the hints may be wrong. Otherwise it feels very different.

                                                                  Let’s rephrase this banner with the explicit goal of doing no harm (better, doing good) when it is wrongly displayed, instead of thinking about the formulation when its assessment is correct.

                                                                  1. 59

                                                                    Speaking as somebody who’s gotten that banner basically permanently on their account, I think a lot of folks here may be missing important context:

                                                                    • The call to delete your account makes a lot of sense if you have to handle users dramatically declaring, in DMs/IRC/elsewhere “One more and [clutches pearls] I shall leave, forthwith!”. This is tiresome from a moderation standpoint and annoying for a community, and if one can nudge somebody into removing their account–in the common case!–rather than continue to engage in a community they don’t fit into (for whatever reason), it’s a win for both parties.
                                                                    • This isn’t some randy sketchy heuristic–the warning links directly to a histogram that shows where you are in the flaggings. It’s deterministic, it’s impartial, and if you’re getting flagged a lot there’s something going on with either your posting or the community.
                                                                    • Moderation team here is currently basically just @pushcx. It’s a large community with real, actual bad actors, and asking for any sort of increase in manual moderation is a very real burden.
                                                                    • One of the biggest reasons for Lobsters coming from the orange site was @jcs being annoyed at opaque moderation. While I might disagree certain particular actions, there is a public log. The thing here being complained about? It’s in the source code, it’s very clear how it works, and it provides impartial, statistical feedback about what’s going on.
                                                                    • There’s a trend for folks to go on IRC, Twitter, or wherever and talk trash about our community, about how @pushcx is powertripping, or whatever. This behavior probably plays well with the circles they’re familiar with and probably feels like punching up, but it’s gotta suck for the person who manages the community to have people he’s tried to work with and accomodate throw it back in his face.
                                                                    • People are really flag-happy, and this is what happens when you are.

                                                                    (Minor annoyance: we used to have a very good explanation of how to use flags, what borderline cases looked like, and so forth, but that was purged for whatever reason. I’ve seen a lot of bad flagging by either new folks who don’t know better or users with an axe to grind.)

                                                                    1. 35

                                                                      Moderation team here is currently basically just @pushcx. It’s a large community with real, actual bad actors, and asking for any sort of increase in manual moderation is a very real burden.

                                                                      This bit deserves signal boosting IMO.

                                                                      Lobsters doesn’t cost anything to join or participate in. The people who run it are clearly doing it for love, not money.

                                                                      Speaking for myself I’d much rather get past the momentary ouch of having a red warning message attached to my account than have the owners or moderators rage quit as a result of feeling UTTERLY drained by the experience.

                                                                      I’m watching the life get sucked out of some very stalwart well meaning people in another community I care about simply due to the sheer VOLUME of constant negative feedback, so I think we all owe it to the mods to suck it up and cut him/them some serious amounts of slack.

                                                                      1. 21

                                                                        <3 Thank you very much.

                                                                      2. 24

                                                                        (Minor annoyance: we used to have a very good explanation of how to use flags, what borderline cases looked like, and so forth, but that was purged for whatever reason. I’ve seen a lot of bad flagging by either new folks who don’t know better or users with an axe to grind.)

                                                                        I would love to see this come back in some form. As someone who joined after that was removed, I feel there isn’t enough information about flags. Every single time I’ve ever flagged something, I’ve been really hesitant because I wasn’t able to find any guidance on what qualifies to be flagged.

                                                                        1. 3

                                                                          I agree. I actually don’t think this is so minor on its own though I can see why you phrased it that way in its original context.

                                                                        2. 23

                                                                          I realize I’m not as active as I might be - I’m bipolar, my ability to spend time on things comes and goes - but I promise that I do still pay active attention to the site and step in when it seems warranted. Also, the mod team has lots of discussions behind the scenes. Just because @pushcx is the face of a decision doesn’t mean the rest of us aren’t involved.

                                                                          I felt I should address that, since you mentioned it.

                                                                          Edit to add: Thank you for the kind words, overall. It’s helpful to know that you and others do see the point of the banner.

                                                                          1. 22

                                                                            People are really flag-happy, and this is what happens when you are.

                                                                            Speaking from experience as someone who’s moderated some decent-sized subreddits – where reddit has both the ability to downvote, and a separate ability to “report” for posts/comments that break subreddit or site-wide rules – this is absolutely the case. The number of people who just spam-click the “report” button thinking it’s some sort of super-downvote that will remove the thing they dislike is astounding. Same with people who periodically decide they just don’t like some type of content even if the subreddit generally allows it, and go mass-report a hundred posts to express their displeasure.

                                                                            1. 11

                                                                              Yeah, this is what I think is fundamentally the issue. A lot of people simply have no emotional control. They have strong believes but no ability to defend them. With that, when they see opinions they dislike, instead of engaging with a retort, they will use the report button. Perhaps in their mind, if the post was deleted, then the opinion no longer exists or is somehow invalid???

                                                                              I have gotten the banner too. I thought the words were harsh. But over the years I have noticed that some of my posts will follow the pattern of (+10 upvote, -8 troll), except the troll downvote count has increased over time. Based on this I assume that the general ratio of people on this site who like to report opinions they don’t like as troll versus people who are willing to engage in intelligent discussion has increased.

                                                                              People simply think people who disagree with them are either stupid, or trolling (deliberately saying stupid things hoping for a reaction) or both.

                                                                              1. 12

                                                                                A lot of people simply have no emotional control. They have strong believes but no ability to defend them. With that, when they see opinions they dislike, instead of engaging with a retort, they will use the report button.

                                                                                It’s also true that people sometimes repeatedly post tired nonsense, and that merely (and at obviously low cost) repeating something that’s poorly researched, or broadly offensive, doesn’t entitle the poster to a vigorous debate. Sometimes the use of a flag is the only viable option.

                                                                                1. 4

                                                                                  If somebody posted some tired nonsense then it should be very easy to dispute.

                                                                                  doesn’t entitle the poster to a vigorous debate

                                                                                  You don’t have to reply. The issue here isn’t whether or not to reply but whether or not reporting is an appropriate response to somebody saying something that you think is wrong and the answer is no.

                                                                                  Sometimes the use of a flag is the only viable option.

                                                                                  Anybody could deem all your posts ‘tired nonsense’ and just report all of them? That is as legitimate as when you do it. Do you somehow think that your idea of what is tired nonsense is universal and therefore a good metric for when a post should be reported?

                                                                                  1. 8

                                                                                    If somebody posted some tired nonsense then it should be very easy to dispute.

                                                                                    In the case of trolling, the whole point is to trick people into taking the bait, which I believe moves the subthread higher up in the scoring ranks.

                                                                                    You don’t have to reply. The issue here isn’t whether or not to reply but whether or not reporting is an appropriate response to somebody saying something that you think is wrong and the answer is no.

                                                                                    I think that detecting trolling is a skill that’s pretty key to the survival of a community, but a good troll will make it quite difficult to resist engaging. Trolling isn’t commonly overt, over the top rudeness. Way more often it is an attempt at looping other community members into a “debate” that ends up in people pointing edgy and charged hot takes at each other.

                                                                                    In its worst form, it will promote socially harmful conclusions through pseudo-from-first-principles lines of reasoning that are aesthetically attractive to the type of people that visit tech forums. To dispute requires dissecting phony arguments, which at a glance, appears to legitimize the “debate” and grant the troll a certain level of community approval, especially if they’re good at giving off the appearance of rationalism. IMO ignoring and flagging this type of content is nowhere near what’s required fully address it.

                                                                                    1. 3

                                                                                      How are you not using an accusation of trolling as a free ‘You lose’?

                                                                                      How do you know that something is true? It is via putting your ideas up for others to engage and debate. But you want to simply circumvent that by calling opinions you don’t like trolls, and then saying that those opinions don’t even need to be debated or engaged because that will legitimise it.

                                                                                      Sooner or later instead of having attacking each other’s ideas so we can improve then, all we will end up doing is claiming the other side is ‘trolling’ so they are immediately wrong and don’t even need to be disproven.

                                                                                      Why even bother defending your ideology against opposition, when you can simply claim the opposition is a foreign spy or a mentally ill person and then getting rid of them?

                                                                                2. 5

                                                                                  I have gotten the banner too. I thought the words were harsh. But over the years I have noticed that some of my posts will follow the pattern of (+10 upvote, -8 troll), except the troll downvote count has increased over time. Based on this I assume that the general ratio of people on this site who like to report opinions they don’t like as troll versus people who are willing to engage in intelligent discussion has increased.

                                                                                  Or maybe you’ve gotten more and more trollish over time.

                                                                                  1. 5

                                                                                    Or maybe we have too many politically driven ideologues who are not interested in communication and they simply throw the word troll around to avoid having to engage with their opposition on the idea plane.

                                                                                    1. 9

                                                                                      Nah, I’ve been around just about as long as you have, I can count on one hand the number of times I’ve not seen you be a troll in a thread. I don’t even know what technical subjects you have expertise in, since I’ve never seen you contribute technical insight to a thread. Pretty much all you do is get into fights around here.

                                                                                      1. 3

                                                                                        Devil’s Advocate: Perhaps @LibertarianLlama is among a new breed of Lobsters who are also concerned with the human side of things, not just the technical one.

                                                                                        1. 2

                                                                                          I’ve not seen you be a troll in a thread

                                                                                          I suppose you are one of those people who have a very low margin for what constitutes ‘trolling’.

                                                                                          I don’t even know what technical subjects you have expertise in, since I’ve never seen you contribute technical insight to a thread.

                                                                                          I didn’t realise technical expertise in a subject is a requirement of using this website. Regardless you can just assume that I have no expertise in any subject.

                                                                                  2. 6

                                                                                    I wonder if a literal “super downvote” button would work as a psychological trick. It would act as a normal downvote, but just look like a bigger, angrier button that would absorb more anger from whoever clicks it. (At the same time, possibly rate-limit the actual report button per user…)

                                                                                    1. 8

                                                                                      That’s a pretty cute idea. I’m tempted to say that, for people who have the self awareness to realize that what they mostly need is catharsis, I recommend getting it from their favorite action videogame, or a trip to the gym or whatever… I don’t want to dismiss your idea though, it’s true that it could help to have some sort of reminder or prompt to seek catharsis.

                                                                                      1. 3

                                                                                        Edit: someone has looked at the system and much of this is actually already automated(!): https://lobste.rs/s/zp4ofg/lobster_burntsushi_has_left_site#c_qiipbc

                                                                                        Previous:


                                                                                        OK, another cute - or hopefully even better - useful idea:

                                                                                        I think HN has a pr account setting that ignores flag from that user, I’m fairly certain dang has mentioned at some time that one should be careful with flags. (Now that I think about it it might have been the vouch option he was writing about.)

                                                                                        I’m not really sure how it would work with perfectly transparent moderation:

                                                                                        • would the user get a warning?
                                                                                        • or would it just show up in the moderation logs?
                                                                                        • maybe it is a fraction so if a user has 1/5 flag weight it takes more than 5 such users to flag before it counts as one ordinary user? Then the moderation log could still say “flagged based on user feedback” or whatever it say but omit the details about there being 10 flag abusers counting as two full votes and 3 ordinary users?
                                                                                        1. 11

                                                                                          Good thoughts. On Lobsters, if I know that a user is going to continue using flags vindictively, I would rather just ban them… of course, I’d talk to them first.

                                                                                          Automation in this sort of thing can be a false savings because if we set up a certain automated rule, we are implicitly sending the message that any behavior that falls within the rule is allowed. So in your example, I would expect to see users who intentionally stay just below the threshold for having their flags de-valued, as well as users who intentionally go past the threshold and flag in a wanton manner because they know that the punishment for doing that is just that their flags will have less numeric weight. Having it be a socially enforced rule, counterintuitively, can often lead to better behavior overall compared to having a technical enforcement mechanism.

                                                                                          1. 1

                                                                                            Good thoughts. On Lobsters, if I know that a user is going to continue using flags vindictively, I would rather just ban them… of course, I’d talk to them first.

                                                                                            Automation in this sort of thing can be a false savings because if we set up a certain automated rule, we are implicitly sending the message that any behavior that falls within the rule is allowed. So in your example, I would expect to see users who intentionally stay just below the threshold for having their flags de-valued, as well as users who intentionally go past the threshold and flag in a wanton manner because they know that the punishment for doing that is just that their flags will have less numeric weight. Having it be a socially enforced rule, counterintuitively, can often lead to better behavior overall compared to having a technical enforcement mechanism.

                                                                                      2. 5

                                                                                        The moderators of r/TheMotte (a subreddit which has the best moderation IMO) observed pretty much the same:

                                                                                        No one who has seen a mod queue would be surprised by this. Even those of you who are always very calm and nonconfrontational, with middle-of-the-road opinions, might be shocked how often your posts are reported. Some of the most reasonable, unspicy posts get marked as “It’s targeted harassment.” Some people will report “Inflammatory claim without evidence” just because they don’t agree with the post.

                                                                                        I pretty much started brushing aside (like several other users reportedly do) the red warning that lobste.rs throws in your profile for this reason, as well as for that condescending final phrase “Reconsider your behaviour or take a break” which rests on the erroneous assumption of there incontrovertibly being sound rationality in this community’s flagging behaviour.

                                                                                        I have a theory that this became worse after the site removed the downvote functionality thus removing a potential anger-outlet for users, who have now shifted to channel that affective energy via flagging. This theory however can only confirmed by doing a simple analysis of the data (was there an increase in flagging right after disabling downvoting?)

                                                                                      3. 12

                                                                                        It’s irrelevant that it is impartial if it is exploitable. Which it very much is.

                                                                                        So the system allows for a mob to harass an user into leaving the site, but you claim that it is important to note that anyone can be harassed. That is the matter subject to challenge here, not “important context”.

                                                                                        Yes people are trigger happy, for that reason, the flagging feature might be counter productive.

                                                                                        1. 5

                                                                                          you claim that it is important to note that anyone can be harassed.

                                                                                          I’m not sure I see where you got that from my post.

                                                                                          The ability of the mob to harass users here exists, and is exploited, at scale and quite apart from this notice that “yo, you’re getting a significant number of flags.”

                                                                                          It doesn’t make sense to optimize for people who run away when told others disagree with them.

                                                                                          1. 21

                                                                                            No one wants to be told they don’t belong here. I really enjoy Burntsushi and a system that is constructed that make it so people like that dont want to be here is a system that needs to be fixed.

                                                                                            Your response of “I don’t want people with a thin skin”, is itself thin skinned in the opposite direction.

                                                                                            1. 6

                                                                                              OK I see an important distinction here. I tried to point this out to burntsushi on Twitter.

                                                                                              If you read the message he got VERY carefully, it sets forth a very specific sequence of potential and suggested routes to mitigation. They are:

                                                                                              1. Take a breath. Take a break. Step away for a bit and think about whether maybe the problem might exist at least partly in your head and the resultant behavior you’re exhibiting in the community.

                                                                                              2. Talk to a moderator about the situation.

                                                                                              3. Then, and ONLY then, does the message point out that you can if you so choose also delete your account.

                                                                                              Having gotten the big red warning myself a ways back, I DO sympathize that it’s an ouchy thing to have happen in the moment, but I strenuously believe that the intent here isn’t to make anyone feel unwelcome. Just the opposite, my read of the intent is an earnest attempt on the part of the community to help people moderate their behavior, and if that’s not possible or applicable, to seek other options for mitigation.

                                                                                              1. 11

                                                                                                No one wants to be told they don’t belong here.

                                                                                                I’d agree, but we have done very poorly by some of our users in that regard already and the mob likes it that way. Remember that time recently the mods banned one of (if not the) current expert on evidence-based software engineering because of an off-hand comment touching culture war stuff? Peppridge farm remembers.

                                                                                                There are no shortage of Lobsters who will clack and freak out if made aware of anybody who doesn’t appear to be in their political tribe–and they’ll get even angrier if you suggest that maybe, possibly, we should focus on something else.

                                                                                                So, while I agree in principle with you, the community has through its actions demonstrated that it does not care.

                                                                                                Your response of “I don’t want people with a thin skin”, is itself thin skinned in the opposite direction.

                                                                                                I don’t believe that it is. You are, of course, welcome to your own interpretation.

                                                                                                1. 14

                                                                                                  Remember that time recently the mods banned one of (if not the) current expert on evidence-based software engineering because of an off-hand comment touching culture war stuff?

                                                                                                  IIRC he had a pattern of problematic behavior, and also I’m not sure how much of an expert in ESE he actually is: his book is overwhelming, but keeps giving me bad vibes. I’m struggling to explain what it actually is, but I’m really suspicious that there are serious problems with it.

                                                                                                  1. 1

                                                                                                    I’d definitely be interested to hear more.

                                                                                                    I’m struggling to explain what it actually is

                                                                                                    Mind giving it a try? I couldn’t see anything particularly bad (relatively speaking) in their comment history, nor anything related to the ban rationale. Seems like you’ve been paying more attention, haha

                                                                                                  2. 14

                                                                                                    There are no shortage of Lobsters who will clack and freak out if made aware of anybody who doesn’t appear to be in their political tribe

                                                                                                    The basic problem with statements like this is that nearly everyone can feel it applies to the angry mob that’s disagreed with them.

                                                                                                    Personally I’m on record as believing that there is no way to separate “politics” from what we do (simple example 1, simple example 2) or to write software without considering the impact it will have on people.

                                                                                                    But I also see plenty of “oh woe is me, the cancel culture and the woke and the leftist and the SJW are taking over” stuff that gets left in place and even highly upvoted, which says to me that it’s not that people don’t want “politics”, it’s that their definition of what is and is not “politics” is at issue. The hypothetical guy (example 2 above) with no criminal record who can’t get bail because the system could only store his name as a bunch of “aliases” is “politics” to me, but apparently not to many other people (it’s just “falsehoods programmers believe about names”), while holding a software project’s leader accountable for misbehavior is “politics” to many of those people and common sense to me. A staggering percentage of actual “political” fights really are that sort of thing.

                                                                                                    1. 3

                                                                                                      But I also see plenty of “oh woe is me, the cancel culture and the woke and the leftist and the SJW are taking over” stuff that gets left in place and even highly upvoted, which says to me that it’s not that people don’t want “politics”, it’s that their definition of what is and is not “politics” is at issue.

                                                                                                      I mean the proof is at hand right? A “let’s not discuss politics” non sequitur as successful troll.

                                                                                                      1. 0

                                                                                                        But I also see plenty of “oh woe is me, the cancel culture and the woke and the leftist and the SJW are taking over” stuff that gets left in place and even highly upvoted

                                                                                                        I don’t think I’ve ever seen this on Lobsters, only on others sites. Do you have any examples?

                                                                                                      2. 1

                                                                                                        I think we disagree about what it means to be thin skinned. I thought you were admonishing the people who leave into toughening up. If that is the case, I think it will lead to either an echo chamber or a dungeon of trolls or both.

                                                                                                        But based on your other comments, I don’t think you meant what I interpreted.

                                                                                                        You in this context means, us, or the offended user that flags people into quitting. How about we make flags public and you can only spend them in certain ways? Do comment points even mean anything? There is a huge distinction between “this person is harmful” and basically anything else. if someone is harmful, they should be removed. Otherwise … if you don’t want to see their posts, then that would be a personal choice.

                                                                                                        1. 2

                                                                                                          Making flags public is a terrible idea.

                                                                                                          1. 2

                                                                                                            I agree. I DO think that people here are overly trigger happy with the flagging, but given other comments in this thread I’m willing to believe this is simply human nature at plan and unavoidable. Making flags public would be in effect shaming someone for trying to make a small contribution to the community by flagging a post.

                                                                                                            1. 2

                                                                                                              I feel that maybe 60% of flags are not trying to contribute to the community, but rather to avenge themselves, or to have an outlet for disagreement without having to engage. It’s part of the problem with the Internet at large: for digital natives, disengagement is no longer an option. People can’t just ignore stuff they disagree with; they have to respond to it, and if it’s a troll, they shouldn’t engage directly, so they instead engage indirectly by flagging. There’s a reason why Twitter’s first option when reporting is “I disagree with this”. It’s just human nature.

                                                                                                            2. 1

                                                                                                              Because? Without justification your statement is opinion, what am I to do with that?

                                                                                                              1. 1

                                                                                                                Because it can lead to retaliatory, tit-for-tat flagging of the flagger’s comments. Mods can already see who flags what and can take action against those who misuse it.

                                                                                                        2. 2

                                                                                                          a system that is constructed that make it so people like that dont want to be here is a system that needs to be fixed.

                                                                                                          Who are “people like that”? To me, this sentence seems to extrapolate based on a single data point, which is based on some observations of another person. That is to say, we don’t know Burntsushi well enough, and maybe no matter how we setup the system, he would find something to quit. And striving to optimize for one would put burden and alienate others.

                                                                                                          1. 5

                                                                                                            people like that

                                                                                                            Hardworking, smart, helpful, writes a lot of great Rust. Reddit and github

                                                                                                            I am talking about specifics not a generalized idea of a Lobste.rs user.

                                                                                                          2. 0

                                                                                                            Since that person left, I’m not getting a flag on every single of my comments anymore.

                                                                                                            An interesting coincidence. ¯\_(ツ)_/¯

                                                                                                            1. 0

                                                                                                              Obligatory “correlation is not causation”.

                                                                                                          3. 5

                                                                                                            That is the problem right there. It.s not a “disagree” link, it’s a “flag” link. Obviously, looks like there are people abusing it because they disagree with something rather than unacceptable behaviour being reported.

                                                                                                            Personally, I wouldn’t take it too seriously much less posting on other websites about it. But it is rather shitty to be told to take a chill pill just because one’s opinion is not widely accepted.

                                                                                                            1. 1

                                                                                                              Accounts with low “karma” can’t downvote but can flag. Perhaps this needs to be looked at..

                                                                                                              1. 6

                                                                                                                There are no downvotes, only flags.

                                                                                                                1. 2

                                                                                                                  TIL. I stand corrected

                                                                                                                  1. 1

                                                                                                                    Thanks for clarifying this. I was wondering where the downvote links were.

                                                                                                                    1. 4

                                                                                                                      iirc the downvotes were the flags, just with a downvote arrow instead of being hidden.

                                                                                                              2. 3

                                                                                                                It doesn’t make sense to optimize for people who run away when told others disagree with them.

                                                                                                                I think discourse is improved when all participants feel safe. Then instead of spending energy in handling negativity emotionally, they can make better arguments. Moreover I don’t want to see valid viewpoints shut down due to mob shouting. I think human discourse works well with a variety of opinions.

                                                                                                                1. 16

                                                                                                                  I think human discourse works well with a variety of opinions.

                                                                                                                  I agree!

                                                                                                                  I think discourse is improved when all participants feel safe.

                                                                                                                  The problem we’re seeing in the last several years is that there are people who will never feel safe, at least not without massive sacrifices from everybody else in a community, often including systematic self-censorship and topic avoidance. The great online community question of the age is how to strike a balance between being welcoming and letting your demographics become taken over by–for lack of a better way of putting it–people who are not robust enough to survive or flourish in a sufficiently diverse/hostile memetic ecosystem.

                                                                                                                  1. 9

                                                                                                                    people who are not robust enough to survive or flourish in a sufficiently diverse/hostile memetic ecosystem

                                                                                                                    I’m not sure what kind of online future you’re envisioning but I don’t want any part of it.

                                                                                                                    1. 15

                                                                                                                      An (only slightly contrived) example:

                                                                                                                      You run a message board that hosts tech content.

                                                                                                                      On one extreme, you tell everybody “hey, we want you here! everybody is super nice and you’ll never be criticized!”.

                                                                                                                      After some period of time, you end up with a bunch of users of C and a bunch of users of Rust.

                                                                                                                      Some of those users cannot bear any perceived slight of their chosen language. There are C people that go off in a tizzy if anybody points out the memory safety issues in C, and there are Rust users that freak out if anybody complains about long compile times. The house rules–because remember, we’re optimizing for welcoming and that means supporting everybody, no matter how thin-skinned they are!–end up including “Never talk about shortcomings of another language.”

                                                                                                                      Since engineering is all about tradeoffs, and since no language is actually good for all things, strict adherence to this rule ends up with only the most optimistic and vapid discussion–worse, it infects other topics. It’s really hard to explain why you might like immutability for concurrency if you can’t talk about memory safety issues because you’ll trigger the C programmers. It’s really hard to explain why you like dynamic or interpreted languages if you can’t talk about how much long compile times suck because you’ll trigger the Rust programmers.

                                                                                                                      On the other extreme, you tell everyone “hey, we talk about tech and things on their own merits here, and if you can’t stand commentary that offends, fuck off!”.

                                                                                                                      Our C users and Rust users come in.

                                                                                                                      Some of these users are just assholes. There are C programmers that strictly use bizarre sexual analogies for anything involving pointers, there are Rust coders that sign all of their posts with Holocaust denial, frequently threads devolve into seeing who can outlast who in massive shit-slinging, and in general a sport is made of making miserable and hazing anybody who won’t stick around.

                                                                                                                      Obviously, there will be users who would be knowledgeable assets to this community but who are squicked out by this stuff and leave. There are other users who can put up with the rampant nonsense but who don’t want to spend the cycles required to weed through the bullshit to talk about what they want. Over time, the community stagnates unless it can find a way of attracting and retaining new users, and odds are that’ll be based on its reputation for no-holds-barred “discussion” rather than actual technical insight…this userbase will also skew towards younger folks who have a deficit of experience and all of the time in the world to share it. This is, incidentally, how /g/ works.

                                                                                                                      ~

                                                                                                                      I’m not sure what kind of online future you’re envisioning but I don’t want any part of it.

                                                                                                                      My point isn’t to advocate for one or the other, but to point out that it’s a central question of community.

                                                                                                                      It’s also a question whose answer shifts over time, as groups tweak the trajectory of their tribe.

                                                                                                                      1. 8

                                                                                                                        Some of these users are just assholes. There are C programmers that strictly use bizarre sexual analogies for anything involving pointers, there are Rust coders that sign all of their posts with Holocaust denial, frequently threads devolve into seeing who can outlast who in massive shit-slinging, and in general a sport is made of making miserable and hazing anybody who won’t stick around.

                                                                                                                        And there’s a pretty easy way to fix that – kick ’em out. There are communities which do that.

                                                                                                                        Because as the saying goes, there are two ways to be a “10x programmer” and one of them is to have such an awful effect on people around you that they drop to 0.1x their prior productivity while you stay average. And even if someone really is “10x” (whatever that means) on some aspect of technical skill or knowledge, it’s still likely to be a net loss to put up with “asshole” behavior from them.

                                                                                                                        1. 2

                                                                                                                          This is good advice and knowledge for me as I try to build one or more Open Source communities. I think you are correct that such communities should have no room for such users.

                                                                                                                          1. 1

                                                                                                                            For the purposes of that thought experiment, we take the position in the second case where we do not eject members for being assholes.

                                                                                                                        2. 3

                                                                                                                          I saw another attempt at creating a HN clone go down a few years ago, not because of flaming or lack of interesting users but because some early users decided they and everyone else decided they needed to be much nicer than HN.

                                                                                                                          I quit commenting soon after.

                                                                                                                          You can check my comment history, I’m not at rude person but those rules made me feel unsafe. I started carefully considering each word. Then stopped posting,

                                                                                                                          I wasn’t the only one. The “super nice” crowd didn’t have anything else to contribute and the site was down a few months later.

                                                                                                                          1. 8

                                                                                                                            Honestly, one of my main issues with HN has always been the focus on superficial civility. You can be an absolute horrendous awful drive-others-away-in-droves trainwreck of a poster there so long as you do it the “right” way. And you will be valued and rewarded for it.

                                                                                                                            A real “anti-HN” would care less about those superficial aspects and more about dealing with the actual trolls and assholes.

                                                                                                                        3. 4

                                                                                                                          people who are not robust enough to survive or flourish in a sufficiently diverse/hostile memetic ecosystem

                                                                                                                          Perhaps I don’t see this as an issue. I believe, in my ideal community (where I’m stressing “ideal” because it’s probably not practically realizable), that any commenter with a good-faith argument should feel empowered to make that comment, even if others in the community viscerally disagree. There are two problems at hand here, one is defining what “good-faith” mean and the other is protecting arguments from being shouted out. When it comes to “good-faith”, due to the nature of human ideology, there will be disagreements. In my mind, the easiest way to come to a consensus on what “good-faith” means is to clearly define it. This is why I’m a fan of Code of Conducts. They lay bare what a community considers “good-faith”, so the minimum bar of participation is met. Ideally the CoC would change infrequently and have community buy-in so that it acts as a minimum bar to entry.

                                                                                                                          Ideally (again the ideal here not the practice, probably), we can create a community where there is no hostility after agreeing to “good-faith” rules. It’s one thing to enter heated discussion, but I’m hopeful that a community can use its own moderation tools to ensure that a heated discussion does not turn hostile.

                                                                                                                          I just don’t see a world where diversity and hostility are equivalent.

                                                                                                                          1. 1

                                                                                                                            When it comes to “good-faith”, due to the nature of human ideology, there will be disagreements.

                                                                                                                            I make good-faith arguments all the time that seem to fall into the class of bad-faith arguments that @bitrot points out, so I get what you’re saying.

                                                                                                                            I just don’t see a world where diversity and hostility are equivalent.

                                                                                                                            In the interest of naming things, it seems what’s under discussion is the paradox of tolerance. I’d link to Wikipedia, but it seems it’s a Marxist idea, which I know not everyone would be comfortable with 😄


                                                                                                                            At some point, I think you just have to go by how things seem. Which is a shame, because that makes it a game of “survival of the fittest”, where those who are best at branding, or putting things “the right way” to seem good to other people, survive; while those who are prone to misrepresenting themselves, or discussing “untouchable subjects” such as the example in @friendlysock’s comment, are booted out.

                                                                                                                            1. 2

                                                                                                                              In the interest of naming things, it seems what’s under discussion is the paradox of tolerance. I’d link to Wikipedia, but it seems it’s a Marxist idea, which I know not everyone would be comfortable with 😄

                                                                                                                              Indeed, I am familiar with the Paradox of Tolerance. My hope is that a CoC or otherwise similar guiding document or constitution would provide a floor on tolerance, but everything beyond that would be tolerated. Not only does that set community baseline rules but it keeps rules distinct, clear, and constant. There’s a reason many real, representative governments go through due process to change laws.

                                                                                                                              At some point, I think you just have to go by how things seem. Which is a shame, because that makes it a game of “survival of the fittest”, where those who are best at branding, or putting things “the right way” to seem good to other people, survive; while those who are prone to misrepresenting themselves, or discussing “untouchable subjects” such as the example in @friendlysock’s comment, are booted out.

                                                                                                                              Perhaps the conclusion I should arrive to is that direct democratic (e.g. “upvote” and “downvote”) discussion sites just lead to dynamics that create and sustain echo chambers. I’m not sure, it’s certainly something I’m mulling about myself.

                                                                                                                      2. 2

                                                                                                                        when told others disagree with them.

                                                                                                                        But that’s not what flagging tells you… If you’ve been doing everything alright, it tells you that others who disagree with you have leveraged a system unrelated to disagreement to make you look unreasonable, unkind, and/or trollish.

                                                                                                                      3. 4

                                                                                                                        I’d be interested in learning if mods have any way to detect brigading, possibly such as by looking at correlations in users who consistently flag the same comments.

                                                                                                                        1. 13

                                                                                                                          Yes, we do. If you look at the mod log you will see that people are banned for this practice now and then. Don’t do it.

                                                                                                                          1. 1

                                                                                                                            I’m not sure why you needed to admonish me like that at the end. I wasn’t probing your defenses. I was merely going to suggest this if you didn’t have it.

                                                                                                                            No need to reply, I know this is a tough time for all the staff.

                                                                                                                            1. 7

                                                                                                                              Sorry, I should have been clearer that I wasn’t directing that at you in particular. I know you were trying to help.

                                                                                                                      4. 8

                                                                                                                        Preface: I don’t have his comments handy and am just looking at the system. Despite this I will be embarrassed if it turns out he was actually making an enormous mess 🤣

                                                                                                                        Also want to add whoever worked on the existing system clearly put a lot of thought into it (e.g. factoring in flags on multiple stories, percent-flagged, and limiting to N users all seem wise, and thought went into the message). Probably no fun to see someone armchair quarterbacking with much less time thinking about the problem space than they have. Hope this at least crosses the threshold of possibly useful.

                                                                                                                        The thing here being complained about? It’s in the source code, it’s very clear how it works, and it provides impartial, statistical feedback about what’s going on.

                                                                                                                        It looks like this is it. My guess is if you’re prolific, it’s inevitable you’ll pop over the hard numerical thresholds sometimes and the 10% of comments is the biggest barrier, followed by the top-30 ranking.

                                                                                                                        10% of comments seems not that unlikely if 1) your recent comments are seen by lots of people (upvoted, early, etc.), 2) they address things a lot of people disagree about, and 3) some % of folks who disagree will flag, which seems likely as long as flagging is one of the easier ways to express disagreement (more below). You could do something like subtract the upvotes/N from the flag count (lots of fiddly options), just because there isn’t a number that represents visibility directly.

                                                                                                                        The top-30 ranking has has the same considerations as flag count, and also if discussion is going well enough, the 30th “worst” person might not be that bad. (Somebody’s the least polite person in a group of absolute diplomats.) The histogram/rank data does seem interesting to expose to the more flagged folks. Given all that, I’m not entirely sure what I think about the wording of the message–definitely already phrased to aim for “stop and consider this” not “you’re a bad actor”, but I can also see how humans get defensive.

                                                                                                                        People are really flag-happy, and this is what happens when you are.

                                                                                                                        (Added clarifications here in [brackets] after friendlysock’s comment.)

                                                                                                                        A nice thing about [the idea of downvotes for simple disagreement, as used on some other sites, is that it lets] people who simply don’t like something say “I don’t like this” without putting noise in the channel that’s used to catch abuse, spam, and so on. I think the dream behind the current system is that not having [no-reason] downvotes leads to a very pluralist site where many people disagreeing (or fewer disagreeing strongly) doesn’t count against a comment as long as there’s no objective problem with the phrasing/on-topicness/etc. Realistically it seems as if without another outlet, some fraction of disagreement will get funneled into the flag system (even just through people looking hard for technically valid reasons to flag) even if you try to discourage it.

                                                                                                                        Just as a random thought, you can offer downvotes without treating them as -1 upvote (-0.5 or -0.25 or whatever in a ranking algorithm), or disagree flags that you treat differently from others.

                                                                                                                        tl;dr if I guessed at possible tweaks they might be allowing [no-reason] downvotes or disagree flags that have less impact than existing flags, just to keep that self-expression out of the flagging system; look for a way to factor in that being more-read will get your comments more negative attention; and maybe there’s something to do with the message wording, though it’s clearly already had a good amount of thought put in it.

                                                                                                                        1. 16

                                                                                                                          A nice thing about downvotes is it lets people who simply don’t like something say “I don’t like this” without putting noise in the channel that’s used to catch abuse, spam, and so on.

                                                                                                                          Yes, I very much agree with this. On Reddit and Hacker News, which lobster.s is modelled after, I think of as:

                                                                                                                          • upvote: “I would like this to appear higher on the page”
                                                                                                                          • downvote: “I would like this to appear lower on the page”

                                                                                                                          Flag is a totally different thing than downvote – it means that the user is abusing the site, and continuing that behavior SHOULD result in getting banned from the site.

                                                                                                                          But expressing minority opinions (thoughtfully) may result in downvotes (*), but it should NOT result in getting banned or encouraged to leave.


                                                                                                                          As far as I can tell, the burntsushi warning was a result of mixing up these signals. I only read a portion of the Rust threads, so I haven’t followed everything, but from what I understand he was probably just expressing some opinions that people disagreed with, not actually abusing the site.

                                                                                                                          So I think you have diagnosed it correctly – the lobste.rs UI is sort of mixing these 2 signals up by omitting downvotes. The “flag” button has 5 reasons, and “off topic” and “me too” should be a downvote, not a flag IMO.

                                                                                                                          Again, the difference between the two is whether continuing the behavior should lead to a ban, and that’s a very important distinction.

                                                                                                                          (Honestly I am surprised that I haven’t gotten this banner ever, given that there is a minority of people who disagree with my opinions on shell. Since I’m writing a new one, I’m opinionated about it, but also invite disagreement)


                                                                                                                          (*) Some people may want opinions they disagree with to appear lower on the page, and some people might not. In my view it’s up to person to exercise that discretion – that’s why you get one vote :)

                                                                                                                          1. 3

                                                                                                                            upvote: “I would like this to appear higher on the page” downvote: “I would like this to appear lower on the page”

                                                                                                                            That’s not actually what they mean on Reddit:

                                                                                                                            Vote. If you think something contributes to conversation, upvote it. If you think it does not contribute to the subreddit it is posted in or is off-topic in a particular community, downvote it.

                                                                                                                            ‘I would like this to appear higher/lower on the page’ is so ambiguous that it leads to different people misunderstanding it and applying it differently.

                                                                                                                            1. 6

                                                                                                                              I’d say that’s a prescriptive definition, but a descriptive one is more useful [1], and thinking about it that way will be more likely to solve the problem.

                                                                                                                              That is, “users don’t read documentation”, and it means whatever the users think it means, and it changes over time. FWIW I’ve been using Reddit since 2007, and HN since 2011 or so, and there’s never complete agreement on what these things mean.

                                                                                                                              I’ve seen the debate about downvote vs. disagree several times over the years on the sites. I choose to sidestep it with the vague definition – that’s a feature! :) It’s OK to be vague sometimes.

                                                                                                                              In cases like this, where the number of flags leads to either banning or encouragement ot leave, I think it’s better not to be vague, and have 2 distinct mechanisms. This isn’t a big change, as lobste.rs had both downvoting and flagging until very recently.

                                                                                                                              [1] https://amyrey.web.unc.edu/classes/ling-101-online/tutorials/understanding-prescriptive-vs-descriptive-grammar/

                                                                                                                              1. 2

                                                                                                                                This isn’t a big change, as lobste.rs had both downvoting and flagging until very recently.

                                                                                                                                I don’t think it had both, rather the flag button just looked like a “downvote” button. You still selected from the same reasons that flag presented. This change is the one that altered the styling I believe. There’s plenty of places that refer to it as “voting” in the code still, but unless I am mistaken there was only ever the one mechanism.

                                                                                                                          2. 7

                                                                                                                            A nice thing about downvotes is it lets people who simply don’t like something say “I don’t like this” without putting noise in the channel that’s used to catch abuse, spam, and so on.

                                                                                                                            So, the purpose of downvotes was emphatically not to express disagreement…it was to signal one of a handful of error conditions (bad information, factual inaccuracy, etc.). There is very little utility in seeing how many people merely disagree about something, especially given how fast people are to be mean to each other.

                                                                                                                            As a historical point, @jcs at one time disabled downvotes. It did not last more than a week or two before it was brought back.

                                                                                                                            1. 11

                                                                                                                              Sorry, I see how it was worded unclearly. I understand that the intention currently is to have no “disagree” button. I’m saying that having that button could reduce how often people flag comments they disagree with as having one of the error conditions, which they might do by by stretching definitions, picking a random reason, or just preferentially noticing real flaggable issues when they happen to dislike the content. (I think the unclarity comes from me using “downvotes” to mean “a no-reason downvote button” as opposed to flags as they exist–I edited to clarify above.)

                                                                                                                              It may be useful to let people push a button for disagreement even if your algorithms assign a low weight to those clicks. I say low weight rather than zero because having a 100%-placebo button in the UI raises other issues, even if moderators give zero weight to an easy expression of disagreement. I’d probably give a no-reason-given downvote nonzero weight in my head but I don’t expect others to adopt my weights.

                                                                                                                              Shorter, the idea is that people sometimes find a way to “downvote” for disagreement however you set up your UI, and you might get a net harm reduction by just giving them the button they want and then deciding what to do with the data.

                                                                                                                              1. 6

                                                                                                                                Ah, so kind of like the buttons on crosswalks?

                                                                                                                                Anyways, thank you for elaborating further. :)

                                                                                                                                1. 4

                                                                                                                                  Very well said. Even if the system is not equipped with a “disagree” button, some users may desire one and use whatever means are at hand to express themselves. The phrase, “the purpose of a system is what it does,” comes to mind.

                                                                                                                                  If existing mechanisms are not meant for use in disagreements, then we might ask if that is actually how they are being used.

                                                                                                                                2. 4

                                                                                                                                  That’s nice, but you can’t make users behave the way you want them to behave, if you’re not going to actively act against it. People not only downvote because they disagree, but they’ll also flag things as spam or off-topic or “troll” just because they disagree, or feel you’ve insulted their particular religious (as in vimacs-vs-spaces) beliefs.

                                                                                                                                  1. 6

                                                                                                                                    I think I’d prefer a system that discourages misuse of flags. Maybe a similar message for people who flag a lot

                                                                                                                                    1. 3

                                                                                                                                      Sure, folks determined to game things would still flag. My theory is decently many who flag today are not determined to game things, and would click a down arrow for “just no” given the option. That’d reduce noise in the flag system even though it wouldn’t eliminate it. (And not saying you couldn’t do other changes too.)

                                                                                                                                  2. 4

                                                                                                                                    in fact, you can have placebo downvotes that show up for the person doing the downvoting but do not affect the vote count otherwise. that would keep (almost) everyone happy, i think.

                                                                                                                                  3. 6

                                                                                                                                    Agreed.

                                                                                                                                    I think it’s fair to discuss whether the wording of the warning message can be improved, but various comments here that pretty much amount to “person X is popular, he should be exempt from the rules” are just tiring.

                                                                                                                                    1. 8

                                                                                                                                      How is being flagged a rule? It’s not a rule. That is the whole problem.

                                                                                                                                      Anyone can flag any comment any time.

                                                                                                                                      1. 2

                                                                                                                                        Receive too many flags, get a notice. That’s the rule.

                                                                                                                                        1. 9

                                                                                                                                          That is not a rule in the sense of rule that can be followed by users. I did’t read a single comment suggesting that shouldn’t apply to some user because of its popularity, but rather many people pointing out that this is a clear case illustrating that such system is broken and should be fixed for all users.

                                                                                                                                    2. 5

                                                                                                                                      rather than continue to engage in a community they don’t fit into

                                                                                                                                      Is lobster a community that accepts a plurality of opinion? If it is, then you will always have people disagreeing with you and therefore be liable to be reported by some of these people.

                                                                                                                                      Democracy leads to lynching. Mass reporting is basically the lynching of internet persona. Any kind of automatic penalty that can be initiated via reporting is simply giving power to the angry mob. Autoban and autosuspend based on reports have always been abused.

                                                                                                                                      1. 3

                                                                                                                                        You’re still here, so evidently the suggestion doesn’t apply to you. You’re glad to contribute.

                                                                                                                                        Why not show the warning to flag-happy people? I don’t have stats but I feel like that could be a better indicator of who doesn’t want to be here.

                                                                                                                                      2. 21

                                                                                                                                        Why do we need this passive aggressive banner anyway? It looks bad for Lobster, not for the person seeing it, and it’s not clear what problem it’s supposed to solve.

                                                                                                                                        1. 19

                                                                                                                                          We consistently see the vast majority of bad behavior come from the same few users. There’s a phenomenon, called the normalization of deviance, whereby people whose behavior is far away from the norm often genuinely don’t realize just how far it is. The banner, and the histogram that it links to, are intended as a way for people to self-correct. I personally am a big believer in giving people opportunities for redemption, and the histogram makes the point in a way that mere words can’t.

                                                                                                                                          1. 6

                                                                                                                                            far away from the norm

                                                                                                                                            Far away from the norm doesn’t mean bad. You seem to be assuming that it is.

                                                                                                                                            1. 8

                                                                                                                                              I appreciate you raising that. On the contrary, I agree that sometimes people’s behavior is far from the norm for positive reasons. I do think that, even in those cases, everyone can benefit from a heads-up and a chance to reflect about whether it’s what they want.

                                                                                                                                              1. 3

                                                                                                                                                As in reflecting on do you want to be good when everybody else is bad?? Am I reading that right?

                                                                                                                                                1. 6

                                                                                                                                                  Well, yeah. I know for a fact that people have left Lobsters for that reason (or at least, that’s how they see it). While I am sad when people leave, I don’t think anyone is obligated to stay somewhere that doesn’t make them happy. It would be wrong of me to try to trick or coerce people into staying when their free choice, with all the facts available, would be to leave.

                                                                                                                                                  I’m not really sure why you’re asking this, though. The flagging system doesn’t have the ability to determine who’s right and who’s wrong. Even if I wanted to take my personal concept of “good” and write code that ignores flags that aren’t “good”, there is no existing technology that can do anything like that. If that’s what you’re advocating for, feature request noted but I’m not able to do it.

                                                                                                                                                  1. 3

                                                                                                                                                    I’m not really sure why you’re asking this, though

                                                                                                                                                    I am not asking anything. I was commenting on an implicit bad argument you made (the implication that the norm is correct). You decided to double down by arguing that even if somebody was correct, they should ‘reflect about whether it’s what they want’. I simply then pointed out that this doesnt reinforce your original argument, because it itself is bad, because having a bad feature (aggressive warning about being reported) is not validated by having that feature also be useful to do useless thing (letting people reflect on whether they should be good, because the answer is always yes).

                                                                                                                                                    I don’t think anyone is obligated to stay somewhere that doesn’t make them happy.

                                                                                                                                                    Of course not. The point is that assuming that lobsters want a community that engage in meaningful discussion, then it should make people want to stay and be happy, that is a worthy goal. all of this is following your argument for the banner, the argument which I consider to be invalid, as pointed out.

                                                                                                                                                    1. 5

                                                                                                                                                      Being distant from the norms can hold little moral judgment and yet be relevant when operating in a constructed community.

                                                                                                                                                      1. 2

                                                                                                                                                        Okay, I guess that’s fair.

                                                                                                                                                        I think we disagree about something in there, but it sounds like figuring out what isn’t a high priority for either of us? I appreciate the discussion, anyway.

                                                                                                                                                2. 1

                                                                                                                                                  I at least didn’t read that implication into the post. Not all ways of being far from the norm are likely to result in seeing the banner. It isn’t a perfect system but it’s definitely not symmetric, so that assumption isn’t necessarily required.

                                                                                                                                                3. 2

                                                                                                                                                  Thanks for clarifying. But I still think it doesn’t make Lobster looks good because this feature implies that “deviant” behaviour should be corrected and can be automatically detected, and I expect most people (especially in tech) aren’t comfortable with either of these.

                                                                                                                                                  I’m wondering what’s the worse that could happen if the banner is not displayed? Maybe the person who’s being flagged all the time will get the point and adjust their behaviour, or maybe they don’t need to adjust anything and it’s other people that will start seeing that perhaps that person has a point. I also believe in giving people a second chance but I don’t think the solution to everything has to be algorithms, sometimes simple human interactions are preferable.

                                                                                                                                                  1. 3

                                                                                                                                                    The hypothesis that motivates the banner and histogram is that, by displaying them, those conversations about what to adjust will happen sooner and be more productive. The goal is to head off situations where somebody doesn’t believe mods when we tell them something needs to change, and they ultimately leave the site. It may be right or wrong but that’s the motivation.

                                                                                                                                                  2. 1

                                                                                                                                                    Do you think that the banner has an observable positive effect? Do you see a change in behavior from the few users you say produce the majority of bad behavior? As friendlysock says above, they see the banner nearly all the time. Do you think they have been falsely-flagged by this system? If so, can you estimate how high the false-positive rate of showing this banner? If friendlysock has been appropriately warned by this system, have you seen any change in their behavior onsite?

                                                                                                                                                    If it is truly only a few users producing undesirable behavior, could it be more effective to simply reach out to those users personally?

                                                                                                                                                    1. 3

                                                                                                                                                      I’m not going to publicly discuss my personal feelings about specific community members. It wouldn’t be fair to anyone.

                                                                                                                                                      I don’t have a methodology to conclusively determine how much influence the banner has had, but the site has a lot less flagging in general than it did a couple years ago. I take that to be an indicator that things have calmed down significantly, and I do think that’s good.

                                                                                                                                                      I do reach out to people personally from time to time, as do the other mods. The banner and histogram were created to address a shortcoming in that approach, where sometimes people aren’t willing to listen to criticism unless they’re presented with data that validates it. I’m skeptical of going fully data-driven for everything, but I think it’s nice to have at least this one particular metric for those who find it easier to take concerns seriously when there’s a metric.

                                                                                                                                                4. 20

                                                                                                                                                  Additional suggestion to all the previous improvements: make that banner a thing that’s moderator-initiated. I of course don’t have statistics on how many people see it (I never got it, so I just learned about it now, anecdotally) but I could imagine that this is rare enough that moderators could just evaluate sending this message to users by hand after the system flags the user internally.

                                                                                                                                                  1. 6

                                                                                                                                                    I of course don’t have statistics on how many people see it

                                                                                                                                                    I don’t have that statistic either, but as I posted elsewhere, only 13 people have been flagged more than me in the last month and I haven’t seen it. Only 7 people have been flagged 10 or more times. I’d therefore expect that trimming it down to 5 people that moderators need to take a look at per month is quite feasible.

                                                                                                                                                    If even that is too much of a load for the moderators, then it might be possible to select a dozen people who have been active recently but not participated in any of the flagged threads to do a triaging pass. At that point, having someone reach out to the person and say ‘you’ve had a lot of things flagged recently, is there anything going on in your life that you want to talk about?’ would be a fairly low load.

                                                                                                                                                    1. 3

                                                                                                                                                      You can a chart that gives you a clear idea how many people see it at /u/you/standing. So you can see it at /u/david_chisnall/standing and I can see it at /u/hoistbypetard/standing. The red Xs should represent users seeing the warning.

                                                                                                                                                      I’d never suggest that someone else should just add a thing to their plate, but it does seem like the kind of thing where, if there were a few active moderators, requiring someone to approve the red box might be an improvement for a relatively low effort. That feels like the kind of statement I should only make if I’m accompanying it with a patch, though, and I can’t offer that right now.

                                                                                                                                                  2. 15

                                                                                                                                                    Yep, I think the current wording will probably trigger exactly the wrong people “have I overstepped a border? Probably” and the people who are actively engaging in a little bit of flaming won’t be bothered.

                                                                                                                                                    1. 7

                                                                                                                                                      Following on the “let’s get shit done” vibe, is there an open issue for discussing this in more detail on github? I did a quick lookup and didn’t find any, would be cool if it was posted here (even better if as a top comment)

                                                                                                                                                      1. 5

                                                                                                                                                        Good idea, thanks! (Obvious in retrospect, like many good ideas.) I created an issue.

                                                                                                                                                      2. 4

                                                                                                                                                        I mildly agree with both of those things, but I also think that the suggestion further down the thread to re-introduce downvoting as “non-bannable feedback” could address the issue more directly.

                                                                                                                                                        https://lobste.rs/s/zp4ofg/lobster_burntsushi_has_left_site#c_padx5h

                                                                                                                                                        Some people may misuse flags and downvotes, but overall I think these guidelines are intuitive and easy to remember:

                                                                                                                                                        • upvote: this should go higher on the page
                                                                                                                                                        • downvote: this should go lower on the page
                                                                                                                                                        • flag: if the user continues this behavior, they should eventually be banned
                                                                                                                                                        1. 2

                                                                                                                                                          In my post I’m trying to focus on an easy thing to do to help reduce this problem. I have the impression that rewording the banner is something that’s reasonably easy, while “let’s reintroduce downvotes” or “the banner should be approved by moderators before being shown” are important change in process that require a lot of discussion. They may be excellent ideas, but it’s a lot more work to discuss and turn them into action, so I think it’s best not to mix the two kind of suggestions if we want to change anything at all in the short term; they should be discussed separately, and maybe differently. (I could just send a PR to rephrase the banner; any of the other suggestions requires more discussion with contributors, etc.).

                                                                                                                                                          1. 1

                                                                                                                                                            Yes, it makes sense to do the easy things first. My impression was that we had downvotes several months ago, so it shouldn’t that big a change to restore them, but I’m not involved so I could be wrong.

                                                                                                                                                            I was mystified by the removal of downvotes, and never saw the rationale for it. I saw one thread discussing it 3 or 6 months after they were removed, which still didn’t answer my questions about why they were removed. It made the site worse for me, but not enough to really complain about it. I know this is an all-volunteer effort and I didn’t have time to look at it myself.

                                                                                                                                                      1. 4

                                                                                                                                                        sorry if the question is naïve,

                                                                                                                                                        but does Neovim or any other lsp-enabled modern vi-inspired editor provide Emacs key binding ?

                                                                                                                                                        reason I am asking is because I am not a ‘elisp’ user and do not extend or configure emacs that much – but emacs key bindings is the only thing I know.

                                                                                                                                                        For my ‘quick shell tasks’ I use joe (that has the jmacs command that enables emacs keybinding) – so I was thinking that may vi-inspired editors can do the same.

                                                                                                                                                        1. 8

                                                                                                                                                          Learning vi keybindings pays off in multiples. There are so many applications (especially in terminal) that default to vi binds that you will often be pleasantly surprised how things “just work” if you try them.

                                                                                                                                                          1. 2

                                                                                                                                                            i’m not convinced that this is a good argument as to the benefit of vi binds. there are advantages to vi binds. that other things use them by default doesn’t seem up there at all.

                                                                                                                                                            you can get *some* emacs-style bindings in vim, i know because i’ve tried. but emacs or an emacs clone works better for that, and vim works better for vimmish modal editing.

                                                                                                                                                            1. 8

                                                                                                                                                              Having a ‘standard’ keybinding across multiple applications out of the box is quite useful.

                                                                                                                                                              1. 2

                                                                                                                                                                sure. but saying it pays off in multiples to learn a confusing keybinding system purely for that reason seems like a cyclic argument.

                                                                                                                                                                the original commenter wants to make neovim work like emacs. i agree that they are better off learning the vi binds if they want to use a vi-family editor. i think that there are much better justifications for doing that then “other tui applications are likely to support them”.

                                                                                                                                                                1. 1

                                                                                                                                                                  I live in the terminal and I’m struggling to think of many examples of other apps that use vi bindings. Meanwhile I also use neovim nearly all the time and I, like most regular vim users, change the (historic but awkward) default bindings. And I use Emacs-style shortcuts in the line editor.

                                                                                                                                                                  1. 3

                                                                                                                                                                    like most regular vim users

                                                                                                                                                                    Wait really? Aye you saying most vim users don’t use hjkl to navigate? Or are you referring to something else?

                                                                                                                                                                    1. 5

                                                                                                                                                                      To be honest, I suspect there’s a surprising amount of Vim users that use arrow keys. I’m one, and it’s not like I’m hunt-and-peck, only use arrow keys. I use them in addition to motions, because I could never develop the muscle memory for hjkl. It just doesn’t feel right to me, and the last thing I want to do is get used to it and start spraying hjkl into every non-vi editor I see.

                                                                                                                                                                      1. 3

                                                                                                                                                                        I did develop the muscle memory at one point, and regretted it. I think hjkl is the most obsolete part of vim, they’re some good keys being taken up with commands that don’t need to be used that often, if you’re using vim effectively.

                                                                                                                                                                        1. 2

                                                                                                                                                                          As someone using a 60% keyboard without cursor keys I have found rebinding the default cursor mappings to hjkl to work rather well since these keys are much more convenient to reach than where cursor keys usually are. So maybe one doesn’t need hjkl in vim but the mapping is surprisingly useful outside of it.

                                                                                                                                                                          (I also accidentally discovered these vim bindings in Evince by forgetting to use modifier keys and just spamming j/k into the PDF reader)

                                                                                                                                                                          1. 1

                                                                                                                                                                            You should be able to rebind them to your preference, though I don’t know if external scripts would break.

                                                                                                                                                                            I always disliked moving my hand to the cursors, and now that I’ve been on a Kinesis Advantage since forever - whose cursors are crazy awkward - I would hate to have to use them.

                                                                                                                                                                            Also someone said he /she uses hjkl on Dvorak!

                                                                                                                                                                            Definitely YMMV based on the keyboard and its layout as well. FWIW I do kinda suck at using anything without a Vi mode anyway, beyond just the navigation.

                                                                                                                                                                            1. 2

                                                                                                                                                                              I do you use hjkl on Dvorak. Not as much in Neovim, because I don’t need these motions, but in firefox (Vimium C), in evince, in tmux (remapped). It works just fine. Of course they are not next to each other (except awkwardly placed jk), but I don’t think about it and it works fine anyway.

                                                                                                                                                                        2. 1

                                                                                                                                                                          I don’t know whether most regular vim users use hjkl in particular (I don’t. It could be interesting to survey vim users on questions like this!), but I was talking more generally. I think it’s very common to either remap Esc or bind something else to leave Insert mode, since reaching for Esc is widely thought to be awkward. I’ve also seen many example vimrcs that map ; (or something else) to : to avoid having to shift for it. I think it’s common to remap the leader too.

                                                                                                                                                                          1. 2

                                                                                                                                                                            Yeah I remap Esc to caps lock.

                                                                                                                                                                            But I do use hjkl to navigate (in lieu of arrow keys anyway, when I’m not using other types of motions). That’s the part that I was surprised by. Not in a bad way or anything. Just one of those things where I thought basically every Vim user used hjkl. But I guess it’s just anecdotal.

                                                                                                                                                                            1. 1

                                                                                                                                                                              I also use hjkl to navigate, and I would remap Esc if I didn’t remap my keyboard to making pressing Esc easier.

                                                                                                                                                                        3. 2

                                                                                                                                                                          quite a few programs have vi binds - cmus, ranger, either mutt or newsboat, but i don’t think both. i’m not a vim user anymore so i couldn’t comment on how modern regular vim users work, but i do see little benefit to not changing any of the keybindings.

                                                                                                                                                                          theres often the “what if im on a server without my dots?” argument, i guess.

                                                                                                                                                                2. 6

                                                                                                                                                                  Kinda sorta not really. Neovim (and Vim) are built from the ground up in the vi-style modal paradigm, and they aren’t a fully configurable environment like Emacs where you could swap out the whole concept of modes for something else (aka, Emacs-style modes/bindings). The closest you can get is rebinding keymaps in insert mode to be closer to Emacs, like Tim Pope’s readline plugin does.

                                                                                                                                                                  1. 1

                                                                                                                                                                    Thank you. I will look into this.

                                                                                                                                                                    I prefer to code without touching a mouse. As my shoulder and neck hurt (I switch hands for the mouse, periodically as I am used to operate it ambidextrously, but it still hurts after a month – when I do 7-8K lines per month, or lots of debugging).

                                                                                                                                                                    Which is why I prefer Emacs. Big problems with Emacs however for me are as follows:

                                                                                                                                                                    a) JS type validation using FB Flow across all of my mono repo subprojects - does not work

                                                                                                                                                                    b) Gradle based projects (Android apps and my Java backends) – do not work

                                                                                                                                                                    c) Java refactoring capabilities are not in the same league to Android Studio / IntelliJ

                                                                                                                                                                    So I thought VI-based ecosystem might be more developed in those areas. At the moment I just use Emacs key bindings in VS Code (for JS/Flow) and intelliJ (Java/Android) – but i seem to be grabbing mouse there too often.

                                                                                                                                                                    When I work my Ansible side of things (Yaml configs) – I use emacs almost exclusively and in a Terminal window (even though I can run a GUI session, I prefer just a terminal or a login console).

                                                                                                                                                                    1. 1

                                                                                                                                                                      What a great name for that plugin! https://en.wikipedia.org/wiki/Repetitive_strain_injury

                                                                                                                                                                      1. 1

                                                                                                                                                                        I love vim-rsi! @lollipopman also made a similar thing for bash, in case you share terminals with people (pairing, debugging, etc). and can’t stand emacs mode and they can’t stand vim mode: https://github.com/lollipopman/bash-rsi

                                                                                                                                                                      2. 2

                                                                                                                                                                        Not that I know of, but Emacs has LSP plug-ins so if LSP is what you’re after and you’re comfortable using Emacs I see no reason to switch.

                                                                                                                                                                      1. 38

                                                                                                                                                                        “The Gang Builds a Mainframe”

                                                                                                                                                                        1. 28

                                                                                                                                                                          Ha ha! I don’t think the mainframe is really a good analogue for what we’re doing (commodity silicon, all open source SW and open source FW, etc.) – but that nonetheless is really very funny.

                                                                                                                                                                          1. 7

                                                                                                                                                                            It makes you wonder what makes a mainframe a mainframe. Is it architecture? Reliability? Single-image scale-up?

                                                                                                                                                                            1. 26

                                                                                                                                                                              I had always assumed it was the extreme litigiousness of the manufacturer!

                                                                                                                                                                              1. 3

                                                                                                                                                                                Channel-based IO with highly programmable controllers and an inability to understand that some lines have more than 80 characters.

                                                                                                                                                                                1. 1

                                                                                                                                                                                  I think the overwhelming focus of modern z/OS on “everyone just has a recursive hierarchy of VMs” would also be a really central concept, as would the ability to cleanly enforce/support that in hardware. (I know you can technically do that on modern ARM and amd64 CPUs, but the virtualization architecture isn’t quite set up the same way, IMVHO.)

                                                                                                                                                                                  1. 2

                                                                                                                                                                                    I remember reading a story from back in the days when “Virtual Machine” specifically meant IBM VM. They wanted to see how deeply they could nest things, and so the system operator recursively IPL’d more and more machines and watched as the command prompt changed as it got deeper (the character used for the command prompt would indicate how deeply nested you were).

                                                                                                                                                                                    Then as they shut down the nested VMs, they accidentally shut down one machine too many…

                                                                                                                                                                                    1. 2

                                                                                                                                                                                      Then as they shut down the nested VMs, they accidentally shut down one machine too many…

                                                                                                                                                                                      This sounds like the plot of a sci-fi short story.

                                                                                                                                                                                      1. 3

                                                                                                                                                                                        …and overhead, without any fuss, the stars were going out.

                                                                                                                                                                                2. 1

                                                                                                                                                                                  I’d go with reliability + scale-up. I’ve heard there’s support for like, fully redundant CPUs and RAM. That is very unique compared to our commodity/cloud world.

                                                                                                                                                                                  1. 1

                                                                                                                                                                                    If you’re interested in that sort of thing, you might like to read up on HP’s (née Tandem’s) NonStop line. Basically at least two of everything.

                                                                                                                                                                                  2. 1

                                                                                                                                                                                    Architecture. I’ve never actually touched a mainframe computer, so grain of salt here, but I once heard the difference described this way:

                                                                                                                                                                                    Nearly all modern computers from the $5 Raspberry Pi Zero on up to the beefiest x86 and ARM enterprise-grade servers you can buy today are classified as microcomputers. A microcomputer is built around one or more CPUs manufactured as an integrated circuit. This CPU has a static bus that connects the CPU to all other components.

                                                                                                                                                                                    A mainframe, however, is built around the bus. This allows not only for the hardware itself to be somewhat configurable per-job (pick your number of CPUs, amount of RAM, etc), but mainframes were built to handle batch data processing jobs and have always handily beat mini- and microcomputers in terms of raw I/O speed and storage capability. A whole lot of the things we take for granted today were born on the mainframe: virtualization, timesharing, fully redundant hardware, and so on. The bus-oriented design also means they have always scaled well.

                                                                                                                                                                              1. 20

                                                                                                                                                                                There is at least one reason for Clojure users to choose for their libraries to be distributed with the same terms as Clojure’s core and standard libraries: it removes one of the many barriers towards canonicalizing popular libraries in a language’s standard library. In e.g. the Python ecosystem, the PSFL serves a similar purpose.

                                                                                                                                                                                That said, I’m not sure I understand at least one of the implicit themes in your post: Why are copyleft licenses “restrictive” or “inflexible”? In the past few discussions that we’ve had here, it seems that these imagined restrictions would generally not impede individual people from expressing themselves with Clojure. Indeed, if more of the Clojure ecosystem were copylefted, wouldn’t e.g. Datomic be pressured to become Free Software too, increasing the expressive landscape?

                                                                                                                                                                                To very gently apply some deconstruction of our own, it appears that this blog post asking a community to use permissive non-copyleft licenses is part of a corporation’s Web presence. Similarly, the “Choose a License” page is owned and operated by GitHub, a subsidiary of Microsoft, one of the “software behemoths like Amazon and Apple” mentioned in this post. When you say, “benefits to copyleft which outweigh the costs,” what exactly are the costs?

                                                                                                                                                                                1. 10

                                                                                                                                                                                  The cost (and inflexibility) is that of a one-way street, as indicated by the doodles. :) I see a lot of new developers blindly choosing the EPL without even familiarizing themselves with the terms of the license. That’s a really difficult decision to reverse.

                                                                                                                                                                                  This post isn’t advocating for MIT over copyleft licenses generally. It’s only a discussion about Sensible Defaults. I license quite a lot of my source AGPL-3, where copyleft licenses are appropriate. But I also ensure I get external contributors to sign Contributor Agreements because, in all likelihood, the AGPL-3 won’t be sufficient indefinitely. In 20 years, those projects may require a stricter copyleft license (or a permissive license, but I doubt it).

                                                                                                                                                                                  1. 13

                                                                                                                                                                                    To very gently apply some deconstruction of our own, it appears that this blog post asking a community to use permissive non-copyleft licenses is part of a corporation’s Web presence. Similarly, the “Choose a License” page is owned and operated by GitHub, a subsidiary of Microsoft, one of the “software behemoths like Amazon and Apple” mentioned in this post. When you say, “benefits to copyleft which outweigh the costs,” what exactly are the costs?

                                                                                                                                                                                    Thank you for saying this. I’ve grown weary defending copyleft in recent years. It feels like such a losing battle. There’s so much pro-liberal license propaganda. They’ll convince us that it’s “more free” or whatever, but the truth is that it’s mostly about “more free… labor for us”.

                                                                                                                                                                                    1. 6

                                                                                                                                                                                      The thing is that the concept of “free” isn’t a one-dimensional axis that you can just stick a number on from 0 (not free at all) to 100 (maximum freedom), it’s a complex matrix where moving the slider in one aspect also moves some other sliders up or down.

                                                                                                                                                                                      When people say that “MIT is more free” then they’re right: there are fewer conditions than the GPL. When people say that “GPL protects freedom better” then they’re right too. It’s just a matter of different values and priorities. I wish people could just accept that not everyone has the same priorities and values instead of reaching to the dismissive “propaganda” cudgel.

                                                                                                                                                                                      This is true for a lot of discussions actually, not just license ones (including many political ones). People tend to frame “free” or “better” according to their own preferences and priorities, and sometimes forget that not everyone shares these and then they’re left bewildered how anyone could prefer something else and come to the conclusion that it can’t be anything other than “propaganda”, “stupidity”, etc. But if you spend some understanding people’s worldview then often (though not always) it starts making a lot more sense.

                                                                                                                                                                                      For my own part, I use both permissive and copyleft licenses, depending on what’s the best fit for the project.

                                                                                                                                                                                      1. 8

                                                                                                                                                                                        Then you’re in good company, because I’ve grown weary of arguing the opposite position. In part because it seems like it’s impossible for someone to hold a position against the GPL that isn’t just “propaganda.” Apparently the notion that reasonable people can disagree is no longer relevant.

                                                                                                                                                                                        1. 8

                                                                                                                                                                                          But most of the arguments I hear against strong copyleft licenses like GPL are ‘You’ll prevent people from using it’, where ‘people’ are usually unspecified but presumably corporations whose lawyers blanket ban anything under the *GPL licenses. The undertone is ‘Don’t you want the project to succeed?’, where ‘succeed’ is also presumed to be measured as ‘used by corporations’.

                                                                                                                                                                                          1. 5

                                                                                                                                                                                            But most of the arguments I hear against strong copyleft licenses like GPL are ‘You’ll prevent people from using it’, where ‘people’ are usually unspecified but presumably corporations whose lawyers blanket ban anything under the *GPL licenses

                                                                                                                                                                                            That’s not the only problem. The more constraints in your license, the less compatibility it has. XPDF was GPLv2, so libpoppler (which was based on the codebase) couldn’t be used in Apache or GPLv3-licensed projects at all (and people didn’t want to use it in permissively licensed projects). This held back PDF support in the entire open source ecosystem for a long time.

                                                                                                                                                                                            Most corporations don’t have any problem using GPL’d code, it’s only distributing GPL’d code that they object to. The GPL didn’t stop Google from running a massively modified version of Linux on millions of servers without contributing their changes back, GPLv3 did prevent Apple from contributing changes back to GCC and is the reason that GCC’s Objective-C support is now largely useless.

                                                                                                                                                                                            The undertone is ‘Don’t you want the project to succeed?’, where ‘succeed’ is also presumed to be measured as ‘used by corporations’.

                                                                                                                                                                                            I want people to contribute to things that I use. That’s how I measure success from open sourcing: do I get a better program / library for my uses than I would have if I hadn’t released it?

                                                                                                                                                                                            1. 4

                                                                                                                                                                                              This held back PDF support in the entire open source ecosystem for a long time.

                                                                                                                                                                                              Correction, it held back PDF support in the permissive license ecosystem.

                                                                                                                                                                                              Most corporations don’t have any problem using GPL’d code,

                                                                                                                                                                                              Not in my experience. Lawyers typically clamp down pretty hard on anything GPL that’s not Linux. E.g. pm2 (the JavaScript service runner).

                                                                                                                                                                                            2. 4

                                                                                                                                                                                              Thankfully, I don’t need to repeat myself endlessly: https://github.com/BurntSushi/notes/blob/master/2020-10-29_licensing-and-copyleft.md

                                                                                                                                                                                              How about we just stop saying that opponents to copyleft are nothing more than transparent corporate shills or idiots who can’t seem to see through propaganda? That’s the point. And the reason why I said this was specifically in response to a supporter of copyleft saying that they are weary of advocacy. Well, yeah, join the club. Maybe if more people see that we have abdicated the notion that reasonable people can disagree, then maybe, just maybe, we might all stop assuming bad faith everywhere.

                                                                                                                                                                                              1. 4

                                                                                                                                                                                                Thank you for sharing this post. It is a well-written summary of a common position, and I will do my best to respect it rather than insulting it.

                                                                                                                                                                                                I worry that you’re not seeing the pragmatic effects of incremental improvements and reforms. The position you’ve detailed is similar to many positions held around the time that the phrase “Free Software” started to become philosophically meaningful; think of copyleft as a pre-existing response to your position, not just part of your own current-day context.

                                                                                                                                                                                                Let us imagine four states, which I’ll call Disneystan, Crementalia, Pirate’s Coast, and Imagineland. Each state has a copyright regime comparable to those in the USA, EU, etc. composed of corporations which exploit a shared creative commons. In each state, cultural forces cause activists to explore different routes to progress:

                                                                                                                                                                                                • In Disneystan, activists appeal to the largest corporations to be better citizens. The corporations reply by contributing small amounts to token charity efforts.
                                                                                                                                                                                                • In Crementalia, activists use copyleft techniques to secure part of the shared creative commons against exploitation. The corporations reply by contributing small amounts to token projects in the commons.
                                                                                                                                                                                                • In Pirate’s Coast, activists set up decentralized repositories to host the commons, and republish corporate content without permission. The corporations reply by suing and jailing activists.
                                                                                                                                                                                                • In Imagineland, activists somehow establish democratic control of copyright law, and enact dramatic reform (14yr terms, end working-for-hire, etc.) Corporations reply by hiring private armies and blackballing anybody who publishes proprietary information.

                                                                                                                                                                                                Then, the question is whether or not you’d like to enjoy a pragmatic effect of a robust shared creative commons – of software, in our case – which is secured against corporate attempts to exploit it. Particularly, if you were a contributor to such a commons, you’d like to consider whether you are secured against exploitation!

                                                                                                                                                                                                Finally, since the goal of maximizing the usage of a chunk of your code is utilitarian, we can find the problems with utilitarianism within your position. For example, the repugnant conclusion to your position is that your goal shouldn’t be to write bold new high-level end-user applications which push the concept of human-computer interaction, but to replace as many low-level loops in the operating system as possible, so that the maximum number of people are technically running code which you contributed.

                                                                                                                                                                                                Similarly, the freedom monsters for your position are those who live forever, always make advantageous trades, acquire rights to software you depend upon, and eventually have control over what kinds of software you produce because they have control over the software which empowers you. Who could that be?

                                                                                                                                                                                                1. 2

                                                                                                                                                                                                  I thank you for not explicitly calling me dumb I guess, but I kind of think you did, just with a flare of sophistication. But I’m fine moving past it. It might just be your style.

                                                                                                                                                                                                  In any case, I think the point you’re missing here is that I’m ideologically opposed to the ownership of ideas. We can dive down that rabbit hole, but I think it will take us to familiar places and neither will benefit much from it. (I can’t remember precisely what your socio-political views are, but I think we are on very opposite ends of that spectrum.) And crucially, there is a point that just because I find something unethical, that doesn’t mean I want to enact laws to forbid it. This is particularly relevant to when you said

                                                                                                                                                                                                  Then, the question is whether or not you’d like to enjoy a pragmatic effect of a robust shared creative commons – of software, in our case – which is secured against corporate attempts to exploit it.

                                                                                                                                                                                                  This is really written in such a way as to be impossible to disagree with. It’s like saying, “Well, don’t you want good stuff to happen and bad stuff to not happen?” Totally! Yes! Sign me up!

                                                                                                                                                                                                  The devil is in the details. How is it “secured”? What are the means through which you accomplish the banning of bad things and the proliferation of good things? And what does exploit mean? I’ve heard some people say that people who release software under permissive licenses are being exploited by corporations. Certainly, corporations use my code without giving anything back to me or even to the commons necessarily. Am I being exploited by that? Are others? I don’t feel exploited. Can I be exploited if I say, with full knowledge and study of the situation, that I am not? What does it mean for someone else to tell me I’m being exploited? Do I even have the agency to disagree with it?

                                                                                                                                                                                                  The position you’ve detailed is similar to many positions held around the time that the phrase “Free Software” started to become philosophically meaningful; think of copyleft as a pre-existing response to your position, not just part of your own current-day context.

                                                                                                                                                                                                  Yes, I think this is what I was getting at when I said that my views opposing copyright actually tend to align with principled copyleft supporters. I tried to address that in my blog post, but it seems like you’re just kind of repeating that notion to me here? Either way, changing my perspective on copyleft to a pre-existing response and not just a part of my own current-day context doesn’t reveal any new insights for me personally. But maybe I’m missing something.

                                                                                                                                                                                                  Finally, since the goal of maximizing the usage of a chunk of your code is utilitarian, we can find the problems with utilitarianism within your position.

                                                                                                                                                                                                  I did not say maximizing the usage of a chunk of my code was ethical though. And if you so insisted, it seems like a pretty easy thing to rebuttal: my language was just imprecise. A charitable interpretation of what I said is that of the code I write, I would like as many people to use it as possible. There is certainly some feedback loop here, e.g., sometimes I pick projects based on what I perceive is a need for them. But I don’t pick projects based exclusively on how widely they will be used. Like, there are other things to consider here, such as… not doing malicious things in my code?

                                                                                                                                                                                                  To be honest, your characterization of my position seems kind of ridiculous. And in particular, here is what I said, emphasis added:

                                                                                                                                                                                                  Namely, when I publish source code, one of my main goals is for as many people as possible to use it, regardless of whether it’s other individuals or giant corporations.

                                                                                                                                                                                                  While I didn’t go into all of the details, I did explicitly call out that the goal I listed is not necessarily my only goal. And thus, you cannot really conclude rigorously that I suffer from a repugnant conclusion.

                                                                                                                                                                                                  Similarly, the freedom monsters for your position are those who live forever, always make advantageous trades, acquire rights to software you depend upon, and eventually have control over what kinds of software you produce because they have control over the software which empowers you. Who could that be?

                                                                                                                                                                                                  You can’t acquire rights to software without a regime of intellectual property, to which I am opposed, because there would be no rights to software.

                                                                                                                                                                                                2. 1

                                                                                                                                                                                                  I read your note on licensing. Long story short, I understand your goals but don’t share them. I said what I said in good faith, based on my actual experiences, not to imply that people who disagree are shills or propagandists. And people are weary of permissive license advocacy because that’s the world we live on, with a cyclical story of people rushing to use MIT or Apache or whatever and then getting their lunch eaten by AWS (among other ill effects). Advocacy in the reverse direction is by far a tiny fraction of that.

                                                                                                                                                                                                  1. 1

                                                                                                                                                                                                    I see a lot more advocacy of copyleft than I do permissive licenses.

                                                                                                                                                                                                    I suppose it’s not surprising that we notice the type of advocacy that we disagree with more than the advocacy we agree with.

                                                                                                                                                                                                    Long story short, I understand your goals but don’t share them. I said what I said in good faith, based on my actual experiences, not to imply that people who disagree are shills or propagandists.

                                                                                                                                                                                                    But I wasn’t just responding to what you said specifically. I was responding to this comment, and your reply to me suggested you disagreed with me and agreed with that comment I was replying to. And then you kind of went on to say, paraphrasing, “permissive license arguments are just pro-corporation arguments in disguise.” By characterizing people you disagree with this way, you remove the opportunity for reasonable people to disagree between copyleft and copyfree. Like, why not say, “I think there is a lot of propaganda out there about permissive licenses, but there are also plenty of legitimate arguments in its favor as well.”

                                                                                                                                                                                                    1. 1

                                                                                                                                                                                                      And then you kind of went on to say, paraphrasing, “permissive license arguments are just pro-corporation arguments in disguise.”

                                                                                                                                                                                                      Well, they kind of are, aren’t they? What’s the big difference between the permissive copyleft and the strict copyleft licenses in terms of who can easily use the software? When you say ‘I want as many people to use my software as possible’, who couldn’t use it if it was GPLd?

                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                        People who oppose copyleft. For example, I don’t use any copyleft Rust libraries in any of my projects. I’m not a corporation and I have ideological opposition to copyleft.

                                                                                                                                                                                                        Moreover, corporations aren’t the root cause. They are just a convenient scapegoat. The root cause is IP itself and the incentive structure in promotes.

                                                                                                                                                                                                        1. 1

                                                                                                                                                                                                          People who oppose copyleft

                                                                                                                                                                                                          That applies to both permissive copyleft and restrictive copyleft licenses, so it’s not really an answer to my question.

                                                                                                                                                                                                          The root cause is IP itself and the incentive structure in promotes.

                                                                                                                                                                                                          I’m not convinced ‘no IP’ is the solution, where people who have the power just release obfuscated software and wash their hands saying, ‘Well, you’re free to reverse engineer it’. That effectively locks out more than 99% of people from accessing the code.

                                                                                                                                                                                                          1. 0

                                                                                                                                                                                                            That applies to both permissive copyleft and restrictive copyleft licenses, so it’s not really an answer to my question.

                                                                                                                                                                                                            When did this conversation change to distinguishing between “permissive” and “restrictive” copyleft? I’m talking about copyleft in general.

                                                                                                                                                                                                            I’m not convinced ‘no IP’ is the solution, where people who have the power just release obfuscated software and wash their hands saying, ‘Well, you’re free to reverse engineer it’. That effectively locks out more than 99% of people from accessing the code.

                                                                                                                                                                                                            I addressed this in my link. We’re just re-treading ground now. I acknowledge this possibility. “No IP” isn’t a panacea that solves every problem. This is orthogonal from identifying IP as the root cause for why corporations oppose copyleft.

                                                                                                                                                                                                            1. 1

                                                                                                                                                                                                              When did this conversation change to distinguishing between “permissive” and “restrictive” copyleft?

                                                                                                                                                                                                              It never stopped being about that difference. The OP is about that, and my question is about that:

                                                                                                                                                                                                              And then you kind of went on to say, paraphrasing, “permissive license arguments are just pro-corporation arguments in disguise.”

                                                                                                                                                                                                              Well, they kind of are, aren’t they? What’s the big difference between the permissive copyleft and the strict copyleft licenses in terms of who can easily use the software? When you say ‘I want as many people to use my software as possible’, who couldn’t use it if it was GPLd?

                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                This is where I entered the conversation, and it’s where you responded to me. Emphasis mine:

                                                                                                                                                                                                                To very gently apply some deconstruction of our own, it appears that this blog post asking a community to use permissive non-copyleft licenses is part of a corporation’s Web presence. Similarly, the “Choose a License” page is owned and operated by GitHub, a subsidiary of Microsoft, one of the “software behemoths like Amazon and Apple” mentioned in this post. When you say, “benefits to copyleft which outweigh the costs,” what exactly are the costs?

                                                                                                                                                                                                                Thank you for saying this. I’ve grown weary defending copyleft in recent years. It feels like such a losing battle. There’s so much pro-liberal license propaganda. They’ll convince us that it’s “more free” or whatever, but the truth is that it’s mostly about “more free… labor for us”.

                                                                                                                                                                                                                This isn’t about “permissive copyleft” vs “strict copyleft” here. I don’t know how this conversation got so confused. I, and the people I was responded to, were talking about permissive vs copyleft. On top of that, the note I linked makes this context very clear: I am talking about permissive or “copyfree” licenses vs copyleft. I am not making a distinction between permissive copyleft and strict copyleft. The OP might, but that’s not what this sub-thread is about.

                                                                                                                                                                                                                I suggest we stop the conversation here. All we’re doing is having meta-discussion now. The original point has been lost. The original point is that, hey, yeah, you’re weary from defending copyleft and I’m weary from the implication that I’m a corporate shill. Maybe reasonable people can disagree. That’s it.

                                                                                                                                                                                          2. 2

                                                                                                                                                                                            Indeed, if more of the Clojure ecosystem were copylefted, wouldn’t e.g. Datomic be pressured to become Free Software too, increasing the expressive landscape?

                                                                                                                                                                                            Or decreasing it by not existing at all because its authors wouldn’t bother doing it if the ecosystem tries to force them into something?

                                                                                                                                                                                            It’s probably a moot point regarding Datomic specifically, as its authors being the authors of the language itself can do whatever the hell they want. What I’m trying to say is that one downside of copyleft licenses is that they can force creators out of communities without those communities having a slightest idea about that happening.

                                                                                                                                                                                            1. 5

                                                                                                                                                                                              Do you have specific examples in mind? The ecosystems that spring to my mind, like Linux and its device drivers, don’t seem to have a decreased palette of supported platforms compared to similar proprietary ecosystems. Contrapositively, Oracle is still in business despite an entire community of relational-database technologists who collectively shun them and exclusively use Free Software. On the gripping hand, at least one ecosystem, OpenWRT, sprang from a situation where a corporation used Free Software and was forced to contribute back to the community.

                                                                                                                                                                                            2. 1

                                                                                                                                                                                              A while ago I changed the license of some of my projects from MPL to Apache/MIT “to better fit the ecosystem” based on some “friendly pressure”.

                                                                                                                                                                                              I regret it and wouldn’t do it again; I now established that for me MPL is as far as I’m willing to go to the “right” in terms of licenses, and those who don’t like that can write their own code.

                                                                                                                                                                                              1. 2

                                                                                                                                                                                                I regret it and wouldn’t do it again

                                                                                                                                                                                                Can you share what made you regret it?

                                                                                                                                                                                                1. 2

                                                                                                                                                                                                  Giving other people’s entitlement more weight than my own preferences.

                                                                                                                                                                                                  (I use GitHub’s “temporary interaction limits” to reduce the interaction with that community for various reasons now.)

                                                                                                                                                                                                2. 2

                                                                                                                                                                                                  Could you elaborate on what in MPL specifically works better for you? (I’m not terribly familiar with MPL, sorry.)

                                                                                                                                                                                                  1. 5

                                                                                                                                                                                                    MPL code can be used by code under pretty much any other license; you only need to provide the source for files under the MPL (including changes you made to these files), which I think is reasonable and incredibly fair.

                                                                                                                                                                                                    1. 1

                                                                                                                                                                                                      And if they modify the MPL’d code? Do they have to also provide the modification back?

                                                                                                                                                                                                3. 0

                                                                                                                                                                                                  it removes one of the many barriers towards canonicalizing popular libraries in a language’s standard library.

                                                                                                                                                                                                  While this is a somewhat reasonable point, in practice this hasn’t happened. Au contraire, Clojure is known for instead of using external libraries and contributions just reinventing the wheel. One of such examples is Schema vs Spec or in smaller scale e.g. the tuple proposal.

                                                                                                                                                                                                  I think when merging in a popular FOSS library, relicensing is part of the effort but probably not all that daunting of a task. With the rise of decent package managers having things in the standard library is also of less importance, given Node’s minimal standard library and the bad example of Python’s massive dead stdlib which is full of duplicates which can’t be removed nor fixed for compatibility reasons.

                                                                                                                                                                                                1. 1

                                                                                                                                                                                                  Link is 404 :(

                                                                                                                                                                                                  1. 2

                                                                                                                                                                                                    t is missing at the end of the URL

                                                                                                                                                                                                    1. 2

                                                                                                                                                                                                      I raise you an l.

                                                                                                                                                                                                  1. 6

                                                                                                                                                                                                    Apparently it is easy to end up championing the gentle treatment of a sexual minority while thinking it is funny to be gratuitously offensive to other minorities.

                                                                                                                                                                                                    Who is this other minority? The minority in the Christian majority that get offended by swearing with religious connotations? The OP?

                                                                                                                                                                                                    Even then, I find comparing what mjg59 says with rms a bit difficult - one of them is a public leader, the other is, while a rather prominent person in the FOSS community, not the leader of any political organization.

                                                                                                                                                                                                    1. 20

                                                                                                                                                                                                      Here’s what I’m doing to adjust to the new era of dystopian surveillance capitalism:

                                                                                                                                                                                                      • Replaced my old MacBook Air with a Thinkpad T14 running Linux (currently Fedora, which has less spyware and advertising than Ubuntu)
                                                                                                                                                                                                      • Firefox + UBlock Origin is my primary web browser. Configured so it mostly doesn’t “phone home” to Mozilla.
                                                                                                                                                                                                      • Ungoogled Chromium (from the flatpak store at flatpak.org) is my backup browser, for web sites where Firefox has issues. Guaranteed never to phone home to Google.
                                                                                                                                                                                                      1. 6

                                                                                                                                                                                                        I’m interested in why you installed “ungoogled chromium” from the flatpack store?

                                                                                                                                                                                                        I personally install it from RPM fusion. (Which you might wanna install if you want to watch any video/listen to any music on fedora)

                                                                                                                                                                                                        $ sudo dnf info chromium-browser-privacy
                                                                                                                                                                                                        Installed Packages
                                                                                                                                                                                                        Name         : chromium-browser-privacy
                                                                                                                                                                                                        Version      : 88.0.4324.150
                                                                                                                                                                                                        […]
                                                                                                                                                                                                        Source       : chromium-browser-privacy-88.0.4324.150-1.fc33.src.rpm
                                                                                                                                                                                                        Repository   : @System
                                                                                                                                                                                                        From repo    : rpmfusion-free-updates
                                                                                                                                                                                                        Summary      : Chromium, sans integration with Google
                                                                                                                                                                                                        URL          : https://github.com/Eloston/ungoogled-chromium
                                                                                                                                                                                                        License      : BSD and LGPLv2+ and ASL 2.0 and IJG and MIT and GPLv2+ and ISC
                                                                                                                                                                                                                     : and OpenSSL and (MPLv1.1 or GPLv2 or LGPLv2)
                                                                                                                                                                                                        Description  : chromium-browser-privacy is a distribution of ungoogled-chromium.
                                                                                                                                                                                                        […]
                                                                                                                                                                                                        
                                                                                                                                                                                                        1. 3

                                                                                                                                                                                                          No good reason, I think it was recommended as an installation method by the blog post where i read about the browser. Thanks for the information. I am still getting used to Fedora.

                                                                                                                                                                                                          1. 2

                                                                                                                                                                                                            What kind of sandboxing does the flatpak-ed package get you? It’s a useful point to remember – a while back (I’m not on Linux anymore so I don’t have a more recent data point) a lot of applications from flathub were packaged without much sandboxing at all, e.g. they still had full access to the user’s home folder.

                                                                                                                                                                                                            1. 2

                                                                                                                                                                                                              Fedora has an “app store” GUI called Software. It is far more user friendly than using the “dnf” command in bash, at least if you are coming from MacOS. On my laptop, since I installed it, UnGoogled Chromium shows up as an installed application in Software, together with a lot of useful information, including an indication that it is sandboxed, with the following permissions: Network, Devices, Home Folder, Legacy Display System.

                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                Oh, thanks! I couldn’t find an explanation of what the “friendly” names mean but assuming the most obvious mapping to Flatpak permissions (here) I think it would go something like this:

                                                                                                                                                                                                                • Home Folder means it has unrestricted access to the home folder (which is slightly better than --filesystem=host but, as XKCD famously put it, not that good…)
                                                                                                                                                                                                                • Devices means it has unrestricted access to things like webcams
                                                                                                                                                                                                                • I’ve no idea what Legacy Display System maps to – presumably either --socket=x11 or --socket=fallback-x11?
                                                                                                                                                                                                                • Network is obvious, I guess :-)

                                                                                                                                                                                                                This is actually a little better than I expected, I think?

                                                                                                                                                                                                              2. 1

                                                                                                                                                                                                                This page is a little clickbait-y but still somewhat true: https://flatkill.org/2020/

                                                                                                                                                                                                                Long story short, yes isolation is still an issue on flatpak

                                                                                                                                                                                                          2. 4

                                                                                                                                                                                                            Can you clarify the first point of replacing MacBook and its impact on privacy as you see it?

                                                                                                                                                                                                            1. 31

                                                                                                                                                                                                              MacOS has telemetry that cannot be disabled. You cannot modify the System folder. Apple wants to be an intermediary in everything you do, they want to see all your data. You are encouraged to store your data on the Apple cloud, which is not end-to-end encrypted, so that they can hand your data over to the government without your knowledge(*). You are encouraged to download apps from Apple’s app store, and even if you don’t, MacOS phones home about apps not installed from the store. I don’t want to use these services, but the UI has built in advertising for these unwanted services that I can’t disable.

                                                                                                                                                                                                              (*) https://www.theverge.com/2020/1/21/21075033/apple-icloud-end-to-end-encryption-scrapped-fbi-reuters-report

                                                                                                                                                                                                              Apple has been very successful at branding themselves as pro privacy. A lot of people believe their bullshit. Here’s an experiment that you can try. Go to an apple store and buy something using cash (so that Apple doesn’t know your identity). When they ask for your email address, refuse to give it to them. See how that goes for you. My experience is that they try to inflict as much pain as possible, but with negotiations, it is possible to leave the store with your merchandise and a receipt. But it is not easy. I try to use cash for everything (although I’ve made exceptions during the pandemic), and the apple store has by far the worst experience.

                                                                                                                                                                                                              We live in an age of anxiety, where there is an ever increasing number of things that you are supposed to be anxious about. The pandemic, of course, but now that we are getting vaccinated, instead of that being a reason to be less anxious, you are now supposed to be anxious about getting and protecting your vaccine passport, without which you will be denied access to services. And of course we are supposed to be anxious about surveillance capitalism. This all sucks. I want to minimize the number of things in my life that generate anxiety: deal with the problem once, then stop thinking about it. The rational thing is to get rid of all my computers and phones, and unplug from the internet. I’m not ready for that yet, so I’m replacing my gear with new gear that doesn’t surveil me. Hopefully that will allow me to stop thinking about those particular issues.

                                                                                                                                                                                                              1. 12

                                                                                                                                                                                                                Great answer, especially this parts resonates with me:

                                                                                                                                                                                                                I want to minimize the number of things in my life that generate anxiety

                                                                                                                                                                                                                1. 15

                                                                                                                                                                                                                  I recently got sent a mac by my employer for compliance reasons, and the process of setting it up was quite a trip. I felt like I spent twenty minutes answering “no” to various forms of “OK but can we collect this piece of personal information? How about if we phrase it slightly differently?” before I could even use the machine at all.

                                                                                                                                                                                                                  In the end they refused to take no for an answer re: my mobile phone number, and after an experience like that I don’t actually have much confidence that they take my consent very seriously for the other pieces of information that I did not agree to.

                                                                                                                                                                                                                  Luckily in my case the compliance concerns can be addressed by simply doing my development inside a virtualbox VM running on that machine over SSH.

                                                                                                                                                                                                                2. 8

                                                                                                                                                                                                                  You are encouraged to store your data on the Apple cloud[…] You are encouraged to download apps from Apple’s app store, […] Apple has been very successful at branding themselves as pro privacy. A lot of people believe their bullshit.

                                                                                                                                                                                                                  Also, you are encouraged to buy into the non-Mac hardware ecosystem (iPhone, Watch, etc.) with their own app store “soft” lock-in (using Things/OmniFocus on Mac? Why not buy the iPhone version!?).

                                                                                                                                                                                                                  Technically, one can use a Mac and avoid the rest of Apple’s ecosystem (by running Chrome, Thunderbird, open source apps, etc.) - but most people will eventually get sucked into Apple’s marketing vortex. I know because I did; which is why I avoid touching anything Apple with a ten foot pole.

                                                                                                                                                                                                                  1. 7

                                                                                                                                                                                                                    This is every business’ strategy. One man’s lock in is another man’s products that work together well.

                                                                                                                                                                                                                    1. 2

                                                                                                                                                                                                                      Does only sound like purchase realization when you’ve locked yourself into that ecosystem.

                                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                                        realization

                                                                                                                                                                                                                        Can’t edit anymore, but that was meant to be rationalization.

                                                                                                                                                                                                                  2. 13

                                                                                                                                                                                                                    if you don’t like the telemetry done by MacOS, that’s totally fine, but there is no need for the hyperboles, like “they try to inflict as much pain as possible”. them knowing your email address is better for their business. of course, it is worse for your privacy. but it’s just a business decision that you can dislike, not them trying to inflict you pain like some james bond villain with a lake with sharks :-)

                                                                                                                                                                                                                    also, in general, you will have to trust the company that makes your operating system. not because they are trustworthy, but because if they were evil, they could just read everything you do on your computer and you would never know. so simply pick one that you can trust the most. (and it applies to linux distros too. i don’t think anyone is reading and understanding every fedora patch).

                                                                                                                                                                                                                    1. 13

                                                                                                                                                                                                                      not them trying to inflict you pain like some james bond villain with a lake with sharks

                                                                                                                                                                                                                      It’s a figure of speech

                                                                                                                                                                                                                      you will have to trust the company that makes your operating system

                                                                                                                                                                                                                      A company doesn’t make my operating system, but even if one did it’s open source, which MacOS is not

                                                                                                                                                                                                                      1. 1

                                                                                                                                                                                                                        Shell and coca cola are exemplars of making the world a better place.

                                                                                                                                                                                                                        Mind explaining? Was this an irony?

                                                                                                                                                                                                                        1. 1

                                                                                                                                                                                                                          I think you replied to the wrong comment.

                                                                                                                                                                                                                      2. 1

                                                                                                                                                                                                                        james bond villain

                                                                                                                                                                                                                        I think this reasoning is problematic and completely ignores wolves in sheep’s clothing. How many James bond villains have ever really existed ? We agree that sharks exist but what about the following

                                                                                                                                                                                                                        1. The nigerian prince scammers don’t really say hey want your money for personal benefit, but dress up the message in the language of victimhood.
                                                                                                                                                                                                                        2. Sexual predators feign weakness, especially if they are older men before making the victim unconscious.
                                                                                                                                                                                                                        3. Pedophiles work in charities or armed forces but present themselves as pillars of community.
                                                                                                                                                                                                                        4. Religious people commit evil on completely innocent people but dress it up in the language of love, justice and purity. You don’t think of nuns who steal babies as human traffickers.
                                                                                                                                                                                                                        5. Communists preach egalitarianism but practice slavery under the guise of enemies of egalitarianism.
                                                                                                                                                                                                                        6. Pharma companies preach healing but sell addictions.
                                                                                                                                                                                                                        7. Under the guise of freedom of speech, pornographers exploit people from towns.
                                                                                                                                                                                                                        8. Shell and coca cola are exemplars of making the world a better place.

                                                                                                                                                                                                                        The list goes on and on. Almost every idea which seems innocent enough is abused by wolves in sheep’s clothing and not james bond antagonists. Maybe there is no such thing as sheep and we are all wolves. Heck even the open source contributors are abused under the guise of openness and community, while the parent company seeks funding.

                                                                                                                                                                                                                        Social media companies, including Google, claim they are making the world a better and connected place while allowing sexualisation of pre-teens and enabling predators on their platforms. They are selling private user data, allow non-state actors to influence elections, let unverified stories to run amok, abuse copyright protections and run behavioral experiments on users. How difficult is it to enable age verification ? You can always store sha(government-id) or use credit cards to verify age.

                                                                                                                                                                                                                        We merely have to ask the question are Google and Apple, wolves in sheep’s clothing ? The answer is obviously yes. Apple is a tobacco company. In what ways can they be stopped ? I don’t think limited liability is the answer.

                                                                                                                                                                                                                        1. 3

                                                                                                                                                                                                                          It’d probably be a good idea to strip out some of the more, um, controversial items from your comment to avoid a hellthread here litigating offtopic matters.

                                                                                                                                                                                                                      3. 7

                                                                                                                                                                                                                        We live in an age of anxiety, where there is an ever increasing number of things that you are supposed to be anxious about.

                                                                                                                                                                                                                        No offense, and I honestly mean that, but it feels as though you’ve got a little more anxiety going on than most of us. One valid way to deal with anxiety is to accept that some things are just facts of life in the modern world. For example, I use an ad-blocker, I don’t use Chrome, and I choose devices and services that are at least reasonably secure, but I gave up trying to control every piece of data I own because the attempt was causing me much more anxiety than just going with the (admittedly unfortunate) flow.

                                                                                                                                                                                                                        Just a thought.

                                                                                                                                                                                                                        1. 5

                                                                                                                                                                                                                          “Don’t worry, be happy” is not a serious answer to anxiety. If you decide to surrender that’s your choice, but that doesn’t mean people preferring to fight a managed retreat and prevent a total rout are wrong to do so. At a minimum they will preserve their freedom longer than you and possibly even retake ground that you have ceded.

                                                                                                                                                                                                                          https://www.history.com/news/7-brilliant-military-retreats

                                                                                                                                                                                                                    2. 2

                                                                                                                                                                                                                      How does the T14 compare to other ThinkPads you have used (eg the X1 carbon)?

                                                                                                                                                                                                                      1. 9

                                                                                                                                                                                                                        I chose the T14 AMD w. Ryzen 4750 (8 cores, decent GPU) because I’m doing open source development and 3D graphics (not gaming), and I wanted this much power. Thicker than my old MacBook, but same mass. Easy to disassemble, lots of upgradeable components. The T14s is too thin, cooling system is inadequate for the 4750 CPU (according to notebookcheck): it runs too hot and throttles. Ryzen uses more energy but performance is comparable to an Apple M1 (faster on some benchmarks, slower on others). Fan noise hasn’t bothered me.

                                                                                                                                                                                                                        According to reviews, T14 has a better keyboard than X1 carbon. X1 carbon has a better trackpad, but this trackpad can be ordered and installed in a T14 (many people on Reddit have done this). The X1 is limited to gen 10 intel + UHD graphics, too slow for my requirements. It maxes out at 16GB soldered RAM (not upgradeable), too small for my future requirements. Probably too thin to support the Ryzen 4750 with adequate cooling. The display options are better than the T14 AMD, that’s my one regret.

                                                                                                                                                                                                                        1. 3

                                                                                                                                                                                                                          I replaced my MacBook Air M1 by a T14 AMD a few months ago and like it very much as well!

                                                                                                                                                                                                                          Fan noise hasn’t bothered me.

                                                                                                                                                                                                                          Me neither. The fan is not very loud, definitely much more quiet than Intel MacBooks.

                                                                                                                                                                                                                          lots of upgradeable components

                                                                                                                                                                                                                          Love this aspect as well. I added an additional 16GB RAM (for 32GB RAM) and replaced the 512GB NVMe SSD by a 1TB NVMe SSD. There is still room for one more upgrade, since the WWAN slot can be used for some SSDs.

                                                                                                                                                                                                                          The display options are better than the T14 AMD, that’s my one regret.

                                                                                                                                                                                                                          Especially in Linux. On Windows the screen is quite acceptable with 150% scaling. Unfortunately, when enabling fractional scaling in GNOME, most X11 applications break (blurry upscaling).

                                                                                                                                                                                                                          1. 1

                                                                                                                                                                                                                            Unfortunately, when enabling fractional scaling in GNOME, most X11 applications break (blurry upscaling).

                                                                                                                                                                                                                            I remember this problem with the X1 Gen3 which couldn’t scale 2x properly, so I could chose between things looking way too tiny or things looking way too large (and very little screen real estate). The 4K screen in the T14s is much better in that regard.

                                                                                                                                                                                                                            But really the problem is that GTK+ 3 (at least) doesn’t support fractional scaling so things are just a complete mess.

                                                                                                                                                                                                                            1. 1

                                                                                                                                                                                                                              But really the problem is that GTK+ 3 (at least) doesn’t support fractional scaling so things are just a complete mess.

                                                                                                                                                                                                                              For me on Wayland, GTK 3 applications work fine. AFAIK, they are rendered at a larger integer scale and then Mutter (?) downscales to whatever fractional scaling you use. This is pretty much the same approach as macOS uses.

                                                                                                                                                                                                                              It’s XWayland where it goes wrong, though I think it was with an external screen hooked up, since XWayland does not support mixed DPI.

                                                                                                                                                                                                                          2. 2

                                                                                                                                                                                                                            The AMD variation is near perfect - but there is one downside to anyone, like me, who owns a Thunderbolt device (eg: LG Ultrafine 5k; I cannot go back to non-retina monitors having used this). It has no support for TB3 even with a dock.

                                                                                                                                                                                                                            1. 3

                                                                                                                                                                                                                              It sucks if you already have a Thunderbolt display, but it does drive 5k@60Hz over USB-C with DP-Alt (according to PSRef).

                                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                                Is there a demonstration of this actually working with any particular 5k monitor (of which there aren’t many)?

                                                                                                                                                                                                                            2. 1

                                                                                                                                                                                                                              The T14s is too thin, cooling system is inadequate for the 4750 CPU

                                                                                                                                                                                                                              I own a T14s, and I can confirm the cooling system is absolutely inadequate.

                                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                                The fact that the 4K screen is only available in the T14(s) with Intel is the sole reason I got the Intel T14s (which apparently does not run crazy hot as the Intel T14). Also oddly the T14s can be ordered with 32 GB RAM unlike the X1, so you get a rather similar device with better specs and keyboard and a worse (non-replaceable) touchpad.

                                                                                                                                                                                                                          1. 4

                                                                                                                                                                                                                            This is something that has been frustrating me in Clojure ever since I started using it (pre-1.0) and every time I go back to it I see nothing has changed:

                                                                                                                                                                                                                            1. Terrible start-up time. Clojure could’ve been a choice for writing Android apps but just isn’t, because the Clojure developers haven’t cared enough in the last 10+ years to optimize it. In the beginning people said “JVM startup is slow” but these days java starts fast enough.
                                                                                                                                                                                                                            2. Terrible errors/exceptions. The stack traces are awful, extremely long and understanding them is more of a “interpreting art” thing than anything else because often the reason something falls apart is a nil value 30 stack frames below.

                                                                                                                                                                                                                            Yet none of these issues seem to be even remotely an issue woth looking at. Instead we get an idiosyncratic version of type checking called Clojure Spec and niche data structure optimizations called transducers.

                                                                                                                                                                                                                            1. 2

                                                                                                                                                                                                                              The startup time issue while quite present is a bit more muddy. Apparently startup time is linearly related to the amount of code you’re loading, including dependencies, since effectively you compile the universe on every JVM startup.

                                                                                                                                                                                                                              For development there’s not much you can do but there’s some: avoid Lein and use the Clojure cli tools. Lein launches two JVMs and adds some layers that might be unnecessary. Precompile your deps as per https://clojure.org/guides/dev_startup_time

                                                                                                                                                                                                                              For production you can generate an AOT Uberjar that at least removes the compiler from the picture. That’s your ceiling, you cannot go faster than that unless you start selecting your dependencies with startup size in mind, or going the route of dynamically loading namespaces when needed (amortizing the cost).

                                                                                                                                                                                                                              Regarding the error messages, there was some work done but it covers only some cases. In my experience, the core team actually listens to complains but is batching work so the response is slow. If you have some specific stacktrace and some idea of what it should be, I would go to ask.clojure.org and open a question.

                                                                                                                                                                                                                              1. 1

                                                                                                                                                                                                                                Nowadays, there is babashka that covers a lot of use cases where startup time is an issue. Meanwhile, I find that ClojureScript works pretty well for mobile development. Obviously there are cases where Clojure isn’t a good fit, but for many situations it does work very well.

                                                                                                                                                                                                                                Errors and exceptions have been getting a lot better in recent versions. Personally, I don’t actually know why people keep saying interpreting stack traces is hard. Vast majority of the time you just got to the end of the trace and look for the last reference to a namespace from your code. My experience is that errors tend to be very close to the line listed, and typically in the same function. There is also lots of REPL middleware, such as this one, that makes exceptions easier to read.