1.  

    I have expected the author would show a tool, such as the one of Jane Street that could integrate with GitHub, Gerrit, ReviewBoard, whatever.

    But the author doesn’t.

    In fact, skimming the article, I missed the information on how the author feeds back his insights in the code-review tool of choice.

    If he simply uses the vimdiff (with some bells and whistles), then I think many people (including myself) do that for years, but simply because those people know so well their command-line tools, that they are way more efficient using them than the code-review tool of choice.

    On the positive side, I liked the idea of creating a dependence graph of the files in the patch, so it drives the code-review process.

    1. 11

      I think it is worth to teach a high-level language, because the focus is solving problems, not on von Neumann architecture. And I think that is the reason most of the courses (I did) and books (I read) on algorithms use pseudo-code, not even programming languages.

      Thus, the small victories of solving increasingly more difficult problems tends to come easier in a high-level programming language than a low-level one.

      If we compare to other fields, such as natural languages, one also learns high-level concepts first (words, then classifying them in nouns and adjectives, then verbs, and much, much later, get into grammatical details, such as direct object), then goes to the fundamentals of the language. That even happens for languages where the fundamental structure is utterly important to proper communication, such as those with grammatical cases.

      However, there are situations in which knowing the underlying machinery (what I previously referred to as von Neumann architecture) helps to optimally resolve a problem.

      In my experience, though, they usually come up later in the learning path of programming.

      1. 10

        That seems strange that elementaryOS developers would try to deny others the same rights that were essential in allowing them to make and distribute elementaryOS in the first place!

        The right they wanted to deny others was the right to distribute CDs using the name ‘elementaryOS’, which could reflect on them as an entity. They restricted nobody’s right to do anything with the software itself.

        1. 4

          The right they wanted to deny others was the right to distribute CDs using the name ‘elementaryOS’, which could reflect on them as an entity.

          But that was already covered by GPLv2:

          If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors’ reputations.

          And on

          They restricted nobody’s right to do anything with the software itself.

          that is not what I understand by

          Both distros have rules on their various subreddits (/r/elementaryos and /r/zorinos) that users cannot post links and sometimes information on how to build your own is removed. If someone builds their own .iso or shares the information to do so, they will have their post deleted and be banned.

          To me, it seems they are limiting people’s ability to distribute of a variation of their GPL’ed product, which goes against the GPLv2 (and v3) text:

          Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients’ exercise of the rights granted herein.

          But in the end, I think the problem is more of moral origin (do not delete posts) than licensing one.

          <sarcasm> Maybe a GPLv4 will address this kind of problem. </sarcasm>

          1. 4

            This is basically the less serious version of the RHEL agreement. Redhat distributes GPL binaries if you sign a support contract with them. Even though Redhat distributes the source to all of their programs, the support contract comes with very strict conditions against redistributing those binaries, and basically voids the contract.

            Many people say that this goes against the spirit of the GPL, but I’m not one of them.

            1. 2

              Many people say that this goes against the spirit of the GPL […]

              As far as I understand the GPLv2 §3, the Red Hat’s restriction violates the GPL:

              You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above […]

              1. 4

                You are allowed to redistribute the binaries. Redhat does not prevent you from distributing the binaries. All they do is stop providing support if they find out you have done so.

        1. 4

          Thanks for posting this! Somebody asked me about termios recently and we lamented, together, that conceptual overview of it is hard to find because it’s old, even though it’s still in use.

          1. 3

            The chapter 18 of Stevens’s Advanced Programming in the UNIX® Environment is dedicated to Terminal I/O, or termios.

            That chapter, followed by chapter 19 (on pseudo terminals), should give one a complete and detailed view on how terminals work on UNIX systems.

            1. 2

              termio(7I) may be interesting to look at as well.

          1. 3

            Regular languages (type 3) > Context-free languages (type 2) > Context-sensitive languages (type 1) > Unrestricted languages (type 0)

            I have always felt that the distinction drawn between context-free and context-sensitive languages was a bit arbitrary. There is a clean separation between regular languages and context-free languages: The former corresponds to automata and the later corresponds to an automata with a stack (a push down automata). To get to context-sensitive, you need a linear bounded automaton which is fairly different from stacks. Add one more stack, and you get unrestricted languages. Similarly, regular grammar is defined usually as

            A → a
              | aB
              | ε
            B → b
              | aB
            

            where A and B are nonterminals and a and b are terminal symbols, and (single) nonterminals are only allowed at the end of the expansions. However, it can also be expressed with arbitrary LHS with any number of terminal and nonterminal symbols, where recursion is disallowed but Kleene star is allowed. This gets you the following grammar

            A → a
              | aB
              | ε
            B → b
              | (ab)*
            

            You can prove that this grammar is equivalent to a regular expression. Now, if you allow recursion to this grammar, you have context-free. Allow arbitrary symbols on the LHS and you have unrestricted. To have context-sensitive grammars, you have to add an ugly rule saying that the grammar is non-contracting. That is, ε is only allowed as an alternative expansion to the start symbol.

            That is, every regular grammar is a context-free grammar. However, not every context-free grammar is a context-sensitive grammar. Finally, the special casing of ε makes context-sensitive grammars unusable for practical purposes (I have not seen an application that would be adequately served by context-sensitive grammars but not by context-free or unrestricted grammars).

            Finally, regular tree grammars are quite interesting structures that sadly seems to be unused in most software engineering tasks. The only difference from context-free grammars is that the RHS is represented as a tree. They have the power of context-free languages, while allowing interesting properties of regular languages such as intersection and complement. Subset and equivalence of regular tree grammars is also decidable unlike context-free grammars.

            1. 4

              However, not every context-free grammar is a context-sensitive grammar.

              I don’t think that is true (see Chomsky’s hierarchy), and I think you can show that by the pumping lemma.

              Can you provide an example of a context-free language (or grammar) which is not a strict subset of the context-sensitive language (or grammar)?

              I think it is possible to see by the class of recognisers (nondeterministic pushdown automata, for context-free languages, versus linear-bounded nondeterministic Turing machine, for context sensitive languages) that context-free languages (and grammars) are a strict subset of context-sensitive languages (or grammars).

              Finally, the special casing of ε makes context-sensitive grammars unusable for practical purposes (I have not seen an application that would be adequately served by context-sensitive grammars but not by context-free or unrestricted grammars).

              It seems that your perspective is reversed: I don’t think one wants to model a problem as context-sensitive to solve it, but there are a lot of daily problems (such as interpretation of nearly all natural languages) that is in that class, and we have to find a way to solve it. (Usually, one simplifies the problem. But that is not enough, and automatic translation is a good example of that.)

              1. 2

                The difference is not in the languages but in the grammar definition; by definition, a context-sensitive grammar has to be monotonic (non contracting). So, the following grammar is not context-sensitive because of ε in the definition of B even though the language it represents is a context-free language (it is finite) and hence a context-sensitive language. Note: I am not saying that the language represented by this grammar can’t be represented by a context sensitive grammar, but that this grammar is not context-sensitive.

                A → a
                  | aB
                  | ε
                B → b
                  | ε
                

                It seems that your perspective is reversed

                I am not an expert on natural language interpretation. However, see the wikipedia entry you linked. As it says, CSGs are far more powerful than what is required for natural languages, and I am not clear what we gain by modeling them as CSGs. Why not interpret them as context-free grammars with extra semantics as we do with programming languages? That is, what property of context-sensitive languages that is not available in unrestricted languages are you using?

                1. 1

                  by definition, a context-sensitive grammar has to be monotonic (non contracting).

                  That is the flaw: every context-sensitive language can be generated by a noncontracting grammar or a context-sensitive grammar, but they are not the same thing.

                  From the Wikipedia’s page:

                  A formal language that can be described by a context-sensitive grammar, or, equivalently, by a noncontracting grammar or a linear bounded automaton, is called a context-sensitive language. Some textbooks actually define CSGs as non-contracting, although this is not how Noam Chomsky defined them in 1959. This choice of definition makes no difference in terms of the languages generated (i.e. the two definitions are weakly equivalent), but it does make a difference in terms of what grammars are structurally considered context-sensitive; the latter issue was analyzed by Chomsky in 1963.

                  […]

                  Kuroda normal form

                  Every context-sensitive grammar which does not generate the empty string can be transformed into a weakly equivalent one in Kuroda normal form. “Weakly equivalent” here means that the two grammars generate the same language. The normal form will not in general be context-sensitive, but will be a noncontracting grammar.

                  The Kuroda normal form is an actual normal form for non-contracting grammars.

                  So it seems that

                  context-free grammar ⊂ context-sensitive grammar
                  ∧ noncontracting grammar ⊂ context-sensitive grammar
                  ∧ context-free grammar \ (context-free grammar ∩ noncontracting gramma)r ≠ ∅
                  

                  And, thus, the grammar you show is context-sensitive, and that can be seen by the formal definition of a context-sensitive grammar, in which ɣ can be ɛ.

                  As it says, CSGs are far more powerful than what is required for natural languages, and I am not clear what we gain by modeling them as CSGs. Why not interpret them as context-free grammars with extra semantics as we do with programming languages?

                  Well, context-free is not enough to represent all natural languages, and that is the original work of Chomsky.

                  It might be that all the power of context-sensitive grammars are not necessary, but a subset of it is.

                  And about your suggestion of “context-free with additional rules”, that is not how it works. First, because enumerating all the “semantic rules” would be a ridiculously laborious work (and this kind of approximation is what current works on automatic translation do), but it doesn’t represent all the classes of constructs of a language: one cannot increase the power of a grammar with “workarounds”.

                  In case of programming languages, the grammars (of the languages) are context-sensitive, and the semantic is artificially limited by the designer.

                  1. 2

                    Perhaps I am mistaken here; but the definition in wiki is that all the rules are of the form

                    αAβ → αγβ
                    

                    with A ∈ N α,β ∈ (N∪Σ)* and γ ∈ (N∪Σ)+ where G = (N, Σ, P, S), with N a set of nonterminal symbols, Σ a set of terminal symbols, P a set of production rules, and S the start symbol.

                    My reading of this definition is that γ can’t be empty because of +. This seems to be implied by the next sentence “The only difference between this definition of Chomsky and that of unrestricted grammars is that γ can be empty in the unrestricted case.”

                    What is the definition of context-sensitive grammar you are using?

                    1. 2

                      You are right, and I have overlooked the fact that γ ∈ (N∪Σ)+ .

                      However, I decided to give a fresh start on my arguments after reading a little more, and I hope my other (new) comment makes matter clearer.

                2. 2

                  …Oh thank Eris, I’m so glad that someone with better theoretical chops than me replied to that post. XD

                3. 1

                  I have always felt that the distinction drawn between context-free and context-sensitive languages was a bit arbitrary.

                  It is not arbitrary:

                  • CFG can generate languages with central auto-recursive item, or { aⁿc*bⁿ | n ≥ 0 };

                  • CSG can generate of the type { aⁿcⁿbⁿ | n ≥ 0 }.

                  That comes from the pumping lemma.

                  The former corresponds to automata and the later corresponds to an automata with a stack (a push down automata). To get to context-sensitive, you need a linear bounded automaton which is fairly different from stacks.

                  A pushdown automata is also quite different from a DFA: it has the concept of memory (the stack), while the DFA just needs to know the current state and the current input to find the next state.

                  So, going from stack to a limited free memory (i.e., restricted Turing machine) is such a powerful jump as was from DFA to pushdown automata.

                  To have context-sensitive grammars, you have to add an ugly rule saying that the grammar is non-contracting. That is, ε is only allowed as an alternative expansion to the start symbol.

                  Yes, you are right.

                  That is, every regular grammar is a context-free grammar. However, not every context-free grammar is a context-sensitive grammar.

                  And here lies the flaw, which took me a while (consult some dead-tree books) to get to the core of the issue.

                  Every CFG is contained in the CSG because grammars are measured by the languages they produce, and it is possible to generate any CFL from a CSG. They are not measure by the “shape” of their grammar. And it is here that lies the confusion, I believe.

                  The fact that CFG grammars allow rules with ɛ, while CSG doesn’t (except for the initial rule), it doesn’t mean that CSG are not capable to generate any language generated by CFG.

                  What you are telling is that the language L₂ representing all the CSG grammars is not a strict superset of the language L₁ representing all the CFG grammars.

                  The problem you are adressing is representation of the grammars, which are languages, and not the grammars itself.

                  Finally, the special casing of ε makes context-sensitive grammars unusable for practical purposes (I have not seen an application that would be adequately served by context-sensitive grammars but not by context-free or unrestricted grammars).

                  It is still not clear what you meant with it, but in another comment I did earlier, I said about natural languages, to which you wrote

                  Why not interpret them as context-free grammars with extra semantics as we do with programming languages?

                  If you are parsing a context-free language, then you have to consult “an oracle” (i.e., a rule in memory outside the stack of your pushdown automata), then you get a restricted Turing machine, which is the recogniser of a CSL.

                  That is, what property of context-sensitive languages that is not available in unrestricted languages are you using?

                  Finitude: a Turing machine (the acceptor of unrestricted languages) implies an infinite tape.

                  And decidability of the halting problem.

                  1. 2

                    It is not arbitrary: … That comes from the pumping lemma.

                    Again, I am not disputing the language hierarchy, rather I am making a subjective point. For me the importance attributed to context-sensitive languages seems arbitrary (seems to be based entirely on being invented by Chomsky as part of the original hierarchy.). There are a number of containments in between context-free and unrestricted languages; for example, you can have indexed languages which are recognized by nested stack automata or by indexed grammars, a generalization of CFGs. They are a proper subset of CSLs.

                    A pushdown automata is also quite different from a DFA

                    My point is that a PDA is DFA + (XXX feature), while it is hard to describe LBA as DFA + (XXX feature).

                    Why is this ability to represent it as PDA + XXX or PDA - YYY important for me? The reason is as follows:

                    There is a pleasing pattern in how we define DFAs. If you look at a graph, where each node represents a state and each edge represents consumption of a character, a directed acyclic graph is equivalent to table lookup, and represents the combinational logic. Next, if you allow cycles in the graph, then you get a finite automata representing regular languages. Then, if allow graphs to be named and reused, you get recursive transition networks representing context-free languages. Add registers to RTNs and you get augmented transition networks which are Turing equivalent. This way of representing languages as a series of enhancement over a graph structure holds intuitive appeal for me. It allows me to reason about the language hierarchy by looking at the machinery required.

                    That is, every regular grammar is a context-free grammar. However, not every context-free grammar is a context-sensitive grammar.

                    And here lies the flaw, which took me a while (consult some dead-tree books) to get to the core of the issue.

                    No, I am very specific here. I am not disputing CSLs are superset of CFLs. I am simply saying that not all CFGs are CSGs based on the structure.

                    The fact that CFG grammars allow rules with ɛ, while CSG doesn’t (except for the initial rule), it doesn’t mean that CSG are not capable to generate any language generated by CFG.

                    Again, this is not what I am saying. I have no dispute with the language hierarchy and the hierarchy of languages representable by the different grammar formalisms. Indeed, any language that is representable by a CFG is also representable by some CSG. However, the particular CFG need not be a CSG. If this is the core of disagreement, perhaps this should clear it up.

                    The problem you are addressing is representation of the grammars, which are languages, and not the grammars itself.

                    No, I am addressing the grammars, not the languages; That is, my point is about the machinery used. Not about what it accomplishes.


                    I have only worked in writing parsers and fuzzers for programming languages. In parsing, the standard technique to parse is to use a lexer (a regular expression, that is an automata) to recognize tokens and use a context-free grammar to specify the parser. Finally, use separate semantic rules to specify what string is valid and what is invalid. The reverse for a fuzzer. I have not yet seen any one use context-sensitive grammars for this. Perhaps it is different in your field and CSGs are used. If so, I would be glad to hear about it.

                    1. 1

                      For posterity: I have found that context-sensitive languages are languages of a one way stack automation. These are PDAs with the additional read-only ability to inspect the stack.

                      “Sets Accepted by One-Way Stack Automata Are Context Sensitive” Hopcroft and Ullman 1968.

                1. 7

                  I agree with the comment; this is pretty light on how the author actually uses it.

                  1. 10

                    Yeah, it’s a really weird choice to conclude what is ultimately no more than a tutorial on setting up syntax highlighting in nano with a comment about how you’ve proven nano is as capable an editor as vim or emacs. It is and has for years been beyond me how nano could ever be useful outside of making trivial config file changes in a system you don’t have root access on – these days it seems more ubiquitous than vim or ed. I was hoping this article would clear that up.

                    Then again, maybe there’s nothing to clear up; maybe there really are people who have no further requirements for an editor than being able to type text and save it to a file. I don’t know.

                    1. 3

                      Some people can work perfectly fine with a minimal editor. For example Linus Torvalds with MicroEMACS.

                      1. 7

                        When I learned C, I decided to only use vi (not vim) without colors and without any custom config.

                        It’s a little weird at first, but the brain adapts (quickly) and recognizes the patterns. Now I don’t care which editor is on a system, or how it’s formatted on the web or in an e-mail.

                        1. 4

                          Instead of vi, I use vis. But, in there, I do the same: I disable the syntax highlight, and I only use the default settings of the editor.

                          I read somewhere, someday, that working with disabled syntax highlight makes the programmer more attentive to the code, and consequently make less mistakes.

                          I actually never measured it, but I instinctively feel that I read more carefully the code base, and therefore I learned the code base I work on better than before.

                          I also started to appreciate the [Open|Net]BSD code style, because it helps to work on this style, and to use default UNIX tools to find parts of the code I am interested at.

                          In other words, it leverages UNIX as IDE.

                          1. 2

                            I am thinking about switching from vim to vi + tmux for Go.

                            So far the most challenging was:

                            • block edit;
                            • go to definition;
                            • copy/paste;

                            Especially copy/paste. It turns out I heavily relied on yanking from one vim tab to another.

                            1. 1

                              Which vi? nvi?

                          2. 2

                            It’s ubiquitous because it’s just what I’d expect from a debian system that some non-vim professional might have to administrate via CLI. And for anything that isn’t changing configs on remote systems / rescue mode I’ve got an IDE or Kate if it’s supposed to be simpler.

                        1. 2

                          I am increasingly interested in “improved C languages” [1], and I like the direction this one is taking.

                          It is still in early design state, but it seems very interesting (to me).

                          [1]: I once saw a video in which @andrewrk told his motivation to create Zig was, if I recall correctly, “to fiddle with C so it could be improved by removal of the weird (and undefined) behaviours”. That message has hit me hard, and since then I have been thinking about (and in search of) it.

                          1. 1

                            Was this the video you were thinking of?

                            1. 1

                              No, it wasn’t. It was this one.

                          1. 2

                            That is a very nice effort, and a useful tool I might add to my command-line toolbox.

                            I just pity it hasn’t reused Troff’s GRAP’s language, which is very readable, clear, English-like and follow the UNIX philosophy, besides being a well-thought product of Brian Kernighan; instead, they chose a JSON-based one, which seems very polluted to my eyes.

                            1. 2

                              IIRC Gnuplot takes after GRAP. I’ve been doing a lot of Gnuplot lately and clip’s language looks cleaner to me.

                              1. 1

                                Would you mind expanding your comparison?

                                What do you think it is cleaner in clip’s compared to Gnuplot’s syntax?

                                And how do you compare GRAP’s and Gnuplot’s syntax, except both use (most of time, for Gnuplot) proper English tokens as their command set?

                                I looked at your repository, and I could mostly understand the Gnuplot files, even though I am not used with the syntax.

                                On the other hand, I struggled to “plot the graph in my mind” looking at clip’s examples.

                                I suspect that our divergence my be only on taste grounds, and I guess it is difficult to make a proper comparison without getting a big graph and plotting it in the three applications.

                                Personally, the initial example of GRAP seems way easier to plot using that tool than clip, based on their “Getting Started” document. However, I suspect clip is easier at some kind of plots (e.g., their charts-scientific/streamgraph) than GRAP, but I cannot say so (for lack of knowledge) about Gnuplot.

                              2. 1

                                they chose a JSON-based one

                                I’m not sure how you mean this is “json based”? Looks like it avoids most of the pitfalls of json, and is rather golang/c-like?

                                https://clip-lang.org/examples/charts-scientific/vectorfield/

                                I see no quotes around keys; possibly? support for comments; what appears to be number support, but I suppose it might be brain-dead floats like json; semicolon as line/statement separator?

                                1. 2

                                  Your comment made me evaluate it better, and see it is neither based on JSON nor C-like as you suggest, but it seems based on CSS.

                                  The similarity with CSS can be better seen in the charts-scientific/streamgraph:

                                  • keys and values are not enclosed by quotes, except if text (e.g., path);
                                  • keys and values are separated by colon;
                                  • property’s (i.e., key-values) declaration finishes with semicolon;
                                  • multiple values are separated by spaces;
                                  • some values are defined by “function calls”, such as rgba();
                                  • named blocks, delimited by curly-braces, agglomerate properties.

                                  While I see good value in the influence of CSS and the analogy between language for graphical design and language for plot design, I am in conflict with that choice for a command-line tool: I would have expected the “line experience” seen pervasively in the *NIX world—and, with that, a lower cognitive load for those I believe is the tool’s most potential users—instead of a “language of the web”.

                                  Also, I feel that the art of creating (domain-specific, but also programming) languages with tokens as English words, and making their represented code read like natural language, seems to be dying. GRAP had that, in my opinion.

                                  But setting my sentiment and bias aside, I re-state there is a value in basing its language on CSS, and it might be it will reach more people than if it had followed “the UNIX tradition”: I guess there are more people, nowadays, who know CSS than people who grok grep.

                              1. 4

                                But why would I want to suck through my computation through a VT220 straw when I don’t have to?

                                1. 1

                                  You don’t have to.

                                  But, sometimes, you want to. In my case, I search for some kind of “minimum, Zen-like environment” that is enough to do my work, and the advices from that text help me achieve that.

                                  Or, as the case of the author, you don’t (want to) have a hardware that follows the requirements of resource-inneficient applications that do only the bare minimum work that simpler machines did incredibly well decades ago.

                                  But you do not have to stick to vt220, and can use the default one (pccon0) as well, and still enjoy the recommendations of the essay. 🙃

                                1. 3

                                  This is an extensive manual on how to work only on console (i.e., not on graphica, or X, environment).

                                  The author goes on the different *NIX systems, explains how console works, as well as they presents several alternatives for common graphical applications for the console.

                                  1. 4

                                    I feel that a lot of “software theory” (very broad generalization) suffer from examples that are trivial or has no use in the real world, and this post exemplifies this.

                                    Can anyone recommend software books (both OOP and functional) that look at multiple real-world cases (such as web applications, data processing or other non-trivial-at-size examples) and also offer some thoughts on when to break some patterns for simplicity?

                                    1. 5

                                      Here are some books that use real examples:

                                      Edited to add some more books.

                                      1. 5

                                        Can anyone recommend software books (both OOP and functional) that look at multiple real-world cases (such as web applications, data processing or other non-trivial-at-size examples) and also offer some thoughts on when to break some patterns for simplicity?

                                        Real World Haskell.

                                        It teaches how to make a JSON parser, a barcode decoder, a regular expression library, binary-enconding parser,syslog, among other stuff.

                                        1. 4

                                          The architecture of open source applications is probably the closest thing to what you are asking for http://aosabook.org/en/index.html. I am not sure I am ready to recommend it: I don’t remember learning a lot from it.

                                          https://www.tedinski.com/archive/ (read in chronological order from the first entry) is not what you ask for, but might be what you want. I might be biased, but for me personally this series (especially earlier articles) provided more insights than all the other software architecture stuff I’ve read combined.

                                          1. 3

                                            There are some good books on operating system internals (Linux, FreeBSD and Minix are well-documented contemporary ones). It should be possible to extract some good design ideas from those. But I don’t know of any books that compare multiple systems of the same type, probably because that’s often going to be an apples versus oranges example as different systems typically don’t have exactly the same goals in mind to begin with.

                                            1. 3

                                              Whenever I’ve tried to write proper examples for complex problems, I’ve found that just explaining the background in a realistic way takes way too long, and I’d lose readers before I get to the main point.

                                              Some language features (like encapsulation, advanced type systems) become useful when you deal with programs large enough and maintained for long enough that you actually forgot how things were implemented. But how do you introduce a “too large to keep in your head” program in a blog post or even a book? I suspect that’s an inherent trade-off in describing complex problems.

                                              1. 2

                                                I agree that it’s not an easy thing to solve, and a lot of wisdom on these subjects come from experience and making mistakes, which is difficult to distill into meaningful chapters in a book.

                                              2. 1

                                                Can anyone recommend software books (both OOP and functional) that look at multiple real-world cases (such as web applications, data processing or other non-trivial-at-size examples) and also offer some thoughts on when to break some patterns for simplicity?

                                                Trying to present more than just one real-life program example is probably too much. As I mention in the article the Growing Object Oriented Software does a good job at presenting OOP with one real-like program.

                                              1. 4

                                                The compose key - https://en.wikipedia.org/wiki/Compose_key - is so wonderful that it’s one of the only computer things I almost can’t do without.

                                                “Curly quotes” are as simple as “< and “>. I hit the extra key without effort, and it’s so much nicer especially when programming to put a string inside straight quotes.

                                                x = "some “quote” here is nice, isn’t it?"
                                                

                                                But I recommend just taking 20 minutes to learn the defaults mostly by exploration because they’re so common sense. It’s like drawing with your keyboard.

                                                ^ 2 = ²
                                                c o = ©
                                                n ~ = ñ
                                                . .  = …
                                                - - - = —
                                                L - = £
                                                E = = €
                                                Y = = ¥
                                                
                                                1. 2

                                                  Compose is so useful, that I even use it on Windows.

                                                  But back to *NIX, I recommend to read about .XCompose project, which extends the default Compose’s key combinations, and is also a good reference in the subject.

                                                  Of course, the Compose’s manpage is also a great reference on the matter.

                                                  1. 1

                                                    Indeed. I wanted to find an easy way to type the wonderful —. I’m glad I stumbled upon this little tidbit of the internet which introduced me to .XCompose as a bonus. I also second Carpetsmoker’s comment in the original forum: looking into this has been on my TODO list for some time.

                                                    1. 2

                                                      Glad you liked it.

                                                  1. 31

                                                    I prefer to see this type of project that builds upon what it considers the good parts of systemd, instead of systemic refusal and dismissal that I’ve seen mostly.

                                                    1. 15

                                                      Same. Too often I see “critiques” of systemd that essentially boil down to personal antipathy against its creator.

                                                      1. 22

                                                        I think it makes sense to take in to account how a project is maintained. It’s not too dissimilar to how one might judge a company by the quality of their support department: will they really try to help you out if you have a problem, or will they just apathetically shrug it off and do nothing?

                                                        In the case of systemd, real problems have been caused by the way it’s maintained. It’s not very good IMO. Of course, some people go (way) to far in this with an almost visceral hate, but you can say that about anything: there are always some nutjobs that go way too far.

                                                        1. 3

                                                          Disclaimer: I have not paid close attention to how systemd has been run and what kind of communication has happened around it.

                                                          But based on observing software projects both open and closed, I’m willing to give the authors of any project (including systemd) the benefit of the doubt. It’s very probable that any offensive behaviour they might have is merely a reaction to suffering way too many hours of abuse from the users. Some people have an uncanny ability to crawl under the skin of other people just by writing things.

                                                          1. 6

                                                            There’s absolutely a feedback loop going on which doesn’t serve anyone’s interests. I don’t know “who started it” – I don’t think it’s a very interesting question at this point – but that doesn’t really change the outcome at the end of the day, nor does it really explain things like the casual dismissal of reasonable bug reports after incompatible changes and the like.

                                                            1. 4

                                                              I think that statements like “casual dismissal” and “reasonable bug reports” require some kind of example.

                                                            2. 3

                                                              tbf, Lennart Poettering, the person people are talking about here is a very controversial personality. He can come across as an absolutely terrible know-it-all. I don’t know if he is like this in private, but I have seen him hijacking a conference talk by someone else. He was in the audience and basically got himself a mic and challenged anything that was said. The person giving the talk did not back down, but it was really quite something to see. This was either at Fosdem or at a CCC event, I can’t remember. I think it was the latter. It was really intense and over the top to see. There are many articles and controversies around him, so I think it is fair that people take that into account, when they look at systemd.

                                                              People are also salty because he basically broke their sound on linux so many years ago, when he made pulseaudio. ;-) Yes, that guy.

                                                              Personally I think systemd is fine, what I don’t like about it is the eternal growth of it. I use unit files all the time, but I really don’t need a new dhcp client or ntp client or resolv.conf handler or whatever else they came up with.

                                                              1. 4

                                                                tbf, Lennart Poettering, the person people are talking about here is a very controversial personality.

                                                                In my experience, most people who hate systemd also lionize and excuse “difficult” personalities like RMS, Linus pre-intervention, and Theo de Raadt.

                                                                I think it’s fine to call out abrasive personalities. I also appreciate consistency in criticism.

                                                        2. 4

                                                          Why?

                                                          1. 7

                                                            At least because it’s statistically improbable that there are no good ideas in systemd.

                                                            1. 1

                                                              Seems illogical to say projects that use parts of systemd are categorically better than those that don’t, considering that there are plenty of bad ideas in systemd, and they wouldn’t be there unless some people thought they were good.

                                                              1. 2

                                                                Seems illogical to say projects that use parts of systemd are categorically better than those that don’t

                                                                Where did I say that though?

                                                                1. 2

                                                                  I prefer to see this type of project that builds upon what it considers the good parts of systemd

                                                                  Obviously any project that builds on a part of system will consider that part to be good. So I read this as a categorical preference for projects that use parts of systemd.

                                                          2. 2

                                                            There have been other attempts at this. uselessd (which is now abandoned) and s6 (which still seems to be maintained)

                                                            1. 4

                                                              I believe s6 is more styled after daemontools rather than systemd. I never looked at it too deeply, but that’s the impression I have from a quick overview, and also what the homepage says: “s6 is a process supervision suite, like its ancestor daemontools and its close cousin runit.”

                                                              A number of key concepts are shared, but it’s not like systemd invented those.

                                                              1. 1

                                                                s6 I saw bunch of folks using s6 in docker, but afaik that’s one of most not user friendly software i’ve been used.

                                                          1. 3

                                                            Do people use fzf at the CLI?

                                                            Not by typing fzf but I started using its zsh bindings so it’s acting as my ctrl-R (history search) and I’ve been getting into the habit of using its alt-C instead of typing cd. The ctrl-T behaviour can be useful, but zsh’s menu completion is usually good enough that I don’t need it. Overall I love the fzf shell bindings.

                                                            Other fun tools I use are fd, the find replacement, and k9s for interacting with Kubernetes clusters.

                                                            1. 2

                                                              Do people use fzf at the CLI?

                                                              Not by typing fzf

                                                              I actually do that with fzy, because I am lazy to study the fzf bindings for Bash (and find out whether they work for Korn shell, then create mine), but I am also tired of the imprecise algorithm of fzf, and rather use that of fzy.

                                                              But, obviously, I am the exception, not the rule.

                                                            1. 3

                                                              I may sound bitter, but calling it “memory safety project” seems dishonest and intentionally misleading on the real goal: inject Rust in selected projects.

                                                              I was expecting to see address sanitation, or use of theorem provers and separation logic, but it is not. 😒

                                                              Also, take an fairly big project in Java (a language they deem to be memory safe), run Infer, count the amount of possible NullPointerException, then tell me how it fits the definition of memory safety they are using.

                                                              1. 10

                                                                then tell me how it fits the definition of memory safety they are using.

                                                                There’s a significant, meaningful difference between Java NPE which always leads to program crashing with exception, and C-style undefined behavior, which sometimes leads to remote code execution. This difference exists regardless of definition being used.

                                                                That being said, usefully defining what is “memory safety” is hard! The definition they are using is informal: absence of certain specific memory related bugs. NPEs are certainly memory safe according to their definition. If you get NPE, you don’t actually touch garbage memory.

                                                                I don’t know what would be a more useful definition of memory safety. Formally, memory safety is just type safety, in a sense that “well-typed programs don’t get stuck”, but types&programming languages formalism is not directly translatable to real-world languages, which rarely have full formal semantics.

                                                                1. 5

                                                                  Indeed. (Though I disagree with your assessment of java. ‘[D]efinition of memory safety’ is not at all difficult; it’s simple: java is sound. Barring the derived-array-upcast thing.)


                                                                  Let’s get the Rustls TLS library ready to replace OpenSSL in as many projects as possible.

                                                                  Please don’t. Use project everest’s libraries instead.

                                                                  1. 1

                                                                    @matklad and @Moonchild, thank you for your clarification on Java and NullPointerException; in fact, their concept of memory safety is restricted to out-of-bounds access and use-after-free, so Java fits their restricted definition of memory safety—but does not include most of the types described at Wikipedia article.

                                                                    @matklad, do you have a reference on the formal definition of memory safety?

                                                                    @Moonchild, I really liked you cited Project Everest, because when I opened this link, I expected to see exactly something like that. And that is where my disappointment (or “bitterness”, if one prefers) came from.

                                                                    1. 2

                                                                      The best discussion I know is in http://lucacardelli.name/papers/typesystems.pdf, “Execution errors and safety” section. The key idea is that runtime errors may be trapped or untrapped, and the language is safe if programs accepted by the compiler do not exhibit untrapped errors. That’s the difference between C++ and Java with respect to null pointers: Java traps all attempts at null pointer dereference, while C++ assumes that null pointer dereference can’t happen, and optimizes based on that.

                                                                  1. 56

                                                                    Most of these tools do not feel very unixy (as in “meant to be part of a pipeline”) to me, although they are all cool CLI apps with good ergonomics and in line with modern “terminal aesthetics” (is that a term?).

                                                                    To me the real modern unix tools are Joey’s moreutils tools:

                                                                    • chronic: runs a command quietly unless it fails
                                                                    • combine: combine the lines in two files using boolean operations
                                                                    • errno: look up errno names and descriptions
                                                                    • ifdata: get network interface info without parsing ifconfig output
                                                                    • ifne: run a program if the standard input is not empty
                                                                    • isutf8: check if a file or standard input is utf-8
                                                                    • lckdo: execute a program with a lock held
                                                                    • mispipe: pipe two commands, returning the exit status of the first
                                                                    • parallel: run multiple jobs at once
                                                                    • pee: tee standard input to pipes
                                                                    • sponge: soak up standard input and write to a file
                                                                    • ts: timestamp standard input
                                                                    • vidir: edit a directory in your text editor
                                                                    • vipe: insert a text editor into a pipe
                                                                    • zrun: automatically uncompress arguments to command
                                                                    1. 21

                                                                      Most of them are made to piped, they just use fancy formatting when they’re output to a terminal.

                                                                      1. 6

                                                                        You are right: moreutils’s tools are the real modern UNIX tools, in my opinion as well.

                                                                        In the same category, I also think it is worth to mention @johnaj’s xutil, which I was in awe with the code (as weel as functionality) of ep.

                                                                        1. 5

                                                                          moreutils is a must-have for sponge alone. I need to remember ts, vipe, and pee more often.

                                                                          1. 3

                                                                            sponge is such a beautiful util.

                                                                          1. 1

                                                                            I found the examples very basic or, at times, showing how code is much more verbose when not using macros.

                                                                            However, I would find the opposite way more interesting: cases where only macros (or the preprocessor) solve the problem.

                                                                            Actually, the article shows two cases where the preprocessor is necessary: for _DEBUG and __FUNCTION__.

                                                                            But I have some cases, in both C and C++, where only (as far as I know) the preprocessor solves my problem. For example, a “function” that returns the caller:

                                                                            #define FOO(predicate, return_value) \
                                                                              do {                               \
                                                                                if (predicate) {                 \
                                                                                  return return_value;           \
                                                                                }                                \
                                                                              } while(false)
                                                                            
                                                                            int bar(int parameter) {
                                                                              FOO(parameter > 10, parameter - 1);
                                                                              FOO(parameter < 10, parameter + 1);
                                                                              return parameter;
                                                                            }
                                                                            

                                                                            I usually use this kind of construction to emulate a “monadic error handling” in complex (or legacy) code.

                                                                            Of course the preprocessor is a double-edged sword and there are “more modern and safer weapons”. But I miss the discussion on the cases it is really useful and also the reasons it was originally invented.

                                                                            Macros is so widespread in the UNIX ecosystem that one must wonder when it is useful.

                                                                            1. 11

                                                                              I find these kind of articles exhausting. They usually come down to the same: pattern X seen in paradigm Y is bad, therefor Y is bad. The alternatives proposed usually aren’t really good either. Basically once you’ve read one of these, you’ve read all of them.

                                                                              For example:

                                                                              If it looks like a candidate for a class, it goes into a class. Do I have a Customer? It goes into class Customer. Do I have a rendering context? It goes into class RenderingContext.

                                                                              Then the “solution” presented in this article:

                                                                              The data itself will be in form of an ADT/PoD structures, and any references between the data records will be of a form of an ID (number, uuid, or a deterministic hash). Under the hood, it typically closely resembles or actually is backed by a relational database: Vectors or HashMaps storing bulk of the data by Index or ID, some other ones for “indices” that are required for fast lookup and so on.

                                                                              Now there’s nothing wrong with plain old data structures. But eventually those data structures are going to need a bunch of associated functions. And then you pretty much have a class. In other words, the solution is basically the same as the problem.

                                                                              The real problem isn’t unique to OOP and can just as easily occur in say functional programming languages. That is, the problem is people over-applying patterns without thinking “Hey, do we actually need this?”. Traditional OOP languages may promote this in some way, but again that’s a problem with those languages. The concept of OOP has nothing to do with any of this.

                                                                              Random example: in any language that has support for macros, inevitably some will start abusing macros. But that doesn’t mean the entire language or its paradigm is bad and should be avoided.

                                                                              As an aside, every time I see a quote from Dijkstra I can’t help but feel this man must have been absolutely insufferable to work with. Yes, he was very smart and made many contributions. But holy moly, his “I am right and everybody else is wrong” attitude (at least that’s how it comes across to me) is off putting to say the least.

                                                                              1. 5

                                                                                Now there’s nothing wrong with plain old data structures. But eventually those data structures are going to need a bunch of associated functions. And then you pretty much have a class. In other words, the solution is basically the same as the problem.

                                                                                It is the other way around. With OOP, you pretty much end up jamming into data structure definitions what essentially are functions. The concept of class is fuzzy and it’s not a clear well define starting point for a thought process.

                                                                                Notice that you said “associated functions”. I think it’s all the OOP non sense cornering you into that unclear language. What exactly are those? Functions that accept the type you are defining? Functions that manipulate the state of said data structure? Functions that return a reference to it?

                                                                                If you think about this questions and find clear answers for them, you will realize that there is absolutely no reason to make functions have all sorts of tricky behaviours based on state or even “belonging to an instance”. At which point the concept of class becomes pointless.

                                                                                Relational algebra was developed with solid theory behind it. To my knowledge, OOP was just something thrown together “because it is a good idea”.

                                                                                Records, as in compound types, are very useful in many fields even outside programming languages. Hooking functions to them is just a strange idea whose motivation I am yet to discover.

                                                                                1. 2

                                                                                  Notice that you said “associated functions”. I think it’s all the OOP non sense cornering you into that unclear language. What exactly are those?

                                                                                  When I say “associated function” I mean that in the most basic sense: it simply does something with the data, regardless of how the code is organised, named, etc.

                                                                                  If you think about this questions and find clear answers for them, you will realize that there is absolutely no reason to make functions have all sorts of tricky behaviours based on state or even “belonging to an instance”. At which point the concept of class becomes pointless.

                                                                                  I’m not sure what tricky behaviour have to do with anything. That just seems like you’re inventing problems to justify your arguments.

                                                                                  even “belonging to an instance”

                                                                                  Perhaps this comes as a surprise, but this exists in functional programming too. For example, if you have a String module with a to_lowercase() function, and that function only operates on strings, then that function basically “belongs to an instance”. How exactly you store that function (in the instance, elsewhere, etc) doesn’t matter; the concept is the same. Whether the data is mutable is also completely unrelated to that, as you can have OOP in a completely immutable language.

                                                                                  Relational algebra was developed with solid theory behind it. To my knowledge, OOP was just something thrown together “because it is a good idea”.

                                                                                  I suggest you do some actual research into the origins of OOP, instead of spewing nonsense like this. It’s frankly embarrassing.

                                                                                2. 4

                                                                                  Have you ever stumbled upon good OOP code that actually looked OOP?

                                                                                  I haven’t. The good code I’ve seen was inevitably a mix of procedural, modular, and functional code, with a heavy slant towards either procedural or functional, with maybe a couple instances of inheritance, for polymorphism’s sake (and even then, sometimes we just pass functions directly).

                                                                                  The most distinguishing characteristic I see in OOP is how it stole almost every features to other paradigms or languages. ADT, encapsulation? Modular programming, from Modula. Generics? Parametric polymorphism from ML and Miranda. Lambdas? From every functional language ever. The only things left are inheritance, which was added in Simula to implement intrusive lists (which were needed because there was no C++ like templates), and subtype polymorphism, which is often better replaced by good old closures.

                                                                                  And guess what, inheritance is now mostly discouraged (we prefer composition). The only thing left is subtype polymorphism. OOP is an empty husk, that only survives by rebranding other programming styles.

                                                                                  1. 2

                                                                                    ADT, encapsulation? Modular programming, from Modula.

                                                                                    ADTs come from Barbara Liskov’s CLU, which cites Simula’s inheritance as inspiration.

                                                                                    1. 1

                                                                                      Hmm, didn’t know, thanks. I looked Modula up as well, it seems both languages appeared at rather the same time.

                                                                                    2. 1

                                                                                      Have you ever stumbled upon good OOP code that actually looked OOP?

                                                                                      This depends on what one would consider OOP, as the opinions/interpretations differ. Have I seen good OOP? Yes. Was that Java-like OOP as I would imagine most people think OOP is like? No. But just because something is OOP doesn’t mean it can’t have elements from other paradigms.

                                                                                      The most distinguishing characteristic I see in OOP is how it stole almost every features to other paradigms or languages. ADT, encapsulation? Modular programming, from Modula. Generics? Parametric polymorphism from ML and Miranda. Lambdas? From every functional language ever

                                                                                      Ah yes: functional languages invented everything, and every other language using elements from this is “stealing” them.

                                                                                      I’m honestly not sure what point you’re trying to make. X sharing elements with Y doesn’t mean somehow X isn’t, well, X. Just as how X having flaw Y doesn’t completely invalidate X. Having such a single minded (if that’s the right term) attitude isn’t productive.

                                                                                      1. 3

                                                                                        Ah yes: functional languages invented everything, and every other language using elements from this is “stealing” them.

                                                                                        Not just functional. Modules did not come from functional languages, that I recall.

                                                                                        To some extent though, yes: functional languages invented a lot. Especially the statically typed ones, whose inventors realise this fundamental truth that often gets me downvoted in programming forums if I voice it: that programming is applied mathematics, and by treating it as such we can find neat ways to make programs better (shorter, clearer, or even faster). Dijkstra was right. Even Alan Kay recognises now through his STEPS project that “math wins”. (Of course, it’s very different from calculus, or most of what you were taught in high school. If anything, it’s even more rigorous and demanding, because at the end of the day, a program has to run on a dumb formal engine: the computer.)

                                                                                        I’m honestly not sure what point you’re trying to make.

                                                                                        That to many OOP proponents, “OOP” mostly means “good”, and as we learn how to program better over the decades, they shift the definition of “OOP” to match what they think is good. It takes a serious break, like data oriented programming, to realise that there are other ways. To give but an example: back in 2007, I designed some over-complicated program in C++, with lots of stuff from the <algorithm> header so I could pretend I was using OCaml (I was an FP weenie at the time). My supervisor look at the code (or maybe I was outlying my design to them, I don’t remember), and said “well, this is very OO and all, but maybe it’s a bit over-complicated?”

                                                                                        That’s how pervasive OOP is. Show a programmer functional patterns (with freaking folds!), they will see OOP.

                                                                                        OOP is no longer a paradigm. It devolved into a brand.

                                                                                    3. 2

                                                                                      But eventually those data structures are going to need a bunch of associated functions. And then you pretty much have a class.

                                                                                      Running in the risk of taking your quote out of context, I think the mindset OOP is simply data structures with encapsulated functions is actually one of the biggest real dangers of OOP, because it hides its biggest flaw: pervasive proliferation of (global) states.

                                                                                      Thus, I understand where you are leading your argument, but I disagree with it.

                                                                                      As an aside, every time I see a quote from Dijkstra I can’t help but feel this man must have been absolutely insufferable to work with. Yes, he was very smart and made many contributions. But holy moly, his “I am right and everybody else is wrong” attitude (at least that’s how it comes across to me) is off putting to say the least.

                                                                                      I happen to know a lot of people who directly worked (or had classes) with him, and unanimously I hear both adjectives: genius and pretentious.

                                                                                      Of course those are just others’ opinions, not mine, but I share your (and those people) feelings.

                                                                                      1. 1

                                                                                        Running in the risk of taking your quote out of context, I think the mindset OOP is simply data structures with encapsulated functions is actually one of the biggest real dangers of OOP, because it hides its biggest flaw: pervasive proliferation of (global) states.

                                                                                        I agree a lot of OOP languages/projects suffer from too much (global) mutable state. But I’m not sure if that’s necessarily due to OOP. I think this is a case of “correlation is not causation”. Perhaps a silly example: if functional languages had mutable state, I think they would have similar issues. In other words, I think the issue is mutability being “attractive”/tempting, not so much the code organisation paradigm.

                                                                                        Another example: I think if you take away the ability to assign non-constant types (basically anything but an int, float, string, etc) to constants/globals, and maybe remove inheritance, you already solve a lot of the common issues seen in OOP projects. This is basically what I’m doing with Inko (among other things, such as replacing the GC with single ownership).

                                                                                        I do think for such languages we need a better term for the paradigm. Calling it X when it mixes properties from A, B, and C is confusing. Unfortunately, I haven’t found a good alternative term.

                                                                                      2. 2

                                                                                        I view OOP as an organizing principle—when you have few types, but lots of actions, then procedural is probably the way to organize the program (send the data to the action). When you have a few actions, but lots of types, then OOP is the way to organize the program (send the action to the data). When you have few actions, few types, then it doesn’t matter. It’s that last quadrant, lots of types, lots of actions, there is currently no good method to handle.

                                                                                        1. 2

                                                                                          When you have X types and Y actions, unless you have many of both, I believe your program is already mostly organised. Many types and few actions? It will end up looking OOP even if you write it in C. Few types and many actions? It will end up looking procedural even if you write it in Java.

                                                                                      1. 3

                                                                                        Sounds like lots of people are seeing these banners. I think they should maybe be turned off. Mods can review flags and reach out to problem members directly in the rare case that that’s appropriate.

                                                                                        Agree that if flags are routinely being used inappropriately that should also be visited: perhaps “-5 unkind” is usually just upsetting/demotivating rather than constructive feedback (perhaps highly flagged users could have this information hidden or frequent flaggers could have their flags ignored or something).

                                                                                        1. 14

                                                                                          I would like to give a different perspective.

                                                                                          Sounds like lots of people are seeing these banners.

                                                                                          So far, except @burntsushi, just other two users saw those banners, in three different instances.

                                                                                          I think they should maybe be turned off. Mods can review flags and reach out to problem members directly in the rare case that that’s appropriate.

                                                                                          I think it is quite a toll on the mods, assuming they are volunteers. (I think so.)

                                                                                          For example, just yesterday, the moderators intervened in six different moderation activities (see moderation log).

                                                                                          Also, it seems there are only three active mods (Sysopt hats), and effectively just one (seeing the moderation log), out of 959 user shown in the standings, out of which eight users are seeing the banner today.

                                                                                          Is it fair to put such burden on moderators because one (famous) user felt the banner was a nudge to leave the community?

                                                                                          Do not get me bad: I do think it is healthy to discuss whether the heuristics are valid. However, I think we should make educated decisions based on the facts we have available.

                                                                                          In defence of Lobsters, I must say:

                                                                                          All in all, I think @jcs, @pushcx (and the other collaborators) did a great job on the algorithm: in clarity, in permissiveness and in coding skills.

                                                                                          Agree that if flags are routinely being used inappropriately that should also be visited

                                                                                          I am not sure how it is done nowadays (I would have to dig even further, and unfortunately I don’t have any more spare time now), but I think it is a good idea, indeed: a “frequent flagger” is also not an example member of the community.

                                                                                          1. 10

                                                                                            So far, except @burntsushi, just other two users saw those banners, in three different instances.

                                                                                            If it’s really triggered this rarely, …

                                                                                            I think it is quite a toll on the mods,

                                                                                            … would it really be a toll for this heuristic to instead send a message to a mod and have them trigger something better worded to the user?

                                                                                            1. 5

                                                                                              … would it really be a toll for this heuristic to instead send a message to a mod and have them trigger something better worded to the user?

                                                                                              The mods already send messages to work with people, and many of the user bans in the past have been from people who were repeatedly warned over months.

                                                                                              1. 2

                                                                                                … would it really be a toll for this heuristic to instead send a message to a mod

                                                                                                I think so because, as I stated in my comment, in the last day:

                                                                                                • eight users has seen the banner (according to the standing page);
                                                                                                • the mods have performed six moderation actions, and those seem uncorrelated with the flagging.

                                                                                                Thus, instead of six, the mods would have had to perform 14 operations in the same timeline, which implies an increase of 133.̅ 3 % of their duties. If I were would be in their shoes, I wouldn’t appreciate this volume increase, especially in a volunteer task.

                                                                                                The “just other two users” were the ones who commented in this story that had seen the banner, which was the context I replied to.

                                                                                                and have them trigger something better worded to the user?

                                                                                                As I said in the other comment,

                                                                                                I found the banner a blunt version of the “dude, chill a little, get a glass of water and let the dust settle” I would get from my co-workers if I would go three meetings straight talking controversial points.

                                                                                                I guess, though, I am immersed in a culture way blunter than most people.

                                                                                                But if re-phrasing the banner would satisfy the community standards and avoid fleeing of active members, then I think it is a worthy effort.

                                                                                                1. 2

                                                                                                  I think so because, as I stated in my comment, in the last day:

                                                                                                  1. That “in the last day” was not at all clear to me. The phrasing sounds like there’s been three people since it was implemented.

                                                                                                  2. How did 3 users from your previous comment become 8 in this one?

                                                                                                  1. 2

                                                                                                    That “in the last day” was not at all clear to me. The phrasing sounds like there’s been three people since it was implemented.

                                                                                                    I noticed it might have caused confusion.

                                                                                                    What I meant is:

                                                                                                    • the standing page shows the people currently flagged;
                                                                                                    • it seems the flagged people are shown the banner after a day;
                                                                                                    • I saw, at the time of the writing of my comment, eight flagged more than 10 times.

                                                                                                    How did 3 users from your previous comment become 8 in this one?

                                                                                                    Well, it was only, at the time of writing, two users, in a total of three occasions (thus, two occasions for a single user), who had stated, in this story we are all commenting, they also saw the banner.

                                                                                                    The original comment from @cmcaine was

                                                                                                    Sounds like lots of people are seeing these banners.

                                                                                                    which, at that point, let me infer he has taken at position based on the comments of the other two users in this story.

                                                                                                    Therefore, given that context, I answered

                                                                                                    Sounds like lots of people are seeing these banners. So far, except @burntsushi, just other two users saw those banners, in three different instances.

                                                                                                    What has accidentally happened is that your original comment removed a lot of context, and thus a common interpretation diverged.

                                                                                                    I hope I made myself clearer, now.

                                                                                              2. 7

                                                                                                Thank you for sharing your thoughts.

                                                                                                In answer to your curiosity about flags being used inappropriately, I can say that flags are quite rare. This entire thread, despite being about a controversial topic, has hardly any. I am personally confident as a moderator that most community members understand that flags are for exceptional situations.

                                                                                                1. 1

                                                                                                  I think this thread has fewer because the thread itself scrutinizes over-use of flags, so people are more aware of that. It’s sort of like how someone can seem aware of what they’re doing wrong when you talk to them and make them conscious of it, but then go right back to doing it later on because now it’s _sub_conscious.

                                                                                                  1. 3

                                                                                                    Sure. That’s a fair point. I haven’t looked at numbers recently, but I do know that even a couple years ago, there were certain topics that would reliably turn into voting wars, with people taking polarized positions and either upvoting or flagging based on their preconceived views. I am pleased that I don’t see much of that any more, I think the site has made some real progress since those days. I think that’s something everyone here should be proud of.

                                                                                                2. 2

                                                                                                  I also like that Lobste.rs is a community that is designed to be transparent and to keep conversation healthy and on-topic, but this is a case where the design has almost certainly not worked as intended: a prominent community member who makes good contributions has left (I have never seen a bad comment on lobste.rs by burntsushi).

                                                                                                  I think it is worth examining why they have left and correcting something: maybe just the text of that warning; maybe requiring a moderator to examine it; maybe something else.

                                                                                                  Regarding the burden, I think that the standing page shows that it is probably not such a big burden: every month or so the comments of ~8 users might need to be reviewed (churn into and out of the danger zone is likely to be slow). Some number of them may warrant a short message from a mod or the display of the banner. That’s not a big increase on the dozens of actions mods already do each month.

                                                                                                  1. 2

                                                                                                    I agree - this wasn’t a positive outcome. I can’t promise anything but we’re thinking about what we can change, behind the scenes. The discussion in this thread is certainly part of that.

                                                                                                    1. 1

                                                                                                      Nice. Thank you for being part of the moderation team.

                                                                                                3. 2

                                                                                                  I agree and would add that that any automatic behaviour taking the number of flags as input should be completely hidden from the users. Not only the authors, but also all website readers.The testimonial by @antt is very clear.