1. 27

    In every project, there is a software architect who makes final decisions.

    Oh, honey, no.

    1. 11

      Oh, honey, no.

      Completely unrelated, but I really wish that people would stop using this kind of phrase. It’s simultaneously the most condescending and the most vapid thing that I hear. It sounds like you’re speaking to a stupid child, and it seems like it never comes with a good argument.

      1. 2

        Well, it sounds like I’ve hit precisely the rhetorical target I was aiming for. Best of luck finding a good argument.

        1. 4

          You were trying to sound pointlessly condescending, with nothing worthwhile to say? If you want, I guess that’s your right.

      2. 1

        Maybe the idea is that given enough time, there are tribal warlords even in “flat” organizations? Sometimes they aren’t easily visible but if you look closely, you’ll find them (or create them?)

      1. 2

        SSH was chosen over TLS because it provides strong, battle tested security without needing centralized third-party trust authorities. This makes it a good fit for distributed systems like distkv.

        FWIW, nothing about TLS requires third-party CAs. It’s entirely possible to use TLS (esp. with crypto/tls) with a Trust On First Use (TOFU) model. SSHv2 is still a fine choice, provided you’re using a modern configuration (and since you’re using golang.org/x/crypto/ssh, you are).

        1. 1

          FWIW, nothing about TLS requires third-party CAs

          You are right in this regard, the third-party attribute is not necessarily given, but I’d argue it is true most of the time. Any proper CA - even if you run it yourself (which has its own security implications) - will usually be centralized again for security reasons and would therefore contradict the distributed approach.

          It’s entirely possible to use TLS (esp. with crypto/tls) with a Trust On First Use (TOFU) model

          I wanted to implement a simple to use, security first approach. Automated TOFU is basically useless for MITM protection, it’s like not even checking the host key fingerprint upon your first SSH connection. TLS would have required distributon of all node certificates for the decentralized (self-signed) use case, so I did not see a simplification.

          1. 1

            Automated TOFU is basically useless for MITM protection, it’s like not even checking the host key fingerprint upon your first SSH connection.

            SSHv2 uses a TOFU model, and it’s about as automated as they come. You’re correct that if the first connection is MitM’d, then the “trust” aspect of it falls apart. But that’s an intentional tradeoff of this approach. OpenSSH recently added support for CA-signed host keys to work around this exact issue.

            TLS would have required distributon of all node certificates for the decentralized (self-signed) use case, so I did not see a simplification.

            TLS does not require pre-distributed certificates. You can compute a fingerprint of the certificate used in the handshake and compare it to the fingerprint of the certificate used in the last handshake—exactly like SSHv2. I’ve implemented a system exactly like this in Go.

            1. 1

              SSHv2 uses a TOFU model, and it’s about as automated as they come. You’re correct that if the first connection is MitM’d, then the “trust” aspect of it falls apart.

              Unfortunately, many end-users and even companies are very careless in this aspect - e.g. my experience with some server providers shows it may even be impossible to securely bootstrap a system with them (no fingerprint given). But I think we are on the same page here - it always comes down to some trade off between security and usability.

              OpenSSH recently added support for CA-signed host keys to work around this exact issue.

              Interesting, I am going to take a look at the implementation!

        1. 17

          See Racket’s <.

          It can (< 5 x 10).

          1. 33

            Heh, due to the styling of links on lobste.rs, that reads rather hilariously as the lesser or equal sign.

            1. 11

              Also Common Lisp, Elisp, and Clojure. It’s an incredibly nice little thing.

              1. 2

                Or, to move out of Lisp: also in Python.

              2. 5

                Yup. A little tip is to read variadic < as “strictly ascending” and <= as “ascending”. That was it makes as much sense for the expected 2-arity as it does for the 0, 1, and N overloads.

              1. 8

                Encryption scheme does not hide information it was not designed to hide. Let’s write an article about it!

                Let’s also make sure we say that PGP is good for the peeping toms, 2 or 3 times, OK? Let the readers stick with plaintext.

                1. 2

                  The NSA has invested massive resources into metadata collection programs precisely because metadata is incredibly valuable for traffic analysis. One is almost guaranteed that they use GPG metadata, given its fidelity and non-repudiability.

                  Remember, it’s not the GNU Confidentiality And Integrity Guard. It’s the GNU Privacy Guard. Metadata is more than enough to expose people despite their expectations of privacy. “You encrypted a 10MB document for an investigative reporter the night before you quit” needs to be private in the same way that “oh, you got a call from an STD clinic and then right afterwards you called your doctor” should be private.

                  1. 1

                    That’s not the choice given to the common email user. The choice is whether to encrypt or not the body of the email. And the criticism is that by encrypting the body, there’s still info visible in the rest of the email? It doesn’t make sense.

                    It’s like saying that locking your door won’t protect you from intruders through the windows, in an article titled “your door locking is leaking” with observations like “thieves love locked doors”, hint-hint, nudge-nudge.

                    It’s a disservice to the users, that’s what it is.

                1. 2

                  How is this better than Telegram?

                  1. 16

                    For one, it’s designed and implemented by actual cryptographers.

                    1. 2

                      Conversely, Telegram has been as reliable as sending a text message, which ends up being a lot more important to me when my spouse needs to contact me.

                      https://lobste.rs/s/4xnt5x/reliable_alternative_to_textsecure

                  1. 5

                    The example they gave about English diverging isn’t so bad, as long as you’re familiar with the TH letter (þ, known as ‘thorn’), which fell out of style because imported printing presses didn’t ship with it.

                    In Old English, however, ‘Ving-Thor was mad when he woke up’ would have been Wraþmod wæs Ving-Þórr/he áwæcnede

                    Rewritten using the modern alphabet: ‘Wrathmod was Ving-Thor / He awaecnede". Not so bad; “Wrath” and “Mad” no longer compound, and “When” is missing, but it seems reasonably close to me.

                    1. 1

                      Wráþmod is a compound of wrath and mood; it’s the same construction as bliðemod, meaning happy (blithe + mood). In addition to mood compounds, there’s also heart compounds (e.g. gramheort, also meaning angry). Anglo-Saxon’s rad.

                    1. [Comment removed by author]

                      1. 9

                        The fact that they aren’t using Mersenne Twister is kinda mind-boggling. Like, in gamedev, we’ve known that shit for two decades.

                        1. 1

                          Mersenne Twister might not be sufficient for real money gaming.

                          1. 1

                            In cases like this, if you ever use the default RNG without at least a wrapper so you can switch to something better–especially something you can seed reliably, which Math.random emphatically isn’t–you are doing it wrong.

                            MT might not be the best, but it’s basically table stakes for this sort of stuff.

                            1. 5

                              MT’s great for Monte Carlo, but it’s a terrible choice if you have an adversary who might benefit from being able to predict the output of your PRNG.

                              It takes 624 consecutive observations from an MT PRNG to be able to absolutely determine its internal state: https://jazzy.id.au/2010/09/22/cracking_random_number_generators_part_3.html

                              That’s also not a hard limit. Fewer observations don’t radically increase the computation difficulty of determining the PRNG’s internal state: https://jazzy.id.au/2010/09/25/cracking_random_number_generators_part_4.html

                      1. 4

                        What’s hard to ignore is that the correct code at the end does a lot of work to hide the fact that there is an error condition, and has to execute through the whole code regardless of if anything will be run. I think this is objectively worse than the Haskell or Ocaml, hypothetical code, that uses a monad. For example:

                        write "foo
                        >>= fun () ->
                        write bar
                        

                        This code, depending on how >>= is defined, will bail out from the computation if an earlier one fails.

                        I completely agree that errors are values. I think Go does it pretty poorly, not much better than C, and Ocaml and Haskell have figured this out awhile ago and have far superior APIs on top. Yes yes, it doesn’t matter because Go is very popular, but I just get ruffled by well-meaning-but-ignorant posts like these.

                        1. 8

                          well-meaning-but-ignorant posts

                          There’s nothing ignorant about this post. It does a fair job at covering error handling in Go.

                          I think this is objectively worse

                          I’ve always wondered how that word can be used in the context of PL design. I think it is disingenuous. Notably, your comment ignores the costs of doing error handling that way. Compare, for example, Rust’s guide to error handling with this post for Go (or Pike’s original post). The difference is hard to miss.

                          1. 5

                            There’s nothing ignorant about this post. It does a fair job at covering error handling in Go.

                            You’re right, I got lost in reading the article thinking it was about errors as values and Go as an example of that.

                            I’ve always wondered how that word can be used in the context of PL design.

                            The monadic method I mention above is superior to Go’s in every way i can see except for the part about it not being in Go. The reason for this is the Go solution given is a broken attempt at a monad. The Go solution requires zombie values to ignore future computation which it tries to do anyways, it is not very compositional, it requires always returning a product type when the actual abstraction is a sum type, and it does not force handling of errors which is explicitly cited as being important in the Pike article. The Ocaml/Haskell/Monad solution enforces all of these things. The programming has to explictly choose to not do them.

                            1. 3

                              The monadic method I mention above is superior to Go’s in every way i can see except for the part about it not being in Go.

                              There is a cost: complexity. I submitted evidence to you in my previous comment.

                              1. 3

                                The link you gave is about Rust, which is not one of the languages I cited. It is also does not seem to be using monadic combinators as I am. It’s unclear to me what the complexity you are referring to is.

                                1. 4

                                  The link you gave is about Rust, which is not one of the languages I cited.

                                  It is principally using the same style of error handling as Haskell.

                                  It is also does not seem to be using monadic combinators as I am.

                                  The similarities between try! and >>= are quite striking. And and_then is a concrete version of >>=.

                                  It’s unclear to me what the complexity you are referring to is.

                                  The article I linked to is over 10,000 words. This is not unique to Rust. The number of language features required to do monadic error handling is a reflection of this. Monadic error handling requires that the language at least have support for parametric polymorphism and sum types. Haskell in particular also benefits from higher kinded polymorphism and a programming model that encourages immutable data structures over mutable data structures. None of these things are present in Go. Adding them to the language, and forcing programmers to learn how to use them to handle errors, is a cost in complexity. You would also need to address the conversion of different error types, which is handled automatically in Go at the expense of somewhat increased complexity for callers that need to get at the concrete error (it requires a type assertion or type switch at runtime).

                                  Go’s error handling is simple. There is only one pattern you need to know:

                                  if err != nil {
                                      return ...
                                  }
                                  

                                  That’s it. It is re-inforced again and again in exactly the same way. It is simple, in part, because it is simplistic. This means it is not privy to the long list of benefits you cited for monadic error handling. However, it does mean that it is simple, which is a benefit unto itself, both in the code it takes to write to handle errors and in the language as a whole.

                                  This notion that one PL design is “objectively” better than another is nauseating. Programming language design is about the balancing of trade offs. List the benefits, compare and contrast different approaches and let others make up their own mind about what is applicable to their particular situation. There’s no need for grandiose pronouncements that you happened to have stumbled upon the keys to what makes one design better than another in all possible cases. For example, some folks might reasonably attach a much higher value to the simplicity afforded by Go than you would. Who are you to say that they are wrong?

                                  1. 4

                                    The similarities between try! and >>= are quite striking. And and_then is a concrete version of >>=.

                                    Perhaps on the surface, but they are quite different underneath. try! just bails out whereas >>= allows for much more power. Yes, and_then is bind, however Rust does not appear to be expressive enough to make calling it not look painful. I would not use it to compare what I’m talking about.

                                    The article I linked to is over 10,000 words. This is not unique to Rust.

                                    As I said, I have not brought up Rust so I do not feel it is a useful comparision to what I have said.

                                    Monadic error handling requires that the language at least have support for parametric polymorphism and sum types.

                                    Indeed, but that is not an issue in Go because the compiler can support it like it does for everything else that requires parametric polymorphism. Much like how tuples are not a type but a specialization of assignment.

                                    You would also need to address the conversion of different error types, which is handled automatically in Go at the expense of somewhat increased complexity for callers that need to get at the concrete error (it requires a type assertion or type switch at runtime).

                                    This is no different in the suggested solution which chains a bunch of rights together.

                                    Go’s error handling is simple.

                                    I agree. That doesn’t make it good. @codahale gave an example of where this simple idiom can easily result in a bug. The error handling mechanism of Go also does not enforce that an error is handled, which was explicitly stated as being important.

                                    This notion that one PL design is “objectively” better than another is nauseating.

                                    My statement is that the Go model is inferior in every way to the monadic solution, including complexity and safety. In this sense, my statement of something being objectively worse is not a language trade-off issue. This is a technical statement. You can disagree and say my technical analysis is wrong, however this is different than claiming my statement is equivalent to opinion.

                                    1. 2

                                      Perhaps on the surface, but they are quite different underneath. try! just bails out whereas >>= allows for much more power.

                                      Notice that I didn’t claim they were the same. How is that difference material to our current discussion?

                                      however Rust does not appear to be expressive enough to make calling it not look painful

                                      Indeed! Hence, try!.

                                      Indeed, but that is not an issue in Go because the compiler can support it like it does for everything else that requires parametric polymorphism. Much like how tuples are not a type but a specialization of assignment.

                                      Right, so, more language features. More complexity. More things the programmer needs to learn to do error handling. Which is exactly my point.

                                      I agree. That doesn’t make it good. @codahale gave an example of where this simple idiom can easily result in a bug. The error handling mechanism of Go also does not enforce that an error is handled, which was explicitly stated as being important.

                                      I never, ever once said “Go’s error handing is good.” I have also never once contested the downsides of Go’s error handling.

                                      My statement is that the Go model is inferior in every way to the monadic solution, including complexity and safety.

                                      This is false. It is more complex because it requires more abstraction and more language features. There are more things that the programmer needs to learn and master before one can effectively handle errors.

                                      You can disagree and say my technical analysis is wrong, however this is different than claiming my statement is equivalent to opinion.

                                      You are using the word objective, which implies you have knowledge of what makes a PL design better than another in every facet. I fundamentally disagree that this something that one can possibly know, and frankly, I find it extremely off-putting.

                            2. 4

                              I think allowing four possible outcomes, despite only two of them being meaningful or even expected 90% of the time could count very well as objectively worse.

                              1. 1

                                This is like saying that statically typed languages are objectively superior to unityped languages because there is really no end to the number of unmeaningful things one can express in a unityped language that would be disallowed in an expressive type system.

                                There are plenty of legitimate uses of unityped languages, or, in this case, simplistic error handling. Namely, when one wants to avoid the cost in complexity of a safer variant that does very well at making sure the programmer writes correct code. (This can be from the perspective of the programmer or from the PL designer!)

                                1. 4

                                  This is like saying that statically typed languages are objectively superior to unityped languages

                                  But a statically typed langauge is objectively superior to an unityped language because I can express everything about a unityped language in an statically typed language with the same runtime guarantees. It’s a mathematical fact.

                                  1. 1

                                    There are a cornucopia of trade offs involved in choosing between a unityped language and a statically typed language. Ignoring these and appealing to “mathematical fact” is downright dishonest.

                                    1. 4

                                      That is not what my response said. A unityped langauge is a strict subset of a statically typed langauge, just with everything being some ‘dynamic’ type. I can therefore great a language that is statically typed but lets me do the semantic equivalent of Python. The is what languages like TypeScript do. So a statically typed language with this dynamic type is always superior to a unityped langauge because I can express everything the unityped language can, and more.

                                      1. 1

                                        is always superior

                                        That doesn’t make any sense. You’re ignoring everything else about the language. Remember what I said:

                                        This is like saying that statically typed languages are objectively superior to unityped languages

                                        If you believe this to be true, then one can conclude that Haskell is “objectively superior” to Python. What does that even mean? It’s nonsense.

                                        You say this:

                                        So a statically typed language with this dynamic type is always superior to a unityped langauge because I can express everything the unityped language can, and more.

                                        I disagree. I do agree with this however:

                                        I can express everything the unityped language can, and more, with a statically typed language.

                                        Do you see the difference? The former has your own little prescriptions buried in it. The latter is a technical claim that can be verified as true or false.

                                        1. 1

                                          That doesn’t make any sense. You’re ignoring everything else about the language. Remember what I said:

                                          You’re right! I misinterpreted what you said! My apologies.

                            3. 4

                              depending on how >>= is defined

                              I think this highlights a strength of how go does it: whenever an error is returned, there’s three possibilities:

                              1. unhandled (none of the return values are assigned)
                              2. ignored (assigned to _)
                              3. dealt with

                              All of these things happen explicitly in the code, I don’t need to figure out if an operator means something different or follow a different logic path.

                              1. 12

                                But because those things happen explicitly in the code, you’re constantly at risk of introducing defects in your error handling code. I’ve written a lot of Go and about 95% of the error handling code I’ve written has been some form of this:

                                err := blah()
                                if err != nil {
                                  return err
                                }
                                

                                The end result is a codebase littered with bits of low-value code, often with poor test coverage (either due to the code being seen as low-value or because the error conditions are hard to simulate). But what could go wrong, you say?

                                // forgetting to pass the error
                                err := blah()
                                if err != nil {
                                  return nil
                                }
                                
                                // passing the wrong error
                                if e := blah(); e != nil {
                                  return err
                                }
                                
                                // accidental exit
                                if err = blah(); err == nil {
                                  return err
                                }
                                

                                All these are mistakes that I’ve personally made (usually caught by tests, often not) or seen in actual, no-shit codebases because humans have a very predictable tendency to zone out when doing boring, repetitive tasks like banging out error handling boilerplate.

                                The virtue of higher level compositional techniques (like monadic errors) is that the error handling code is written once, tested exhaustively, and reused everywhere. A Haskell programmer isn’t at the mercy of arbitrary monad definitions any more than a Go programmer is subject to capricious Reader implementations — >>= with an Either is early exit, just like Read returns a non-nil error if something went wrong.

                                I hear what you’re saying about Go surfacing where errors might occur, and that’s something I also appreciate about it. I just wish it had more options for composition to reduce the risk in handling those errors.

                                puts another quarter in the “Programming Language Wishes Jar”

                                1. 5

                                  All of these things happen explicitly in the code, I don’t need to figure out if an operator means something different or follow a different logic path.

                                  Given the solution described in the post here, how do you not have to do this? A >>= operator can be implemented just as close to the code that uses it as the solution described in this code. In general, though, one does not need to implement >>= because the existing ones do the Right Thing.

                                  unhandled (none of the return values are assigned)

                                  The solution in the article does not require this at all. The write calls could be done and not checked the error value in the end, the error has actually become implicit and easily unhandled. On top of that, not assigning return values does not explicitly mean it was ignored. It could be the API changed from returning nothing to something, so this is not explicit either.

                              1. 87

                                Don’t continue reading if you’re a pussy, 9-year old boy or afraid of little bit “strong” writing.

                                This is like standing at a podium as a huge banner unfurls behind you saying “I AM A JOKE” and a pantless marching band comes out on stage playing a off-key version of Yackety Sax.

                                I definitely do not give a single solitary shit what the author thinks after that.

                                1. 27

                                  There is very little quite so tiresome as the “I’m going to give it to you straight, and by straight I mean with lots of cuss words” sort of truth telling. It so rarely actually has any truths to tell.

                                  1. 6

                                    Skimming the article, the author seemed to have some good points with solid examples, particularly the bit about slice manipulation.

                                    But the writing was so intolerable I quit reading.

                                  2. 15

                                    It looks like he’s removed that line now. But the tone remains that way throughout… Public discourse has standards that are required if you expect to be engaged.

                                    1. 6

                                      Trolling and terrible writing aside, I’d be far more interested in the opinions of people who have been using the language for more than a whole 4 months, and who have actually used it in production.

                                      None of those seem particularly bad to me. In fact, the variable shadowing seems like people getting what they deserve for shadowing a variable in an inner scope like that ;-)

                                      On the other hand, maybe years of C++ has numbed me to it.

                                      1. 3

                                        I’ve been using Go for years, since before 1.0 was released. In side projects (that I count on and use every day, at home and at work). In academic research. And now in production. Several of the things the author mentions are benefits of the language. For example, I love go generate. Others might be reasonably considered warts or footguns, but they are warts that simply haven’t caused many (if any at all) problems for me personally.

                                      2. 3

                                        So, you have no opinion on the technical complaints presented in the article?

                                        1. 32

                                          If somebody announces “Hi, I’m trolling!” I think it’s a reasonable tradeoff to decide you’re not interested in reading the rest of the post to determine if that’s true or not.

                                          I probably could have put up with around half the intro, but at some point I grow tired of reading why I’m not going to like what comes next.

                                          1. 4

                                            That’s typically where the scroll keys come in handy. :)

                                            I’ve noticed (over the last year or two) that people seem to be increasingly reluctant to try and find the good with the bad when it comes to technology posts, often to the point of (as with your GP) proudly proclaiming their impatience. At least the author here had the decency to be up-front, even though the edginess was sorta tiring.

                                            1. 7

                                              Ah, so I don’t ordinarily complain about such things. I’m thankful the author has been so considerate as to tell me not to waste my time. :)

                                              I just don’t have any opinion about the rest, since I didn’t read it, which I only mention since there seemed to be a thread going.

                                              1. 2

                                                Personally, I’m fine with anything in an article besides unwarranted swearing. I don’t enjoy reading it and have a hard time blocking it out.

                                                1. 1

                                                  I’ve noticed (over the last year or two) that people seem to be increasingly reluctant to try and find the good with the bad when it comes to technology posts

                                                  My time is too precious to waste it reading poorly written content. If the ideas have merit they’ll be written up again by better authors.

                                                  I feel like poor language indicates lazy thought, and lazy thinkers often don’t have as deep and interesting insights as they think they do ;)

                                                2. 1

                                                  While that is true, if you do that, you should not leave a comment about how you didn’t read the article and therefore have nothing interesting to say about it.

                                                  1. -3

                                                    If somebody announces “Hi, I’m trolling!” I think it’s a reasonable tradeoff to decide you’re not interested in reading the rest of the post…

                                                    Meanwhile, OpenBSD continues to produce “serious” presentations in Comic Sans, which doesn’t at all scream “Hi, I’m trolling!”

                                                    Pot, Kettle, it’s all the same in this kitchen. Now excuse me as my karma burns away for daring to point out the above hypocrisy.

                                                    1. 8

                                                      No, your karma will burn away for the tired old “I’ll lose karma for this”. It adds nothing to the discussion. Please don’t do it.

                                                      1. 6

                                                        Shrug. I don’t typically use comic sans. Anyway, I think complaints about comic sans say more about the reader than the presenter, where as calling the reader a pussy says more about the author.

                                                        1. 0

                                                          where as calling the reader a pussy says more about the author.

                                                          Nit, he didn’t call the reader a pussy.

                                                        2. 1

                                                          OpenBSD definitely gets justifiable criticism for that, and the pot being black doesn’t make the kettle not black.

                                                          (IMO, while the Comic Sans thing is stupid and unprofessional, the bigger issue is that they typically deliver these things in a complicated binary format for which decoders have already had serious vulnerabilities, which sort of flies in the face of their entire raison d'être of worrying about security first and foremost.)

                                                          1. 2

                                                            Their presentations are either presented as PDFs, which already integrate with screen readers & tools like pdf2text, or are presented as webpages with images - and those presentations have plain text or HTML slides as well:

                                                            (and c'mon, if you (not you specifically but y'all) can’t tell the difference between light ribbing directed at people who believe in form over function and starting your paper with GTFO PUSSIES then, uh.)

                                                            1. 2

                                                              Whenever I’ve seen them linked it’s been a page full'o jpegs, and I’ve certainly never bothered investigating further. Good that that’s not the only format they’re available in; bad that it’s the only one I’ve seen, and still stupid and unprofessional that they format it like a middle schooler in the 90s.

                                                              And yes, I don’t think the two are comparable. To take the pot-and-kettle metaphor way too far, OpenBSD is at worst lightly scorched here. Not perfect, but at least mostly not actively insulting their audience.

                                                      2. 15

                                                        Why the fuck would I wade through the rest of that shit just to find out what the author thinks?

                                                        Opinions about why Go is a poorly designed language are not so valuable or rare that I feel obliged to pick the peanuts out of the poop here.

                                                        1. 3

                                                          Precisely. It’s not like you’re obligated to read every word everywhere, even on a subject you might be interested in.

                                                          1. 2

                                                            “Peanuts out of the poop.” Thanks, that’s my new favorite phrase.

                                                        2. 2

                                                          That’s pretty much a classic Tone Argument… not saying it’s great writing, but maybe look through the writing to the arguments more?

                                                          1. 9

                                                            I’m pretty tone agnostic, actually, so I probably wouldn’t notice or care, except when the author goes out of their way to tell me how bad the tone is. If you know your tone is so bad that you have to warn people about it, but choose not to fix the tone, well… I think you have chosen poorly. It seems to reflect a desire to be more shocking than informative.

                                                            1. 9

                                                              It’s definitely not a tone argument. Me saying your tone is shitty is only a tone argument if I’m also saying that makes you wrong, in the same way that ad hominems aren’t actually just insults.

                                                              1. 3

                                                                I don’t know if that’s strictly true. The typical example of a tone argument is an angry feminist being told “if you were less angry, people would be more receptive to your argument” (as a euphemism for “please make your point in a format I can more easily ignore”) with no reference to its truth value.

                                                                Regardless, this author is (a) not underprivileged relative to the people criticizing his tone, and (b) not justifiably angry anyway, so I don’t see a problem here.

                                                                1. 1

                                                                  You’re saying that the tone he is using is sufficient to invalidate what he is saying. I’m pretty comfortable calling that a Tone Argument.

                                                                  1. 3

                                                                    You’re saying that the tone he is using is sufficient to invalidate what he is saying

                                                                    Pretty sure what the parent was saying is that the tone the author is using, for him as a reader, is sufficient to ignore what the author is saying, without making any claims as to whether the author’s points about Go are correct or not.

                                                                    “This paper is so caked in stinky shit I refuse to read it” is different than “this paper is so caked in stinky shit that whatever is written on it must be wrong”.

                                                                  2. 1

                                                                    Me saying your tone is shitty is only a tone argument if I’m also saying that makes you wrong

                                                                    Eh … isn’t that exactly what you are doing? You don’t like him writing like you usually do, and use that to dismiss everything he has to say.

                                                                    1. 1

                                                                      Do I use gendered slurs? No. No, I don’t.

                                                                      1. 1

                                                                        Dick, pussy and asshole are all slurs. Gender doesn’t come into it (and it’s interesting that you would consider genitalia to be gendered).

                                                                        1. 0

                                                                          Are you trying to imply that if he used an inclusive she/he/they/xir/zhe/… you would have had no trouble reading the article?

                                                                  3. 2

                                                                    I don’t disagree with your point, or desire to point out your wrongness here. I do wish to share that I found it entertaining that you don’t like his tone, but use one like it for most of your own discussion. Again, I’m not criticizing (this is a different medium and you have different goals, for starters of why it doesn’t matter), I just found it causal of some chuckling.

                                                                    1. 3

                                                                      I don’t use gendered slurs, nor do I posture that cursing is some sort of bad-boy bullshit. If you think the author lost me because of his “strong” writing then you’re not paying attention.

                                                                  1. 6

                                                                    “tools like Slack, Hangouts, and GitLab” wow, coming from an ex-GitHub employee that made me do a double-take.

                                                                    1. 5

                                                                      I can understand why he might not want to talk their book anymore. http://zachholman.com/posts/fired/

                                                                    1. 21

                                                                      As Hellerstein wrote in his criminally-underquoted mind-blower of a position paper, “The Declarative Imperative” (2010), “the inherent purpose of time is to seal fate”:

                                                                      In his Refutation, Borges concludes with a very similar inescapable association of time and fate: “And yet, and yet… Denying temporal succession, denying the self, denying the astronomical universe are apparent desperations and secret consolations. Our destiny … is frightful because it is irreversible and iron-clad. Time is the substance I am made of. Time is a river which sweeps me along, but I am the river; it is a tiger which destroys me, but I am the tiger; it is a fire which consumes me, but I am the fire. The world, unfortunately, is real; I, unfortunately, am Borges.”

                                                                      TCP does not lose messages in a timeless world, but asynchronous networks are not timeless; rather, they are worlds lush with clocks. To paraphrase Borges: the timeouts, unfortunately, are real.

                                                                      1. 5

                                                                        As a friend says, all networks are partitioned, it just depends on how long you’re willing to wait.

                                                                      1. 10

                                                                        Direct link to the code: https://www.freebsd.org/internal/code-of-conduct.html

                                                                        ok, so I generally think having a code of conduct is bullshit (oops, sorry, language). You’ve already lost if this is something you need. Attempting to enumerate the badness leads to absurdity, and this crosses the line.

                                                                        I’m on the fringe of the FreeBSD community, but it’s clear now that I can’t join. Sooner or later somebody is going to harass somebody else, and I’m going to ignore it, but then that makes me guilty of “condoning” harassment.

                                                                        1. 21

                                                                          Oh, one more thing I forgot:

                                                                          Attempting to enumerate the badness leads to absurdity,

                                                                          You have two options here: try to enumerate behaviors, or leave it up to interpretation. The first falls under the kind of criticism you’re offering here, and the second leads to an argument about how the rules aren’t written down, and therefore, can’t be applied fairly.

                                                                          1. 2

                                                                            an argument about how the rules aren’t written down, and therefore, can’t be applied fairly.

                                                                            For a company, yeah, this matters. Otherwise, “you’re out because we say you’re out” seems to get the job done pretty well.

                                                                            1. 11

                                                                              Oh, it’s not about the effectiveness, I’ve just seen countless concern trolls play the “but how will I know if I’ve crossed a line unless it’s explicitly spelled out because social norms are totally arbitrary and I just say it like it is” in response to a community attempting to enact a code of conduct before.

                                                                              (I personally am in favor of enumerating broad categories of behavior and leaving it at that.)

                                                                              1. 2

                                                                                Open-source projects often don’t have the strong leadership that would make that happen. E.g. Tony Morris is still upsetting people on #scala (or was when I gave up on it a few weeks ago) where any decent organization or leader would long since have kicked him out, and I think the bungled, unclear code of conduct had a lot to do with that.

                                                                            2. 15

                                                                              I don’t think, for example, that Python has “lost” by having a code of conduct. Pycon has 1/3 female attendance and speakers, in large part due to its code of conduct and many other outreach programmes. What other tech conference has lineups for the women’s bathroom?

                                                                              Being more inclusive is good for everyone, both the people doing the including and the ones being included. You can’t achieve this without actively doing outreach. Just sitting there and waiting for it to happen doesn’t make it happen.

                                                                              1. 5

                                                                                Was it Pycon that had a very public incident that started with one person complaining about a sexist joke (and very explicitly claiming the code-of-conduct supported their complaint) and ended with multiple people losing their jobs? It’s conceivable that in the absence of a code that incident would have been less confrontational and ended less badly.

                                                                                Inclusiveness does benefit everyone, but nothing is completely free. I think codes like this are on balance a good thing (and this is one of the better-written examples IMO: it’s relatively explicit and objective), but let’s not oversell them. Any such thing imposes overhead (especially for people who already have trouble expressing themselves, or who are anxious about participating in a community), and runs the risk of becoming a weapon for the popular or politically astute to attack the weak with.

                                                                                I do support this code. But caution is warranted.

                                                                                1. 13

                                                                                  with multiple people losing their jobs?

                                                                                  It ended with one of the offenders losing their job and finding a new one within a week or two, and the reporter losing their job by having their employer be DDOSed, then not being able to find a new job for over a year due to the stigma, almost putting them on the street. And getting graphic death threats almost continually, still to this day.

                                                                                  1. 5

                                                                                    Ummm, given that Adria was the attacker, I don’t see that as being particularly unreasonable (other than the death threat part). We’re never going to grow as a society if we don’t hold men and women to the same standards.

                                                                                    Additionally, it looks like Adria spent the better part of that year justifying to herself that her actions were right:

                                                                                    “Somebody getting fired is pretty bad,” I said. “I know you didn’t call for him to be fired, but you must have felt pretty bad.”

                                                                                    “Not too bad,” she said. She thought more and shook her head decisively. “He’s a white male. I’m a black Jewish female.

                                                                                    http://www.theguardian.com/technology/2015/feb/21/internet-shaming-lindsey-stone-jon-ronson

                                                                                    1. 6

                                                                                      given that Adria was the attacker,

                                                                                      I don’t agree with this characterization. She reported an event that happened, after that, it was up to the conference to decide what to do here. She didn’t even inaccurately report it, the actual circumstances were never in question.

                                                                                      1. 8

                                                                                        She reported an event that happened

                                                                                        It was a while ago, so my memory may not be the clearest, but as I recall she took a picture of the guy (initially people thought some other guy in the picture was the culprit!), and tweeted it to the whole world along with commentary. The pycon conference staff actually contacted her via twitter after seeing the posting. Seemed like an odd way to report something overheard at a conference to staff.

                                                                                        Making a dongle/dick joke at a conference is very inappropriate. No disagreement there. The “let’s make an example out of this guy” response seemed rather outsized.

                                                                                        In addition, maybe instead of just firing him, his employer could have sent the guy to some type of sensitivity training so he actually learned something other than the likelihood that he just picked up some new prejudice like “it is not safe to have women in your team – you might get fired” or “don’t ever go to conferences”. I consider companies generally pretty heartless though, so it wasn’t surprising that he was simply fired – arguably the fastest way to distance themselves from the issue entirely.

                                                                                        1. 9

                                                                                          The exact text of the tweet:

                                                                                          Not cool. Jokes about forking repo’s in a sexual way and “big” dongles. Right behind me #pycon

                                                                                          Yes, one could argue that she could have reported it in private instead of in public, but especially tagging it with #pycon, to me, is reporting. The entirety of the ‘commentary’ is “Not cool.”

                                                                                          1. 2

                                                                                            Thanks for finding the tweet text!

                                                                                        2. 8

                                                                                          Seriously, “the attacker”? And earlier “a very public incident that started with one person complaining about a sexist joke”? The complaint about the issue is undoubtedly the problem. Nah, it started with the snickering innuendo. Too often this site feels like browsing HN Jr.

                                                                                    2. 5

                                                                                      Yeah, donglegate. Not sure I would say that this would have never happened if there wasn’t a code of conduct. In fact, it may not have happened in a vacuous way: without a code conduct, there would not have been 20% female participation which would have made it much less likely for any women to overhear. Without any women, there are no women who will voice complaints. :-)

                                                                                      I really don’t think there is an overt benefit to not having a code of conduct. The only one I can see is if you want to keep your community insular and unwelcoming. Like everything else in human society, as long as there’s more than a few of us, we need rules to guide us.

                                                                                  2. 16

                                                                                    You’ve already lost if this is something you need.

                                                                                    This is why Rust is a moribund language tended to by a community of lifeless, gray dullards devoid of insight or imagination, plodding along the same worn paths trodden by the endless parade of sightless generations before them. All this misery could have been avoided had they but known the risk their code of conduct posed to their ability to say fuckwords in public lo those many years ago.

                                                                                    1. 13

                                                                                      Python, too, succumbed to this same problem and lo their language was lost to the howling winds of time. We can also expect Go to burst into flames or something RSN.

                                                                                      waves hands and makes ghost noises

                                                                                      1. 6

                                                                                        I done been snarked!

                                                                                        1. 3

                                                                                          I code in C. I’m expected to curse… profusely, at that.

                                                                                        2. 21

                                                                                          (oops, sorry, language)

                                                                                          Most codes of conduct don’t include curse words, as being puritans is not the aim of a code of conduct.

                                                                                          You’ve already lost if this is something you need.

                                                                                          Codes of conduct are largely written plans to set expectations and make the process clear for when something doesn’t go according to plan. “you’ve already lost” is beside the point.

                                                                                          Any reasonable ops team has a plan for what to do in the case of system failure. Codes of conduct are no different.

                                                                                          1. 6

                                                                                            Most codes of conduct don’t include curse words, as being puritans is not the aim of a code of conduct.

                                                                                            The problem with this is that, as written, the code of conduct kinda does:

                                                                                            • Avoid foul or abusive language: remember that cultural standards differ, and that what may seem to you to be a very mild statement can be deeply shocking to another.

                                                                                            The core issue is that, I think, as developers and engineers we tend to read things rather literally, and any code of conduct read in such a way seems rather harsh and draconian.

                                                                                            And the natural response is “Well, that’s what it says, sure, but that’s just level-setting and a general zeitgeist…we’re not going to go after you for cursing/whatever”, and that basically illustrates to the person raising the concern the arbitrariness built into the enforcement of these things.

                                                                                            It’s not that they’re bad (hell, they’re arguably better than nothing)–it’s just totally unsurprising that many don’t sing their praises.

                                                                                            1. 9

                                                                                              Yeah, it’s true that this one does. I was responding more generally. Rust’s actually does too, with an explicit caveat:

                                                                                              (Cursing is allowed, but never targeting another user, and never in a hateful manner.)

                                                                                              And

                                                                                              that basically illustrates to the person raising the concern the arbitrariness built into the enforcement of these things

                                                                                              Software developers do tend to see many social boundaries as ‘arbitrary’, but that doesn’t mean they actually are.

                                                                                              1. 2

                                                                                                What are some examples of non-arbitrary social boundaries?

                                                                                                1. 6

                                                                                                  Basically all of them. Social boundaries come out of some kind of need for a community, you can call them ‘arbitrary’ in response to some sort of platonic ideal, what-if-society-was-totally-different, but that’s more thought experiment and not something that’s actually useful when interfacing with other humans or understanding the real world.

                                                                                                  That doesn’t mean they’re immutable, or are all good boundaries, but with that definition of arbitrary, basically everything is arbitrary.

                                                                                          2. 11

                                                                                            I really shouldn’t fan the flames (these are always incendiary topics) but you can’t make everyone happy. All of the words used there (harassment, hate speech etc) are relative, regardless of what people believe.

                                                                                            To give an example, suppose a person comes on and during the course of a conversation expresses the view that homosexuality is an aberration and is illegal. The person is banned. The person then in turn claims harassment + discrimination because in their nation/culture/religion this is the commonly held view.

                                                                                            Now, I’ll shut up, because I came here to learn about computation.

                                                                                            1. 3

                                                                                              In “almost all” cases, general good will, cultural norms, and good manners covers relations between people in a group.

                                                                                              Obviously, there are special cases where arbitration is needed and this is the purpose of a code of conduct - to formalize what happens when normal (polite) interactions break down.

                                                                                              Often, the formation of a code of conduct is challenging because it gives rise to unspoken and unaired differences between members of the group. For example: what if one leading member supports an aggressive, hardball management style that involves profanity, public call-outs, and insults, while another leading member supports a gentle management style that focuses on one-on-one interactions and words of encouragement? (In the first case, I’m thinking of some of the famous public arguments about the Linux kernel.) Making one or the other style “formal” in a code of conduct means that one leader “wins” the debate over group culture, while the other one “loses”.

                                                                                              1. 5

                                                                                                So, most of that scans pretty decently–a little “no fun allowed” in terms of speech, sure, but if we can’t not sweat and curse and whatnot during a project, we lack creativity in expressing our displeasure.

                                                                                                The only part I disagree with:

                                                                                                • Discrimination based on gender, race, nationality, sexuality, religion, age or physical disability.
                                                                                                • Bullying or systematic harrassment.
                                                                                                • Incitement to or condoning of any of these.

                                                                                                …which is totally, reasonable on the face off it, especially the latter two. However, that links with:

                                                                                                “We will not tolerate any member of the community, either publically or privately giving aid or encouragement to any third party to behave in such a way towards any members of the FreeBSD community.”

                                                                                                If it’s truly a meritocracy, it shouldn’t matter if a contributor is a bigoted shithead on their own time. This linkage, for example, is technically what would’ve been used to censure, say, Eich.

                                                                                                1. 15

                                                                                                  If it’s truly a meritocracy, it shouldn’t matter if a contributor is a bigoted shithead on their own time.

                                                                                                  Only if you don’t include ‘works well with others’ as merit. I know I personally do.

                                                                                                  One might say this brings up the ‘arbitrariness’ of the concept of meritocracy in the first place…

                                                                                                  1. 1

                                                                                                    “works well with others” is an interesting wagon to hitch to.

                                                                                                    It opens the unfortunate can of worms of whether or not minority members who constantly fight the status quo and make noise are “working well with others”. Especially when they, say, derail Github issues with agendas orthogonal to code problems.

                                                                                                    I’m not sure that bandying about fitting in is what we want to do here.

                                                                                                    1. 9

                                                                                                      You seem to be conflating “works well with others” for “has a boundless appetite for bullshit”. Can we add that to the list of things we don’t want to do here?

                                                                                                      1. 2

                                                                                                        You may think of it as derailing (and it’s not an entirely false or unreasonable opinion), but for every communication channel there should be a place to discuss issues with communication, and in cases of social issues it often makes sense to use the very same channel for that (just because all the participants are already present). E.g., if some aspect of your team’s weekly meetings renders these meetings ineffetive or intolerable, by all means bring it up during one of these meetings.

                                                                                                        1. -2

                                                                                                          To put it explicitly (and odiously, mind you):

                                                                                                          If the argument is “works well with others is something of merit”, then any minority who fails to shut up and fall in line with the others is, by definition, not worthy of merit. This means putting up with homophobic remarks, because that’s what the majority of the workplace does. This means putting up with sexism, because that’s what the majority of the workplace does. This means not commenting/arguing/fighting-back against all of the microaggressions, because doing so puts you at odds with all the others.

                                                                                                          That is the full ramification of “gets along well with others”.

                                                                                                          1. 7

                                                                                                            Likewise, every majority (is this the right word?) that issues racist/homophobic/misogynistic remarks is, by definition, not worthy of merit, because such remarks alienate current and potential employees and clients. Not only minorities, mind you — I feel uneasy interacting with chauvinists no matter where their hate is directed. And we haven’t mentioned wide-scale long-term effects of such attitudes being popular.

                                                                                                            I really fail to imagine what kind of merit would override the fault of being a complete asshole.

                                                                                                            This means putting up with homophobic remarks, because that’s what the majority of the workplace does. This means putting up with sexism, because that’s what the majority of the workplace does.

                                                                                                            I’m sorry you had such a bad workplace experience. I hope it’s not typical where you live; where I live it’s surely unusual.

                                                                                                            This means not commenting/arguing/fighting-back against all of the microaggressions, because doing so puts you at odds with all the others.

                                                                                                            Oh, I’m not saying one should complain about every little annoyance, but there’s a not-so-fine line between calling your colleague an idiot once in anger, and doing it constantly due to lack of respect towards (a subset of) others.

                                                                                                            Look… I find that people who like to use words such as “rationality” and “meritocracy” tend to ignore human feelings, which makes them less rational and meritocratic than they think they are, because feelings exist and have consequences in the real world. Working with sexists and homophobes is not nice. Even working in white-male-only environment is not as nice as in mixed one, I find. Not being able to hire minorities (and people like me, who don’t hate minorities but do hate nazis) matters, because you lose a percentage of potential employees, and perhaps clients as well. Do you really think banning sexism and racism would do more harm than alienating the aforementioned minorities?

                                                                                                    2. 10

                                                                                                      If it’s truly a meritocracy

                                                                                                      Being a meritocracy is not in itself a good thing. I know how we nerds want to pretend that we humans are all beings of pure intellect and all that matters is your code. While well-intentioned, this attitude can end up causing harm by deliberately ignoring all of the extenuating non-intellectual factors that people have to contend with (try to read that link, despite its length).

                                                                                                      Sure, we’re all beings of pure intellect, but some of us are female, which is a very rare trait in this tribe but common elsewhere, so this tribe ends up treating us differently or we perceive ourselves as being different from this tribe, despite its claims of equality.

                                                                                                      The meritocracy attitude is a bit like “separate but equal” was in the southern USA of the 1950’s. While apparently well-intentioned and seeking to give everyone equal treatment, it attempts to silence a lot of other important cultural factors, which results in non-equality.

                                                                                                      1. 3

                                                                                                        Meritocracy is like a platonic ideal - it’s a point that most people want to get to; however, since people have different starting points, it’s impossible to realize in reality. The “merit” being measured is on one axis or a small number of axes, which generally need to be the ones that are most aligned with successful outcomes in projects.

                                                                                                        The bigger picture of meritocracy, society-wide, is a fundamentally different question, and one that most open-source projects (and most for-profit companies, for that matter) are generally unequipped to handle. Most projects just want skilled and dedicated contributors (i.e. contributors with particular “merits”) and beggars can’t be choosers.

                                                                                                        1. 7

                                                                                                          By the way, did you know that the word was coined in the 1950’s in a satirical essay where a meritocratic society was a dystopia? :-)

                                                                                                          1. 3

                                                                                                            I think I heard that somewhere. Funny that it was considered something bad back then.

                                                                                                            The sense I get from the usage of the word nowadays, is that it’s broadly considered a good thing among idealistic engineers and technical people: of course we should judge people only on their merit (e.g. the performance of their code), not on political considerations, or nepotism, or who went to school with whom.

                                                                                                            Of course, since it’s people we’re talking about, things rarely get implemented as purely as the idealistic engineer believes or hopes.

                                                                                                    3. 2

                                                                                                      Sooner or later somebody is going to harass somebody else, and I’m going to ignore it, but then that makes me guilty of “condoning” harassment.

                                                                                                      this is pure slippery-slope-fallacy. do you seriously think that someone is going to come after you for simply passively ignoring something?

                                                                                                      1. 1

                                                                                                        I think it should be possible for me to comply with not just the spirit, but also the letter, of a well written code of conduct. I’m not comfortable with the idea that the written rule says something is prohibited, but then there’s an unwritten rule that says minor infractions will probably go unnoticed.

                                                                                                        1. 2

                                                                                                          why, though? given that a code of conduct is run by people, rather than by computers, do you honestly feel that being subscribed to a mailing list in which someone is being harassed, and doing nothing either way, is going to be interpreted as against the letter of the code? it’s fine to apply a common-sense approach to these things, rather than going the heavyhanded legal-jargon, dot-every-i route.

                                                                                                          1. 1

                                                                                                            Surely that’s the whole point of the code. If we’re just relying on people to follow sensible judgement, why have a written code at all?

                                                                                                            1. 2

                                                                                                              there are two different things here:

                                                                                                              1. the specifics of the code of conduct. sure, it usually boils down to “don’t be a dick”, but what is considered dickish behaviour varies from community to community, and a good set of guidelines can help establish a culture by indicating what is and isn’t considered acceptable

                                                                                                              2. the interpretation of the written form of the code. this is where some people really want to quibble about words and phrasing and how they can be interpreted and how close you can skate to the line without crossing it. but really, it comes down to common sense; a CoC is not a game that you’re trying to play, where it’s crucially important to drag out the rulebook and argue each point and whether the exact language supports you or the other person. most of these things are pretty easy to apply a reasonable interpretation to, and the people trying to game it are usually the people you don’t want around anyway, because they don’t really care about not being dicks.

                                                                                                              to take the example tedu cited, he focused on the word “condoning”, and wondered whether simply sitting silently on a mailing list where harassment was taking place would technically be condoning said harassment, and whether he’d be expelled from the community for doing so. but a more reasonable interpretation would be that it applies to people managing spaces or events, and who would be expected to make sure their spaces are harassment free by taking note of and stopping it when it starts. if you simply assume that the CoC writers are trying to foster a good community rather than playing legal games, it’s pretty easy to follow it.

                                                                                                      2. 2

                                                                                                        I think ethics are really important. Codes of Conduct are one way of expressing your ethics.

                                                                                                        Attempting to enumerate the badness leads to absurdity

                                                                                                        Which is currently demonstrated by the British Governments approach to Encryption - “it is allowing the baddies to communicate securely” - this badness must be banned!

                                                                                                        Condoning behaviour by ignoring it is not necessarily true - ask any parent who has had to negotiate with a two year old, sometimes ignoring a behaviour is the correct approach - but not when you are an officer in a military prison and your soldiers are abusing your prisoners.

                                                                                                        Ethics are never black or white, but they might be right or wrong :~)

                                                                                                        1. 1

                                                                                                          Sooner or later somebody is going to harass somebody else, and I’m going to ignore it, but then that makes me guilty of “condoning” harassment.

                                                                                                          This is interestingly put. Why the quotes? Isn’t that exactly what condoning means?

                                                                                                          1. 1

                                                                                                            Quoted to point out its taken directly from the code.

                                                                                                        1. 6

                                                                                                          MongoDB.

                                                                                                          1. 3

                                                                                                            Hey Coda I understand it doesn’t have a great reputation, but I’m not too familiar with it. What about mongo specifically would make a queue have really awful performance/affect more than that table specifically? Do you have any idea whether mongo was the reason they couldn’t just drop queued builds on the floor?

                                                                                                          1. 3

                                                                                                            Not to hate on her, but does she think generalizing and ranting about it is the right solution?

                                                                                                            By blaming “the industry” for something some trolls have done to her, she’s effectively doing their game and inciting them to strike again.

                                                                                                            Or do you really think people go “I’ve been jerking off to your conference videos” to her thinking it’s a genuine compliment?

                                                                                                            About the other comments in this thread (I’d reply to each single of them but it would end up being the same message so what’s the point):

                                                                                                            If you want to talk about this, I think you can find all the people you want, I just think that you should try to avoid saying “men” when referring to people doing death threats, rape jokes etc. Don’t think people want to avoid this stuff because they’re misogynist or anything, it’s because it’s so incredibly annoying to be attacked and pointed at just because we share the same gender as some guys that are a complete jerks to women.

                                                                                                            Also don’t think we enjoy rape jokes because they put us in a position of power or something, sometimes we might just find them funny, just like any sort of racist/black humor, and I’m definitely not saying that since they’re funny they have to be shouted in every single inch of the planet.

                                                                                                            If you can find the courage to explain to me why I am so wrong with all I’ve said with a reply instead of silently downvoting my post, I’d be really really glad and I’ll promise that I will look at it seriously and try to respond to the best of my abilities (and then downvote anyway! Die Hamcha! DIE DIE DIE!!).

                                                                                                              1. 4

                                                                                                                3 quick links straight to the point, I like you already!

                                                                                                                I agree with the first one, at least in part. The points that that one link give (at least from what I understood) are something around “You have to moderate rather than ignore”, which is very true indeed. You can just let people say crap on anybody or you’ll end up with a toxic culture in no time.

                                                                                                                This time though we’re talking about private emails and the like. If you want to reply to a troll and “teach him a lesson” or whatever, I can’t figure out why a personal blog would be an appropriate place for that (one with no possibility of having a conversation, even!).

                                                                                                                I really love Nicole Sullivan’s talk on the matter of trolls, as she goes to analyze more how she deals with them and why some of them act a certain way.

                                                                                                                The “not all men” is just plain wrong. While I agree that it can be used an excuse to try to go away from a discussion, it also does point out that you are just attacking a whole category of people based on a couple individuals and some people will get angry at you for doing it.

                                                                                                                That’s true of pretty much every stereotype, just like not all women are bad at driving, not all asians are godlike at math and stuff.

                                                                                                                Very often I’ve seen rants that are like “All men are X”, which is really just the simplest type of association fallacy at work, I can’t really think why “not all men” wouldn’t be an appropriate answer to a fallacious statement (usually made in anger and stress, so it’s probably not even made in ill will)

                                                                                                                Last item on the list, I already said that in my opinion I don’t see anything incredibly harmful about politically incorrect jokes, as long as it’s between people that are all ok with that and know that it’s just for humor. If I made one and someone would interrupt me saying it hurt them, I would definitely be embarassed and be asking for forgiveness. I make jokes to see people laugh, not to hurt anyone, if that involves hurting it’s not really worth it.

                                                                                                                I’m not saying they’re not a weapon, though. People that use them to shame people are monsters and I will never deny it, I just think they shouldn’t be completely banned from all places.

                                                                                                              2. 6

                                                                                                                it’s because it’s so incredibly annoying to be attacked and pointed at just because we share the same gender as some guys that are a complete jerks to women.

                                                                                                                The following Cracked article comes to mind. Please try to read it:

                                                                                                                http://www.cracked.com/blog/5-helpful-answers-to-societys-most-uncomfortable-questions/

                                                                                                                Yes, maybe you didn’t start the fire, but you have to understand that the world is burning regardless. It’s not that you’re being blamed, and feeling guilty about the fire that members of your group has started is absolutely pointless. It’s that the fucking fire is burning, and you have to recognise that it is also your job as it is mine to do something about this fire.

                                                                                                                Fix the problem, not the blame. We have to all do this together.

                                                                                                                1. 4

                                                                                                                  Ohai! Sorry for replying to codahale first, but your link was long and I made a promise to read it and give a detailed answer!

                                                                                                                  The article is very nice and I understand that yes, indeed I have white privilege and if I have such ease in finding a job it’s also due to the fact that my family doesn’t come from a bunch of slaves and nobody here thinks I might steal their wallet (which I still think it’s the stupidest thing ever considering good thieves try to look as professional and trustworthy as possible, but hey, humans and their stuff).

                                                                                                                  I do understand the concept of privilege, and I understand that I’m very lucky to be born white, cis, male and everything, and it’s incredibly difficult being a woman, especially in male-dominated fields such as IT or gaming.

                                                                                                                  But I still think that aiming your finger at an incredibly big thing is just pointless. It’s just like if someone from a community attacked me personally and I’d take against the whole community.

                                                                                                                  I understand that my gender has been oppressive toward women, but today the general image is that doing that is no more a good thing (at least in my culture, my country, my workplace etc etc) but when I try to express my viewpoint about the whole thing I just get bullied by all these extreme feminists. I’ve already been banned from a place I really liked for not defending a women I thought didn’t deserve being defended (because being a woman doesn’t mean you can never be wrong).
                                                                                                                  Hope you’re not taking these words too literally/seriously, I really know a ban is really nothing opposed to a continuing campaign of harassment in every media.

                                                                                                                  Still, I don’t think feminism is cancer, I just think some feminists are wrong about how they approach things. And here I am trying to have a conversation with you people instead of just pointing my finger and blaming feminism for being forced away from a place I liked or stopping to interact with people I loved to talk with.

                                                                                                                  I know the whole “not all men” is a cliché nowadays, but my hope is that you people can understand that it’s really hard for me (and others, I suppose?) to get into a conversation about gender equality and stuff when all I see is “man, these men will never understand and will never want to talk about this” or even worse when I get told “you are a man and cannot understand”. It feels like you don’t even want men to get into a conversation, but just dismiss and blame them since it’s the easiest solution.

                                                                                                                  And really, it goes for other men just as much as women.

                                                                                                                  1. 4

                                                                                                                    But I still think that aiming your finger at an incredibly big thing is just pointless.

                                                                                                                    Of course it is. When you hear people say, “people from your group have been really awful to me,” your response shouldn’t be “I didn’t do it!” It should be something like, “crap, that sucks, I’m sorry this happened to you. How can I help?”

                                                                                                                    Unless they really are complaining directly about you, don’t make the complaint about you again. Make it about them.

                                                                                                                    And if they really are complaining directly about you, then see if you need to correct your behaviour.

                                                                                                                    1. 4

                                                                                                                      Yeah, I actually do understand how the aggressive stance comes off. Fundamentally it errs on the aggressive side because erring on the polite side hasn’t worked and can never work, but, yes, it does hinder conversation in some cases. I actually err on the side of saying nothing in public spaces, because I’m not comfortable being part of that and wouldn’t be psychologically capable of handling the response it would get.

                                                                                                                      Unfortunately there’s an extremely high rate of, call it spam or DDoS traffic, masquerading as polite attempts to initiate conversation, and dealing with too much of it reduces everyone’s capacity to take the time to do a more accurate filter by reading things carefully. Having read your words, I find them thoughtful and not in that category. Honestly, mostly because of the first sentence and the second-last paragraph. Most of the rest is pretty easily parroted, so just whether someone says it isn’t a useful signal for guessing intent… hopefully that explains the problem a bit. :/

                                                                                                                      It seems as though you have enough of a grasp of the issues to understand that when criticism isn’t true of you, you should try not to feel hurt by it. I know that can be difficult, and no, that’s not sarcasm.

                                                                                                                      I do second JordiGH’s response, especially the “how can I help?” thing. There’s a large number of easily-found resources about this stuff, and Google is right there; people shouldn’t really need interactive guidance when figuring out what to do to help a marginalized group is their goal. (It seems like conversations on lobste.rs are mostly about feminist issues, but this part is very true for all marginalized groups.)

                                                                                                                1. 8

                                                                                                                  we had 200 API servers running on m1.xlarge instance types with 24 unicorn workers per instance. This was to serve 3000 requests per second

                                                                                                                  This is what blew my mind.

                                                                                                                  1. 9

                                                                                                                    Well, yeah.

                                                                                                                    Given Little’s Law (L = λW), we can model this.

                                                                                                                    λ is the arrival rate (3000 req/sec), W is the average duration (which we can estimate at 1 seconds), and L is the average number of requests in-flight at any point in time, which is 3000. 200 instances running 24 workers each is 4800 workers total, so they’re running at ~65% capacity, which seems reasonable.

                                                                                                                    This is what happens when your scalability model is per-process but your processes are two or three orders of magnitude larger than a POSIX thread.

                                                                                                                    1. 2

                                                                                                                      An average response time of 1 second seems way too long, but I don’t know anything about Parse. Most Rails apps should be south of 300ms at least. Github and Shopify hover between 50 and 100ms.

                                                                                                                      1. 2

                                                                                                                        Seems, yes. Should, yes.

                                                                                                                        Is? Probably not.

                                                                                                                    2. 2

                                                                                                                      Extrapolating from one of my higher-traffic apps that gets 60 requests per second, 200 servers sounds about right. FWIW We’re using 4 c3.large instances with 4 workers each, so I’d guess their traffic patterns are quite different - it’s definitely a different problem domain.

                                                                                                                      I absolutely agree that a process per request model breaks down, and it does sound to me like moving beyond ruby made sense for their case. That’s the sort of problem that is great to have, honestly. This was a neat case study to read.

                                                                                                                    1. 4

                                                                                                                      I’m puzzled why he didn’t talk much about in-process-style microservices. If you know you have some discrete modules but don’t need to separate them by process/machine then you get the benefits of decoupling without deployment issues.

                                                                                                                      1. 5

                                                                                                                        What’s the difference between “in-process microservices” and “regular old modular code?”

                                                                                                                        1. 33

                                                                                                                          It’s a lot easier to get a conference talk proposal accepted about the former than the latter.

                                                                                                                          1. 3

                                                                                                                            None. Sorry, I’m mobile and didn’t make that clear.

                                                                                                                        1. 6

                                                                                                                          The answer is never. If you need a generator-like function, you give the generator-like function a callback to call on all the iterables (that can return if it’s done or what not, for break-like behavior).

                                                                                                                          Callbacks are always more general. The go developers realized this and were sad about it. I wonder if I can find the mailing list thread when I’m not on my phone, but check out os.Walk in the stdlib.

                                                                                                                          That’s the right way. Trying to shoehorn channels here so you can use range is a hack. Someday I’ll write a blog post about how having to spin up a goroutine to service the side of a channel - just so you can use a channel when you could implement it without the goroutine or channel at all - is a huge anti-pattern

                                                                                                                          EDIT: can’t find the thread, maybe it was the old Go wiki comments? I’ve looked everywhere, can’t find it.

                                                                                                                          1. 8

                                                                                                                            Or model it as an iterator:

                                                                                                                            for s.Scan() {
                                                                                                                                fmt.Println(s.Text())
                                                                                                                            }
                                                                                                                            
                                                                                                                            1. 1

                                                                                                                              yep, another great model. a bit more boilerplate (create the iterator type if you want to support more than one concurrent iteration) but probably the most flexible and easy to use as a user

                                                                                                                              1. 2

                                                                                                                                The primary advantage is that you leave control up to the caller. For callbacks I generally allow a boolean or error return value, so that the callback function can signal that the iteration should be interrupted. However, it seems that some libraries use callbacks without a way to stop iteration (except for panic()).

                                                                                                                            2. 4

                                                                                                                              I think it is worth pointing out explicitly that when you use the Go pattern discussed here you can’t use break to get out of the loop. If you do, the goroutine will not be garbage collected.

                                                                                                                              1. 1

                                                                                                                                Indeed. You have to close the input reader if you want to cancel early. Python generators have the same issue, which is why you can throw an exception into a generator from the outside.

                                                                                                                                1. 1

                                                                                                                                  No, Python generators do not have the same problem. If they did, then this interactive session would be leaking memory like crazy, and instead its memory usage remains stable at 8 megs (3.6 resident) for the minute-plus I could be bothered to wait:

                                                                                                                                  $ python
                                                                                                                                  Python 2.7.3 (default, Mar 14 2014, 11:57:14) 
                                                                                                                                  [GCC 4.7.2] on linux2
                                                                                                                                  Type "help", "copyright", "credits" or "license" for more information.
                                                                                                                                  >>> def x():
                                                                                                                                  ...  yield 1
                                                                                                                                  ...  yield 2
                                                                                                                                  ... 
                                                                                                                                  >>> while True:
                                                                                                                                  ...  for y in x():
                                                                                                                                  ...   break
                                                                                                                                  ... 
                                                                                                                                  
                                                                                                                                  1. 1

                                                                                                                                    See the old PEP 325 (from 2003), “Resource-Release Support for Generators”, for what I’m talking about.

                                                                                                                                    1. 1

                                                                                                                                      That was fixed ten years ago in Python 2.5 with PEP 342, but stalled generators didn’t result in leaking memory in Python the way blocked goroutines do in Golang even before that. It’s just that, until then, finally blocks in generators were not reliable. That’s what PEP 325 and the part of PEP 342 that supplanted it were designed to fix. PEP 342 is the PEP that introduced the .throw method you refer to upthread.

                                                                                                                                      But Python has never, not even in 2003, suffered from the problem Golang apparently does.

                                                                                                                                      I haven’t done enough in Golang to know why Golang would have this problem; you’d think that it would be safe to garbage-collect a process that’s blocked on a channel that nothing else has a reference to. I guess you could argue that the orphaned goroutine has nobody to report any possible errors to, but that’s already the case!

                                                                                                                                      1. 1

                                                                                                                                        Yes, PEP 342 helps with throw. What I’m trying to say that finally blocks in generators still aren’t reliable unless you’re careful enough to fully exhaust the generator or throw() an exception into it. It’s similar to how you can force close the input reader to cause a goroutine to exit, in this example.

                                                                                                                                        1. 1

                                                                                                                                          Even that’s not true. As PEP 342 explains, you can also .close() the generator, which is equivalent to .throw()ing a GeneratorExit into it, and the .__del__() finalizer implicitly invokes .close(), so the only way that a finally or __exit__ can fail to run in a generator is if the generator never gets finalized — if the machine loses power, for example, or you kill -9 the process, or (I think) if the generator is part of a reference cycle.

                                                                                                                                          1. 1

                                                                                                                                            That’s a great point. The case I’m worried about is the last one (reference cycle or never garbage collected). Like you said, it would be great if Go had a way to do similar garbage collection by terminating a goroutine that’s not needed.

                                                                                                                                            1. 1

                                                                                                                                              While this is in theory a problem, I’ve never seen it, for these reasons:

                                                                                                                                              1. Most of my generators (I use a lot of generators) don’t have with or finally clauses, because they don’t have side effects that they need to undo.
                                                                                                                                              2. I do exhaust most of my generators.
                                                                                                                                              3. I very rarely have circular references in my generators, and indeed I usually try to avoid circular references in general.
                                                                                                                              2. 3

                                                                                                                                Yep, I’ve been disillusioned by channels and iterators/generators are one of those subtle problems. If you’re not careful, you end up leaking. I’ve found the iterator pattern as coda suggests a much saner approach.

                                                                                                                                Couldn’t have it put better myself @jtolds!

                                                                                                                                1. 3

                                                                                                                                  I posted this comment on the article but I’ll reproduce it here:

                                                                                                                                  I think “never” is bad advice. The comments in the Reddit thread do a good job of covering the pros and cons of this approach. It’s a set of tradeoffs that depends on what you’re doing, like everything in programming. Sometimes a goroutine/channel is a good fit, sometimes it’s not.

                                                                                                                                  1. 1

                                                                                                                                    Not to be persistent here, but do you understand my point in my reply to your comment on the article about how a callback interface is always more general? Trivially, you can use a callback-based interface to implement a channel-based one. Just use the callback to send on a channel.

                                                                                                                                    I agree “never” is bad advice, but that said 2 will never be greater than 3.

                                                                                                                                    1. 1

                                                                                                                                      Isn’t that reversible? If you have a channel, just call the callback with everything that comes out of it.

                                                                                                                                      1. 1

                                                                                                                                        Nope, not reversible. Channels add some unfortunate requirements.

                                                                                                                                        1) Channels requires a goroutine servicing the channel, which isn’t trivial overhead unfortunately. This matters most when your API is being called heavily in hotpaths, and it’s frustrating when you’re trying to use an API that creates this overhead for you so you have to do something else.

                                                                                                                                        2) Callbacks as discussed in a different thread above make it so you can break out of the iteration, but if it’s a channel you can’t throw a signal back to the generator that it’s time to stop generating. If you stop reading off the channel, unless you have a large enough buffer the producer will block and fail to die, causing resource leaks.

                                                                                                                                1. 4

                                                                                                                                  Note that chacha20+poly1305 is slower than AES-NI + CLMUL-accelerated GCM on Intel chips…

                                                                                                                                  Don’t get me wrong, I love djb, but I’m not sure this is the wisest default, especially if you find yourself scping large files around frequently.

                                                                                                                                  1. 1

                                                                                                                                    IME chacha20+poly1305 is the fastest of the default 6.8 ciphers on non-AES (i.e old, or embedded) hardware. Of course, choosing a different cipher on the command line is trivial, and adding more to the server config for internal use (arcfour128) is also pretty easy.

                                                                                                                                    1. 1

                                                                                                                                      AES-NI and CLMULM have been in Intel chips since ~2010 (Westmere) and AMD chips since ~2011 (Bulldozer). For server software, at least, they’re nearly ubiquitous.

                                                                                                                                      1. 3

                                                                                                                                        Unless your servers are virtualized and don’t have AES-NI exposed, which until recently was all of AWS.

                                                                                                                                        1. 1

                                                                                                                                          Well, using older chips is normal, but you can’t use older AWS; it’s not available. At the moment, all of AWS supports AES-NI.

                                                                                                                                  1. 15

                                                                                                                                    This was true back when I was a Ruby programmer. It’s true now. I don’t know that exhortations to do better at software are going to change much for folks.

                                                                                                                                    1. 9

                                                                                                                                      Also sort of-not-quite-but-basically ex-Rubyist chiming in. Same. A bunch of us tried for a few years, you couldn’t go to a conference without hearing some talk on how your architecture was bad. Hasn’t seemed to change much…

                                                                                                                                      1. 3

                                                                                                                                        another mostly-ex-rubyist chiming in - the talks on how everyone’s architecture was bad were inspiring and all, but how many people started projects to do it right? say what you will about rails’s muddling of concerns, but there was a large community contributing code to it. there was (is?) essentially no leadership or community around the attempt to demonstrate a lot of one-thing-well libraries integrated nicely into a cohesive whole, even though the libraries themselves certainly existed.

                                                                                                                                        1. 13

                                                                                                                                          Well, there was an interesting bit of coevolution there.

                                                                                                                                          Rails’s quick time-to-market made it a really great fit for consultants, who appreciated that the integration was already done and weren’t really ever paid to care about how a codebase aged with time. So they started using it, and it began to sprout even more tightly-coupled features which made it amazing to get off the ground with but hampered its ability to remain tractable as the codebase aged and increased in size and complexity.

                                                                                                                                          I remember being at a RailsConf where the new feature everyone was excited about were the project generators, which would allow you to build project templates so you could pre-integrate all your favorite libraries and then just bang out a bunch of cookie-cutter projects for each gig you were working. At the time I was trying to figure out what to do with a three-year-old Rails codebase and hadn’t created a new Rails project in about three years. I realized I was surrounded with smart, focused people who had totally different jobs, and that I needed to find some tools which were better equipped to solve the problems I had.

                                                                                                                                          1. 3

                                                                                                                                            For as much as I agree with the comment above, it’s fascinating to me that the benevolent dictator* of Rails is a company supporting a single product with an 11 year old code base. My sense is just slightly more subtle: Rails has a great out of the box experience, and works well for Basecamp’s long-lived code base, but not as well for other people’s long-lived code bases.

                                                                                                                                            It would be interesting to know if this contributed to Basecamp’s decision to sell the rest of 37 Signals, though!

                                                                                                                                            * At least one member of the “Rails core team” didn’t know about Action Cable until David’s RailsConf keynote. So I think it’s fair to say David / Basecamp are driving, even though the “core team” is larger.

                                                                                                                                            1. 1

                                                                                                                                              Basecamp (né 37signals) shifted from being a web design/app consultancy to being more of a product company around the same time they open-sourced Rails. As far as Rails Core goes, 7 of them are currently working for consultancies (Koz, José, Santiago, Xavier, Rafael, Andrew, Godfrey), and 6 are working for product companies (DHH, Jeremy, Aaron, Guillermo, Carlos, Yves).

                                                                                                                                          2. 4

                                                                                                                                            Oh totally, agreed.

                                                                                                                                            1. 3

                                                                                                                                              I guess this is to @zem, @steveklabnik, and @codahale: could you point to examples of folks succeeding at leading/demonstrating how to improve the everyday practice of a language? I’m asking because I’m taking a run at this in Ruby (griping at my coworkers is just no longer enough) and it’d be nice to have folks to learn from.

                                                                                                                                              1. 3

                                                                                                                                                i’m a fan of what jane street has done in their “core” library (an alternative stdlib for ocaml). there has been a lot of thought put into consistency and coherence, complete with blog posts outlining some of their thinking and experiences. recently, they’ve been working on pulling out a minimal core_kernel that can be used in other runtimes like javascript where all of core is not available.

                                                                                                                                                even more inspiring is what the openmirage people are doing - indeed, that was the first project i thought about when reading the original post. they are pushing hard on the “everything is a library” model, and contributing to the general ocaml ecosystem in the process.

                                                                                                                                                another thing worth looking at is the elm mailing list - the language, while perfectly usable, is still in the going-through-changes stage, and the community is thinking hard about best practices, design patterns, where it makes sense to follow existing languages and where they should break with historical artefacts and go their own way, etc. it reminds me a bit of the early days of the ruby community, where things like finding a good name for something were considered of prime importance (because, after all, names are part of the public user interface of a language or library, and hard to change once they get established).

                                                                                                                                          3. 5

                                                                                                                                            I agree, exhortations won’t help.

                                                                                                                                            This article popped into my head as soon as I started reading. It feels to me like any language with prolific meta-programming falls into the same traps.. and Ruby is only the latest victim.

                                                                                                                                            1. [Comment removed by author]

                                                                                                                                              1. 3

                                                                                                                                                I’ll agree as far as finding the first far simpler and writing all of my tests in MiniTest. I have no idea why the RSpec DSL there is so prevalent despite being so hard to understand what’s going on.

                                                                                                                                                I mean, it reads like English, sure. But all of the methods for how to do things are completely different from standard Ruby. It’s like you have to memorize a whole different language to really understand the details and write new tests in it. What’s so wrong with a simple assert method?

                                                                                                                                                1. 2

                                                                                                                                                  My favorite by far is

                                                                                                                                                  10.hours
                                                                                                                                                  

                                                                                                                                                  This is monkey patching the core Number class just to match English measure word order. It’s like lighting a campfire through a careful application of a tank because you just so happened to already be driving one.

                                                                                                                                                  1. [Comment removed by author]

                                                                                                                                                    1. 1

                                                                                                                                                      Oh god, what library monkey patches forty_two in?

                                                                                                                                                        1. 1

                                                                                                                                                          I never even knew that was there. I’m at a loss for words.

                                                                                                                                                          Oh, and it was added to spite Reddit? That’s not even just poor design but straight childish.

                                                                                                                                                          It’s not even called forty_second?

                                                                                                                                                          1. 5

                                                                                                                                                            It was not added to spite Reddit, it was left in to spite reddit. Long ago, these accessors were there from everything from 1 - 100. A ton of people complained, so only one to five was kept in, and also, forty_two.

                                                                                                                                                              1. 1

                                                                                                                                                                Oh wow. Always strange when you find out that the way you imagined things was just … wrong. :(

                                                                                                                                                                Thanks for digging that up.

                                                                                                                                                                1. 1

                                                                                                                                                                  s/imagined/remembered/, sigh

                                                                                                                                                    2. 1

                                                                                                                                                      This could be implemented as a decorator pretty easily

                                                                                                                                                      1. 2

                                                                                                                                                        Or… a function. Static method on TimePeriod if you must.

                                                                                                                                                  2. 3

                                                                                                                                                    I’ve been using Common Lisp quite a bit lately, and I don’t really agree with the article you linked.

                                                                                                                                                    It could just be my experience, but from what I’ve seen, a lot of Lisp coders treat advanced macro programming like magic. It’s one of those things you “can” do, but rarely “should,” precisely because it’s so easy to misuse and potentially difficult to understand. There are some popular libraries (like Iterate) that use macros to do far out stuff, but most people write macros themselves pretty infrequently. Even Paul Graham, in “On Lisp” suggests writing macros, “when nothing else will do,” like when conditional evaluation is required.

                                                                                                                                                    On the other hand, my experience with Ruby was that everybody wanted to do meta-programming everywhere because it was the hot new thing and made Ruby like Lisp, and made you look smart and clever. The more a person could abuse meta-programming to twist the language, the better.

                                                                                                                                                    For example, here’s a Ruby tutorial explaining how to use method_missing to auto-generate methods that match a regular expression, and at the end: “we’ve created an extremely expressive and beautiful API that is DRY and easy to maintain.”

                                                                                                                                                    1. 4

                                                                                                                                                      Ruby seems like a faster / more extreme version of it maybe, but the pattern of meta-programming everywhere becoming harmful predates Ruby.

                                                                                                                                                      I have only worked on two major lisp projects. One become so impossible to reason about it was thrown away and rewritten in C. The second remained in lisp – but a strictly procedural version of it, all cleverness was banned and scanned for at the commit level with thousands of lines of Perl… which just made it sort of a “meh” language.

                                                                                                                                                      I have worked on two other meta-programming heavy projects, one built MOP/Groovy – which I just heard the rewrite to Go was completed in the last few months… and one written in Elixir which is still alive and well – but very young… so, my faith in “good” meta-programming based on personal experience is limited.

                                                                                                                                                      The failure always seem to follow the same pattern – initial team is awesome, everyone knows what to do, is reasonable and does amazing… they start to grow / ramp up / are successful! Now they need people, and they need to train and teach and document and they realize all the embedded undocumented knowledge using the system entails, how much of their personal preferences and how they think the language should work is baked in, and how horrible it is to bring new people on-board. This limps along for awhile until it is decided that just switching is easier than continuously paying the human integration cost.

                                                                                                                                                1. 2

                                                                                                                                                  The really interesting things mentioned here for me were being able to write stored procedures in V8 JavaScript, automatic GPG-encryption of your transaction logs (so that even if someone compromises your database server they can’t read your old transactions, I suppose?), and using PITR to recover from disastrous updates by rolling back to any arbitrary point in time. A lot of the other stuff (e.g. querying stored JSON, PostGIS) is pretty neat but I already knew it existed. I thought PITR was just for recovering consistently up to the last transaction committed before a crash or datacenter fire!

                                                                                                                                                  1. 3

                                                                                                                                                    WAL-E isn’t, like, transparent WAL encryption or anything.

                                                                                                                                                    It just backs up WAL segments to S3, and has the option of encrypting them with GPG before uploading them to S3.