1. 8

    This one always irritates me every time someone posts it.

    That’s what the “contract” is about. It’s a two way binding.

    I promise to deliver what I said in the contract, you promise to use only what is in the contract.

    I choose to reimplement my side of the contract, but hold to the contract, and your side breaks, it’s your problem.

    That’s what contracts are for.

    To work out who needs to clean up their shit.

    You may say, ouch, it’s too much work for me please give me back the old behaviour… but that’s a New contract (and a New Price).

    More common is the contract was too informally specified and ambiguity arose in the interpretation.

    Or even worse Connascent Coupling arose because the two sides “Grew Up Together”.

    Personally I regard Connascent Coupling as the enemy of good software and kill it whenever I see it. (Which is often).

    All very good reasons never to use closed source opaque binary blobs.

    1.  

      You may say, ouch, it’s too much work for me please give me back the old behaviour… but that’s a New contract (and a New Price).

      What if you depend on that customer? They can switch to another provider at some inconvenience to themselves, but then you might go bankrupt. Do you hold your ground?

      What if it’s a third party that’s harmed by the new behavior? B relies on your “implicit interface” and C uses B. When your change breaks B, C thinks it’s your fault. After all, B didn’t change their software, you changed yours.

      1.  

        What if you depend on that customer?

        Still new contract, new price, but your management may choose to pay the price for the customer. ie. On the basis that Good Will buys more custom than ads, ie. it’s essentially coming out of the advertizing budget, but at that level accounting rules are more politics than arithmetic.

        The contract declares B is to blame, however, how and by who it is fixed can be a matter of a new negotiation and a new contract.

        If I’m writing the code on both sides of the contract, I choose the solution that minimizes the total amount of work.

        1.  
          1. If you have one enormous customer then they can make a lot of demands on you regardless. This would be just one example of them monopolizing your services. You are basically a contractor for them.

          2. Misuse that will void the product warranty are, but not limited to … etc.

          1.  

            Misuse that will void the product warranty are, but not limited to … etc.

            I’m trying to find an article I read where SimCity (or doom, one of those two) relied on undocumented behavior of the DOS memory manager. When windows 95 changed that it broke the game, which customers blamed on MS and not the game company.

            1.  

              It was SimCity. (Search for “SimCity”, since Joel doesn’t have internal anchors in that article; and I can’t find a primary source for that story.)

      1.  

        This is a problem with any language or library. You need to know what is available in the Python library and what it does to use it effectively. You need to know the binaries in /bin to use the shell effectively. And so on.

        It’s just like learning a human language: Until you use the vocabulary enough to get comfortable, you are going to feel lost, and spend a lot of time getting friendly with a dictionary.

        1. 8

          This is a problem with any language or library. You need to know what is available in the Python library and what it does to use it effectively. You need to know the binaries in /bin to use the shell effectively. And so on.

          I think this probably misses the point. The Python solution was able to compose a couple of very general, elementary problem solving mechanisms (iteration, comparison), which python has a very limited vocabulary of (there’s maybe a half dozen control constructs, total?), to quickly arrive at a solution (albeit while a limited, non-parallel solution, one that’s intuitive and perhaps 8 times out of 10 does the job). The standard library might offer an implementation already, but you could get a working solution without crawling through the docs (and you could probably guess the name anyways).

          J required, owing to its overwhelming emphasis on efficient whole-array transformation, selection from a much much much larger and far more specialized set of often esoteric constructs/transformations, all of which have unguessable symbolic representations. The documentation offers little to aid this search, complicating a task that was already quite a bit less intuitive than Python’s naive iteration approach.

          1.  

            For a long time now, I’ve felt that the APL languages were going to have a renaissance. Our problems aren’t getting any simpler, so raising the level of abstraction is the way forward.

            The emphasis is on whole array transformation seems like a hindrance but imagine for a second that RAM becomes so cheap that you simply load all of your enterprise’s data in memory on a single machine. How many terrabytes is that? Whole array looks very practical then.

            For what it’s worth, there is a scheme to the symbols in J. You can read meaning into their shapes. Look at grade-up and grade-down. They are like little pictures.

            J annoys me with its fork and hook forms. That goes past the realm of readability for me. Q is better, It uses words.

            What I’d like to see is the entire operator set of, say, J brought into mainstream languages as a library. Rich operations raising the level of abstraction are likely more important than syntax.

            1.  

              J annoys me with its fork and hook forms. That goes past the realm of readability for me.

              In textual form I agree. The IDE has a nice graphical visualization of the dataflow that I find useful in ‘reading’ that kind of composition in J code though. I’ve been tempted to experiment with writing J in a full-on visual dataflow style (a la Max/MSP) instead of only visualizing it that way.

              1.  

                I find it a lot easier to write J code by hand before copying it to a computer. It’s easier to map out the data flow when you can lay it out in 2D.

                1.  

                  Have you looked at Q yet?

                2.  

                  That would be a very useful comparison of the usability of a compact text syntax vs visual language. I imagine that discoverability is better with a visual language as by definition it is interactive.

                3.  

                  I started implementing the operators in Scala once - the syntax is flexible enough that you can actually get pretty close, and a lot of them are the kind of high level operations that either already exist in Scala are pretty easy to implement. But having them be just a library makes the problem described in the article much much worse - you virtually have to memorize all the operators to get anything done, which is bad enough when they’re part of the language, but much worse when they’re a library that not all code uses and that you don’t use often enough to really get them into your head.

                  1.  

                    It could just be a beginning stage problem.

              2. 5

                The difference is that Python already is organized by the standard library, and has cookbooks, and doesn’t involve holistically thinking of the entire transformation at once. So it intrinsically has the problem to a lesser degree than APLs do and also has taken steps to fix it, too.

                1.  

                  How easy is it to refactor APL or J code? The reason I ask is that I have the same problem with the ramdajs library in JavaScript, which my team uses as a foundational library. It has around 150 functions, I don’t remember what they all do and I certainly don’t remember what they’re all called, so I often write things in a combination of imperative JS and ramda then look for parts to refactor. I’m interested to hear whether that’s possible with APL, or whether you have to know APL before you can write APL.

              1.  

                This captures pretty well what my problem with J has been too. I wonder to what extent it’s largely just the size of community though. Judging by the revision history, the NuVoc reference pages were almost entirely written by 4 people. Given a few more, you could imagine a more extensive set of resources on the wiki or elsewhere. It also lacks as a result the most common way people pick up useful code snippets and partial solutions in other languages, an extensive set of StackOverflow answers.

                1.  

                  I wonder to what extent it’s largely just the size of community though. Judging by the revision history, the NuVoc reference pages were almost entirely written by 4 people.

                  I think that summarizes the problem quite well: the language itself is great, but the support network isn’t yet there. It’s compounded by the fact you really need to know some idioms to build complex sentences with, a problem most other languages don’t have. I might try to whip up some verb classifications.

                  1.  

                    This honestly is reminding me of people coming to FORTH. We’ve tried to improve the situation in Factor by having namespaces and examples, but I’m still used to those new to the language writing amazingly unidiomatic code because they didn’t know that a word existed in some vocabulary somewhere. I wonder if there’s a generic solution to this type of problem with “weird” languages.

                    1.  

                      Cookbooks are great help for this

                      Lots of problems end up needing to be solved. Sure, there’s stuff like finding the mean. But I’m thinking maybe one level up. Parsing out tuples from a string in a file efficiently. Having a basic state machine simulating… Bank accounts maybe? Making some circles on a screen to visualize some data

                      Some tools are for different domains than others but most of us are aiming to ship things for “real people” so having proper end to end examples can show new people good ways to organize their code.

                      Purescript by Example does this pretty well, with “real” motivating examples the entire time, and showing how to take advantage of Purescripts goodness even with JavaScript being used for heavy lifting.

                      I learned so much watching other people code JQuery stuff too. Real examples. It’ll show larger architecture patterns that type signatures can rarely capture

                1. 4

                  I’d love to see a comparison between this and quorum.

                  1. 1

                    I keep thinking about putting an evidence package from safe and verified systems to give them some language features to study. Especially like contracts or Ada’s built-in safety features.

                  1. 2
                    Why?

                    I use Vim for almost everything. I wish I didn’t have to say almost. My usual workflow is to open Vim, write, copy the text out of my current buffer and paste it into whatever application I was just using. vim-anywhere attempts to automate this process as much as possible, reducing the friction of using Vim to do more than just edit code.

                    I don’t quite understand the rational behind this? Why should one perfer vi-editing when, for example, writing prose? It would seem like all you’d get would be typing i before you start writing, and pressing the escape button when you’re done, plus maybe a more preferable color theme?

                    Personally, as a guy who generally uses Emacs (and for that reason structurally can’t relate to this issue ^^), I see vi being nice when working on code-like or in some sense structured data, which might or might not have some.concept of words and paragraphs. Configuration files, logs, scripts, etc. things you want to easily and quickly manipulate, on a regular basis. (Maybe that’s the reason I don’t use Vi(m), since I see the editor as a kind of “sword”, with wich you quickly strike once, and change whatever you neee, instead of having it open for extended periods of time, and fully living within it, like Emacs. This is also why I don’t like extending vim, since I want it to stay clean and fast)

                    But back to this project, it seems to me, that when I’m writing stuff outside of my editor or a shell, it isn’t this kind of text vi keybinding are good for. Maybe the author has a different experience, and if that’s the case, I’d be very interested in hearing what “reducing the friction of using Vim to do more than just edit code” is supposed to mean.

                    1. 7

                      I don’t quite understand the rational behind this? Why should one perfer vi-editing when, for example, writing prose? It would seem like all you’d get would be typing i before you start writing, and pressing the escape button when you’re done, plus maybe a more preferable color theme?

                      • dis deletes a sentence
                      • '' reverses your last jump
                      • Search highlights show if you overused a word
                      • c is great for editing and revisions
                      • Visual blocks help with adding formatting
                      • Move by paragraph and move by sentence
                      1. -1

                        Most of these tricks seem more like hypothetical advantage, that look great in a list, than real justifications. How often does one reverse their last jump? Or moves the cursor through a text sentence by sentence? Most the other tricks can be more or less easily emulated by a combination of the shift/control and the arrow keys (or on the mac and some GTK versions using built in emacs keybindigs). The “normal” text entry interfaces offered by operating systems are not ot be underestimated, after all.

                        So unless one says “I don’t want to learn any other keybindings that vi’s”, one could understand why people would use this, but it still doesn’t appear to be a good reason to me.

                        1. 4

                          How often does one reverse their last jump?

                          I go back to previous editing positions all the time in Vim, using g;

                          Some other Vim features I find useful for prose:

                          • autocomplete from terms in current document
                          • ya” to copy quoted text
                          • dap for cutting and moving paragraps
                          • zfip for termporarily hiding a paragraph under a fold
                          • digraphs for inserting em dash—tricky to write otherwise.
                          1. 2

                            I use all of these tricks regularly when editing prose. And these were just the ones I immediately thought of when reading your thing. There are plenty of other commands I use all the time. None of them may be strictly necessary but it all adds up to a big quality of life improvement.

                        2. 7

                          I don’t quite understand the rational behind this? Why should one perfer vi-editing when, for example, writing prose? ….

                          I’m not a vi-user, as you might guess, but I can say that a proper text editor is a real boon for writing any sort of text, whether code or light fiction. Word processors are such hostile environments for real production of anything, in my experience.

                          You say you generally use Emacs - don’t you prefer it for non-code things too? I assume vi(m)-people must feel similarly about their paradigm.

                        1. 13

                          I just had to scroll 3 screens to get past a gigantic picture of a lamp in order to get to the text.

                          What the fuck?

                          Waiting on “How To Build A Blog Post That You Won’t Hate.”

                          1. 7

                            It’s Medium. Permanent huge bar across the top of the screen, permanent floating “open in app” button at the bottom.

                            I don’t know how Medium makes web design decisions, but it’s certainly not with the user’s experience in mind.

                            1. 1

                              Or their UX data is based on small sample sizes rendering it almost useless.

                            2. 4

                              Waiting on “How To Build A Blog Post That You Won’t Hate.”

                              1. The page should load text in under two seconds.
                              2. The page should work if javascript is disabled or adblockers are enabled. There should be no popups or interruptions from the reading experience.
                              3. Text should be the first thing you see. Both the title and at least some content should present without scrolling.
                              4. All images must be directly relevant to the main text. If it does not clarify or expand on anything, leave it out. This means, among things, no memes, visual gags, or hero images. Most images will be screenshots or diagrams.
                              5. All visual content must have alt defined for accessibility. If possible, none of the visual content should be necessary to understand the text. Assume you will have visually impaired readers and plan accordingly.
                              6. All quotes and references should be linked, or at least cited. Use of tags should be consistent. You can decide what bold and italics mean, but monospace must mean code.
                              7. Any javascript should only interact with the text to make it more comprehensible. Examples: interactive demos, collapsible elements, inlined footnotes. Apoexamples: select-to-share, “load more” buttons, background animations, any form of scrolljacking.

                              Some of these might make the blog less marketable, but they’ll all make the blog more readable.

                            1. 5

                              It seems odd to spend so much space discussing the complexities of software development, only to conclude that the answer is empiricism. Surely the number of variables and their non-linear effects make experimentation difficult. I think $10M is an extremely tiny fraction of what a reproducible experiment would cost, and it would take a long time to run. You need a huge scale in number of projects and also lengthy longitudinal studies of their long-term impacts. And after you did all that the gigantic experiment would be practically certain to perturb what it’s trying to measure: programmer behavior. Because no two projects I’m on get the same me. I change, mostly by accumulating scar tissue.

                              Empiricism works in a tiny subset of situations where the variables have been first cleaned up into orthogonal components. I think in this case we have to wait for the right perspective to find us. We can’t just throw money at the problem.

                              1. 6

                                What else can we do? Our reason is fallible, our experiences are deceitful, and we can’t just throw our hands up and say “we’ll never know”. Empiricism is hard and expensive, but at least we know it works. It’s gotten us results about things like n-version programming and COCOMO and TDD and formal methods. What would you propose we do instead?

                                1. 4

                                  Empiricism is by no means the only thing that works. Other things that work: case studies, taxonomies, trial and error with motivation and perseverance. Other things, I’m sure. All of these things work some of the time – including empiricism. It’s not like there’s some excluded middle between alchemy and science. Seriously, check out that link in my comment above.

                                  I’m skeptical that we have empirically sound results about any of the things you mentioned, particularly TDD and formal methods. Pointers? For formal methods I find some of @nickpsecurity’s links kinda persuasive. On some mornings. But those are usually case studies.

                                  Questions like “static or dynamic typing” are deep in not-even-wrong territory. Using empiricism to try to answer them is like a blind man in a dark room looking for a black cat that isn’t there.

                                  Even “programming” as a field of endeavor strikes me as a false category. Try to understand that domain you’re interested in well enough to automate it. Try a few times and you’ll get better at it – in this one domain. Leave the task of generalization across domains to future generations. Maybe we’ll eventually find that some orthogonal axis of generalization works much better. Programming in domain X is like ___ in domain X more than it is like programming in domain Y.

                                  You ask “what else is there?” I respond in the spirit of Sherlock Holmes: “when you have excluded the impossible, whatever is left, however unlikely, is closer to the answer.” So focus on your core idea that the number of variables is huge, and loosen your grip on empiricism. See where that leads you.

                                  1. 5

                                    I think we’re actually on the same page here. I consider taxonomies, ethnographies, case studies, histories, and even surveys as empirical. It’s not just double blind clinical studies: as Making Software put it, qualitative findings are just as important.

                                    I reject the idea that these kinds of questions are “not even wrong”, though. There’s no reason to think programming is any more special than the rest of human knowledge.

                                    1. 2

                                      Ah ok. If by empiricism you mean, “try to observe what works and do more of that”, sure. But does that really seem worth saying?

                                      It can be hard psychologically to describe a problem well in an article and then not suggest a solution. But sometimes that may be the best we can do.

                                      I agree that programming is not any more special than the rest of human knowledge. That’s why I claim these questions are not even wrong. Future generations will say, “sure static typing is better than dynamic typing by about 0.0001% on average, but why did the ancients spend so much time on that?” Consider how we consider ancient philosophers who worried at silly questions like whether truth comes from reason or the senses.

                                      Basically no field of human endeavor had discovered the important questions to ask in its first century of existence. We should spend more time doing and finding new questions to ask, and less time trying to generalize the narrow answers we discover.

                                      1. 3

                                        Ah ok. If by empiricism you mean, “try to observe what works and do more of that”, sure. But does that really seem worth saying?

                                        It’s not quite that. It’s all about learning the values and limitations of all the forms of knowledge-collection. What it means to do a case study and how that differs from a controlled study, where ethnographies are useful, etc. It’s not “observe what works and do more of that”, it’s “systematically collect information on what works and understand how we collect and interpret it.”

                                        Critically in that is that the information we collect by using “reason” alone is minimal and often faulty, but it’s how almost everybody interprets software. That and appealing to authority, really.

                                        Basically no field of human endeavor had discovered the important questions to ask in its first century of existence. We should spend more time doing and finding new questions to ask, and less time trying to generalize the narrow answers we discover.

                                        The difference is that we’ve already given software control over the whole world. Everything is managed with software. It guides our flights and runs our power grid. Algorithms decide whether people go to jail or go free. Sure, maybe code will look radically different in a hundred years, but right now it’s here and present and we have to understand it.

                                        1. 2

                                          It is fascinating that we care about the same long-term problem but prioritize sub-goals so differently. Can you give an example of a more important question than static vs dynamic typing that you want to help answer by systematically collecting more information?

                                          Yes, we have to deal with the code that’s here and present. My answer is to reduce scale rather than increase it. Don’t try to get better at running large software projects. Run more small projects; those are non-linearly more tractable. Gradually reduce the amount of code we rely on, and encourage more people to understand the code that’s left. A great example is the OpenBSD team’s response to Heartbleed. That seems far more direct an attack on existing problems than any experiments I can think of. Experiments seem insufficiently urgent, because they grow non-linearly more intractable with scale, while small-scale experiments don’t buy you much: if you don’t control for all variables you’re still stuck using “reason”.

                                          1. 2

                                            Can you give an example of a more important question than static vs dynamic typing that you want to help answer by systematically collecting more information?

                                            Sure. Just off the top of my head:

                                            • How much does planning ahead improve error rate? What impacts, if any, does agile have?
                                            • What are the main causes of cascading critical failures in systems, and what can we do about them?
                                            • When it comes to maximizing correctness, how much do intrinsic language features matter vs processes?
                                            • I don’t like pair programming. Should I be doing it anyway?
                                            • How do we audit ML code?
                                            • How much do comments help? How much does documentation help?
                                            • Is goto actually harmful?

                                            Obviously each of these have ambiguity and plenty of subquestions in them. The important thing is to consider them things we can investigate, and that investigating them is important.

                                            1. 0

                                              Faced with Cthulhu, you’re trying to measure how the tips of His tentacles move. But sometimes you’re conflating multiple tentacles! Fthagn!

                                              1. 1

                                                As if you can measure tentacles in non-Euclidean space without going mad…

                                                1. 1

                                                  Now you’re just being rude. I made a good faith effort to answer all of your questions and you keep condescending to me and insulting me. I respect that you disagree with me, but you don’t have to be an asshole about it.

                                                  1. 2

                                                    Not my intention at all! I’ll have to think about why this allegory came across as rude. (I was more worried about skirting the edge when I said, “is that really worth talking about?”) I think you’re misguided, but I’m also aware that I’m pushing the less likely theory. It’s been fun chatting with you precisely because you’re trying to steelman conventional wisdom (relative to my more outre idea), and I find a lot to agree with. Under it all I’ve been hoping that somebody will convince me to return to the herd so I can stop wasting my life. Anyway, I’ll stop bothering you. Thanks for the post and the stimulating conversation.

                                          2. 2

                                            “try to observe what works and do more of that”

                                            That is worth saying, because it can easily get lost when you’re in the trenches at your job, and can be easy to forget.

                                      2. 2

                                        What else can we do?

                                        If describing in terms of philosophies, then there’s also reductionism and logic. The hardware field turning analog into digital lego’s and Oberon/Forth/Simula for software come to mind for that. Maybe model-driven engineering. They break software into fundamental primitives that are well-understood which then compose into more complex things. This knocks out tons of problems but not all.

                                        Then, there’s logical school that I’m always posting about as akkartik said where you encode what you want, the success/failure conditions, how you’re achieving them, and prove you are. Memory safety, basic forms of concurrency safety, and type systems in general can be done this way. Two of those have eliminated entire classes of defects in enterprise and FOSS software using such languages. CVE list indicates the trial-and-error approach didn’t works as well. ;) Failure detection/recovery algorithms, done as protocols, can be used to maintain reliability in all kinds of problematic systems. Model-checking and proof has been most cost-effective in finding protocol errors, esp deep ones. Everything being done with formal methods also falls into this category. Just highlighting high impact stuff. Meyer’s Eiffel Method might be said to combine reductionism (language design/style) and logic (contracts). Cleanroom, too. Experimental evidence from case studies showed Cleanroom was very low defect, even on first use by amateurs.

                                        Googled a list of philosophies. Let’s see. There’s the capitalism school that says the bugs are OK if profitable. The existentialists say it only matters if you think it does. The phenomenologists say it’s more about how you perceived the failure from the color of the screen to the smell of the fire in the datacenter. The emergentists say throw college grads at the problem until something comes out of it. The theologists might say God blessed their OS to be perfect with criticism not allowed. The skeptics are increasingly skeptical of the value of this comment. The… I wonder if it’s useful to look at it in light of philosophy at all given where this is going so far. ;)

                                        I look at it like this. We have most of what we want out of a combo of intuition, trial-and-error, logic, and peer review. This is a combo of individuals’ irrational activities with rational activity on generating and review side of ideas. I say apply it all with empirical techniques used to basically just catch nonsense from errors, bias, deception, etc. The important thing for me is whether something is working for what problems at what effort. If it works, I don’t care at all whether there’s studies about it with enough statistical algorithms or jargon used in them. However, at least how they’re tested and vetted… the evidence they work… should have rigor of some kind. I also prefer ideological diversity and financial independence in reviewers to reduce collusion problem science doesn’t address enough. A perfectly-empirical study with 100,000+ data points refusing my logic that Windows is insecure is less trustworthy when the people who wrote it are Microsoft employees wanting a NDA for the data they used, eh?

                                        I’ll throw out another example that illustrates it nicely: CompCert. That compiler is an outlier where it proves little to nothing about formal verification in general most empiricists might tell you. Partly true. Skepticism’s followers might add we can’t prove that this problem and only this problem was the one they could express correctly with logic if they weren’t misguided or lying to begin with. ;) Well, they use logical school of specifying stuff they prove is true. We know from testing vs formal verification analysis that testing or trial-and-error can’t ensure the invariants due to state space exploration. Even that is a mathematical/logical claim because otherwise you gotta test it haha. The prior work with many formal methods indicate they reduce defects a lot in a wide range of software at high cost with simplicity of software required. Those generalizations have evidence. The logical methods seem to work within some constraints. CompCert pushes those methods into new territory in specification but reuses logical system that worked before. Can we trust claim? Csmith throws CPU years of testing against it and other compilers. Its defect rate bottoms out, mainly spec errors, unlike about any compiler ever tested that I’ve seen in the literature. That matches prediction of logical side where errors in proven components about what’s proven should be rare to nonexistent.

                                        So, the empirical methods prove certain logical systems work in specific ways like ensuring proof is at least as good as the specs. We should be able to reuse logical systems proven to work to do what they’re proven to be good at. We can put less testing into components developed that way when resources are constrained. Each time something truly new is done like that we review and test the heck out of it. Otherwise, we leverage it since things that logically work for all inputs to do specific things will work for the next input with high confidence since we vetted the logical system itself already. Logically or empirically, we can therefore trust methods ground in logic as another tool. Composable, black boxes connected in logical ways plus rigorous testing/analysis of the box and composition methods are main ways I advocate doing both programming and verification. You can keep applying those concepts over and over regardless of tools or paradigms you’re using. Well, so far in what I’ve seen anyway…

                                        @derek-jones, tag you’re it! Or, I figure you might have some input on this topic as a devout empiricist. :)

                                        1. 2

                                          Googled a list of philosophies. Let’s see. There’s the capitalism school that says the bugs are OK if profitable. The existentialists say it only matters if you think it does. The phenomenologists say it’s more about how you perceived the failure from the color of the screen to the smell of the fire in the datacenter. The emergentists say throw college grads at the problem until something comes out of it. The theologists might say God blessed their OS to be perfect with criticism not allowed. The skeptics are increasingly skeptical of the value of this comment. The… I wonder if it’s useful to look at it in light of philosophy at all given where this is going so far. ;)

                                          Awesome, hilarious paragraph.

                                          We have most of what we want out of a combo of intuition, trial-and-error, logic, and peer review. This is a combo of individuals’ irrational activities with rational activity on generating and review side of ideas. I say apply it all with empirical techniques used to basically just catch nonsense from errors, bias, deception, etc. The important thing for me is whether something is working for what problems at what effort. If it works, I don’t care at all whether there’s studies about it with enough statistical algorithms or jargon used in them.

                                          Yes, totally agreed.

                                        2. 2

                                          What else can we do? Our reason is fallible, our experiences are deceitful, and we can’t just throw our hands up and say “we’ll never know”.

                                          Why not? The only place these arguments are questioned or really matter is when it comes to making money and software has ridiculous margins, so maybe it’s just fine not knowing. I know high-risk activities like writing airplane and spaceship code matter, but those folks seem to not really have much contention about about if their methods work. It’s us folks writing irrelevant web services that get all uppity about these things.

                                      1. 2

                                        What will the Unicode organization do with this money? Their basic job of standardizing character mappings doesn’t seem super resource intensive.

                                        1. 13

                                          Turns out it’s pretty expensive! There’s anthropological work they do, they gotta fund font development, etc.

                                        1. 19

                                          This is something I pushed against a lot at my last job. We wanted to hire Juniors and Associates, but every time we interviewed one we always rejected them as “not experienced enough”. The training is always someone else’s problem.

                                          We’ve known for a long time how to fix this: train people. Companies don’t like it because they don’t “have the time or money”, but this is the exact opposite of the truth. Edwards Deming calls “emphasis on short term profits over long term consistency” one of the deadly diseases of modern industry.

                                          One idea I had to make this more palatable to managers is to hire juniors as programming assistants, that spend part of their time doing training and another part doing helpful work for other developers.

                                          The reality is that most software developers don’t stay one place very long, so maybe it doesn’t make sense to invest a lot in training someone?

                                          Good thing investing in training leads to higher retention!

                                          1. 2

                                            Our industry’s inability to mentor and train people effectively in software engineering is due to the wizard myth that somehow keeps going and going, and is ruining everything from interviews, training, quality, and process.

                                          1. 1

                                            The article makes a really important observation that’s often overlooked. It’s really important for code to express its intent clearly. The key to working with code effectively lies in your ability to understand its purpose. Static typing can have a big impact on the way we structure code, and in many cases it can actually obscure the bigger picture as the article illustrates.

                                            1. 20

                                              I don’t see how the article illustrates that. The article’s argument is that converting between serialization format and your business object requires maintaining some other kind of code and that costs something.

                                              In my experience I’ve had other costs, which I found more expensive, in dealing with using one’s serialization layer as a business object:

                                              1. The expected fields and what they are tend to not be well documented. Just convert the JSON and use it as a dict or whatever, but it’s hard to know what should be there for someone who didn’t write the code. With static types, even if one doesn’t document the values, they are there for me to see.
                                              2. The semantics of my serialization layer may not match the semantics of my language and, more importantly, what I want to express in my business logic. For example, JSON’s lack of integers.
                                              3. The serialization changes over versions of the software but there is a conversion to the business object that still makes sense, I can do that at the border and not affect the rest of my code.

                                              The call out to clojure.spec I found was a bit odd as well, isn’t that just what any reasonable serialization framework is doing for you?

                                              As a static type enthusiast, I do not feel that the conversion on the edges of my program distract from some bigger picture. I do feel that after the boundary of my program, I do not want to care what the user gave me, I just want to know that it is correct. If one’s language supports working directly with some converted JSON, fine.

                                              On another note, I don’t understand the Hickey quote in this article. What is true of all cars that have driven off a road with a rumble strip? They went over the rumble strip. But cars drive off of roads without rumble strips too, so what’s the strength of that observation? Does the lack of a rumble strip some how make you a more alert driver? Do rumble strips have zero affect on accidents? I don’t know, but in terms of static types, nobody knows because the studies are really hard to do. This sort of rhetoric is just distracting and worthless. In my experience, the talk of static types and bugs is really not the strength. I find refactoring and maintenance to be the strength of types. I can enter a piece of code I do not recognize, which is poorly documented, and start asking questions about the type of something and get trustworthy answers. I also find that that looking at the type of a function tends to tell me a lot about it. Not always, but often enough for me to find it valuable. That isn’t to say one shouldn’t document code but I find dynamically typed code tends to be as poorly documented as any other code so I value the types.

                                              If one doesn’t share that experience and/or values, then you’ll disagree, and that’s fine. I’m not saying static types are objectively superior, just that I tend to find them superior. I have not found a program that I wanted to express that I preferred to express with a dynamic language. I say this as someone that spends a fair amount of time in both paradigms. The lack of studies showing strengths in one direction or another doesn’t mean dynamic types are superior to static or vice versa, it just means that one can’t say one way or the other and most of these blog posts are just echos of one’s experience and values. I believe this blog post is falling into the trap of trying to find some explanatory value in the author’s experience when in reality, it’s just the author’s experience. I wish these blog posts started with a big “In my experience, the following has been true….”

                                              Disclaimer, while I think Java has some strengths in terms of typing, I really much prefer spending my time in Ocaml, which has a type system I much prefer and that is generally what I mean when I say “static types”. But I think in this comment, something like Java mostly applies a well.

                                              1. 3

                                                The call out to clojure.spec I found was a bit odd as well, isn’t that just what any reasonable serialization framework is doing for you?

                                                My experience is that Clojure spec addresses the three points. However, Spec can live on the side as opposed to being mixed with the implementation, and it allows you to only specify/translate the types for the specific fields that you care about. I think this talk does a good job outlining the differences between the approaches.

                                                On another note, I don’t understand the Hickey quote in this article.

                                                What you ultimately care about is semantic correctness, but type systems can actually have a negative impact here. For example, here’s insertion sort implemented in Idris, it’s 260 lines of code. Personally, I have a much time understanding that the following Python version is correct:

                                                def insertionsort( aList ):
                                                  for i in range( 1, len( aList ) ):
                                                    tmp = aList[i]
                                                    k = i
                                                    while k > 0 and tmp < aList[k - 1]:
                                                        aList[k] = aList[k - 1]
                                                        k -= 1
                                                    aList[k] = tmp
                                                

                                                I can enter a piece of code I do not recognize, which is poorly documented, and start asking questions about the type of something and get trustworthy answers.

                                                I’ve worked with static languages for about a decade. I never found that the type system was a really big help in this regard. What I want to know first and foremost when looking at code I don’t recognize is the intent of the code. Anything that detracts from being able to tell that is a net negative. The above example contrasting Idris and Python is a perfect example of what I’m talking about.

                                                Likewise, I don’t think that either approach is superior to the other. Both appear to work effectively in practice, and seem to appeal to different mindsets. I think that alone makes both type disciplines valuable.

                                                It’s also entirely possible that the language doesn’t actually play a major role in software quality. Perhaps, process, developer skill, testing practices, and so on are the dominant factors. So, the right language inevitably becomes the one that the team enjoys working with.

                                                1. 7

                                                  That’s not a simple sort in Idris, it’s a formal, machine checked proof that the implemented function always sorts. Formal verification is a separate field from static typing and we shouldn’t conflate them.

                                                  For the record, the python code fails if you pass it a list of incomparables, while the Idris code will catch that at compile time.

                                                  I’m a fan of both dynamic typing and formal methods, but I don’t want to use misconceptions of the latter used to argue for the former.

                                                  1. 1

                                                    machine checked proof that the implemented function always sorts.

                                                    And if comparing spec vs test sizes apples to apples, that means we need a test for every possible combination of every value that function can take to be sure it will work for all of them. On 64-bit systems, that’s maybe 18,446,744,073,709,551,615 values per variable with a multiplying effect happening when they’re combined with potential program orderings or multiple variable inputs. It could take a fair amount of space to code all that in as tests with execution probably requiring quantum computers, quark-based FPGA’s, or something along those lines if tests must finish running in reasonable time. There’s not a supercomputer on Earth that could achieve with testing what assurance some verified compilers or runtimes got with formal verification of formal, static specifications.

                                                    Apples to apples, the formal specs with either runtime checks or verification are a lot smaller, faster, and cheaper for total correctness than tests.

                                                  2. 3

                                                    For example, here’s insertion sort implemented in Idris, it’s 260 lines of code. (…) Personally, I have a much time understanding that the following Python version is correct: (snippet)

                                                    An actually honest comparison would include a formal proof of correctness of the Python snippet. Merely annotating your Python snippet with pre- and postcondition annotations (which, in the general case, is still a long way from actually producing a proof) would double its size. And this is ignoring the fact that many parts in your snippet have (partially) user-definable semantics, like the indexing operator and the len function. Properly accounting for these things can only make a proof of correctness longer.

                                                    That being said, that a proof of correctness of insertion sort takes 260 lines of code doesn’t speak very well of the language the proof is written in.

                                                    What I want to know first and foremost when looking at code I don’t recognize is the intent of the code.

                                                    Wait, the “intent”, rather than what the code actually does?

                                                    1. 1

                                                      An actually honest comparison would include a formal proof of correctness of the Python snippet.

                                                      That’s not a business requirement. The requirement is having a function that does what was intended. The bigger point you appear to have missed is that a complex formal specification is itself a program! What method do you use to verify that the specification is describing the intent accurately?

                                                      Wait, the “intent”, rather than what the code actually does?

                                                      Correct, these are two entirely different things. Verifying that the code does what was intended is often the difficult task when writing software. I don’t find static typing to provide a lot of assistance in that regard. In fact, I’d say that the Idris insertion sort implementation is actually working against this goal.

                                                      1. 4

                                                        The bigger point you appear to have missed is that a complex formal specification is itself a program!

                                                        This is not true. The specification is a precondition-postcondition pair. The specification might not even be satisfiable!

                                                        What method do you use to verify that the specification is describing the intent accurately?

                                                        Asking questions. Normally users have trouble thinking abstractly, so when I identify a potential gap in a specification, I formulate a concrete test case where what the specification might not match the user’s intention, and I ask them what the program’s intended behavior in this test case is.

                                                        I don’t find static typing to provide a lot of assistance in that regard.

                                                        I agree, but with reservations. Types don’t write that many of my proofs for me, but, under certain reasonable assumptions, proving things rigorously about typed programs is easier than proving the same things equally rigorously about untyped programs.

                                                        1. 1

                                                          This is not true. The specification is a precondition-postcondition pair. The specification might not even be satisfiable!

                                                          A static type specification is a program plain and simple. In fact, lots of advanced type systems. such as one found in Scala, are actually Turing complete. The more things you try to encode formally the more complex this program becomes.

                                                          Asking questions. Normally users have trouble thinking abstractly, so when I identify a potential gap in a specification, I formulate a concrete test case where what the specification might not match the user’s intention, and I ask them what the program’s intended behavior in this test case is.

                                                          So, how is this different from what people do when they’re writing specification tests?

                                                          1. 2

                                                            A static type specification is a program plain and simple.

                                                            Not any more than a (JavaScript-free) HTML document is a program for your browser to run.

                                                            In fact, lots of advanced type systems. such as one found in Scala, are actually Turing complete.

                                                            I stick to Standard ML, whose type system is deliberately limited. Anything that can’t be verified by type-checking (that is, a lot), I prove by myself. Both the code and the proof of correctness end up simpler this way.

                                                            So, how is this different from what people do when they’re writing specification tests?

                                                            I am not testing any code. I am testing whether my specification captures what the user wants. Then, as a completely separate step, I write a program that provably meets the specification.

                                                            1. 1

                                                              I stick to Standard ML, whose type system is deliberately limited. Anything that can’t be verified by type-checking (that is, a lot), I prove by myself. Both the code and the proof of correctness end up simpler this way.

                                                              At that point it’s really just degrees of comfort in how much stuff you want to prove statically at compile time. I find that runtime contracts like Clojure Spec are a perfectly fine alternative.

                                                              I am testing whether my specification captures what the user wants.

                                                              I’ve never seen that done effectively using static types myself, but perhaps you’re dealing with a very different domain from the ones I’ve worked in.

                                                              1. 1

                                                                At that point it’s really just degrees of comfort in how much stuff you want to prove statically at compile time.

                                                                This is not a matter of “degree” or “comfort” or “taste”. Everything has to be proven statically, in the sense of “before the program runs”. However, not everything has to be proven or validated by a type checker. Sometimes directly using your brain is simpler and more effective.

                                                                I am testing whether my specification captures what the user wants.

                                                                I’ve never seen that done effectively using static types myself

                                                                Me neither. I just use the ability to see possibilities outside the “happy path”.

                                                                1. 1

                                                                  However, not everything has to be proven or validated by a type checker.

                                                                  I see that as a degree of comfort. You’re picking and choosing what aspects of the program you’re going to prove formally. The range is from having a total proof to having no proof at all.

                                                                  Sometimes directly using your brain is simpler and more effective.

                                                                  Right, and the part we disagree on is how much assistance we want from the language and in what form.

                                                                  1. 1

                                                                    You’re picking and choosing what aspects of the program you’re going to prove formally.

                                                                    I’m not “picking” anything. I always prove rigorously that my programs meet their functional specifications. However, my proofs are meant for human rather than mechanical consumption, hence:

                                                                    • Proofs cannot be too long.
                                                                    • Proofs cannot demand simultaneous attention to more detail than I can handle.
                                                                    • Abstractions are evaluated according to the extent to which they shorten proofs and compartmentalize details.

                                                                    Right, and the part we disagree on is how much assistance we want from the language and in what form.

                                                                    The best kind of “assistance” a general-purpose language can provide is having a clean semantics and getting out of the way when it can’t help. If you ever actually try to prove a program[0] correct, you will notice that:

                                                                    • Proving that a control flow point is unreachable may require looking arbitrarily far back into the history of the computation. Hence, you want as few unreachable control flow points as possible, preferably none.

                                                                    • Proving that a procedure call computes a result of interest requires making assumptions about the procedure’s precondition-postcondition pair. For second-class (statically dispatched) procedure calls, these assumptions can be discharged immediately—you know what procedure will be called. For first-class (dynamically dispatched) procedure calls, these assumptions may only be discharged in a very remote[1] part of your program. Hence, first-class procedures ought to be used sparingly.


                                                                    [0] Actual programs, not just high-level algorithm descriptions that your programs allegedly implement.

                                                                    [1] One way to alleviate the burden of communicating precondition-postcondition requirements between far away parts in a program is to systematically use so-called type class laws, but this is not a widely adopted solution.

                                                                    1. 1

                                                                      Right, and the other approach to this problem is to use runtime contracts such as Clojure Spec. My experience is that this approach makes it much easier to express meaningful specifications. I’m also able to use it where it makes the most sense, which tends to be at the API level. I find there are benefits and trade-offs in both approaches in practice.

                                                                      1. 1

                                                                        Right, and the other approach to this problem is to use runtime contracts such as Clojure Spec.

                                                                        This is not a proof of correctness, so no.

                                                                        I’ve already identified two things that don’t help: runtime checks and overusing first-class procedures. Runtime-checked contracts have the dubious honor of using the latter to implement the former in order to achieve nothing at all besides making my program marginally slower.

                                                                        My experience is that this approach makes it much easier to express meaningful specifications.

                                                                        I can already express meaningful specifications in many-sorted first-order logic. The entirety of mathematics is available to me—why would I want to confine myself to what can be said in a programming language?

                                                                        I’m also able to use it where it makes the most sense, which tends to be at the API level.

                                                                        It makes the most sense before you even begin to write your program.

                                                                        1. 2

                                                                          This is not a proof of correctness, so no.

                                                                          I think this is the key disconnect we have here. My goal is to produce working software for people to use, and writing a proof of correctness is a tool for achieving that. There are other viable tools that each have their pros and cons. My experience tells me that writing proofs of correctness is not the most effective way to achieve the goal of delivering working software on time. Your experience clearly differs from mine, and that’s perfectly fine.

                                                                          I can already express meaningful specifications in many-sorted first-order logic. The entirety of mathematics is available to me—why would I want to confine myself to what can be said in a programming language?

                                                                          You clearly would not. However, there are plenty of reasons why other people prefer this. A few reasons of top of my head are the following. It’s much easier for most developers to read runtime contracts. This means that it’s easier to onboard people and train them. The contracts tend to be much simpler and more expressive. This makes it easier to read and understand them. They allow you to trivially express things that are hard to express at compile time. Contracts can be used selectively in places where they make the most sense. Contracts can be open while types are closed.

                                                                          It makes the most sense before you even begin to write your program.

                                                                          Again, we have a very divergent experience here. I find that in most situations I don’t know the shape of the data up front, and I don’t know what the solution is going to be ultimately. So, I interactively solve problems using a REPL integrated editor. I might start with a particular approach, scrap it, try something else, and so on. Once I settle on a way I want to do things, I’ll add a spec for the API.

                                                                          Just to be clear, I’m not arguing that my approach is somehow better, or trying to convince you to use it. I’m simply explaining that having tried both, I find it works much better for me. At the same time, I’ve seen exactly zero empirical evidence to suggest that your approach is more effective in practice. Given that, I don’t think we’re going to gain anything more from this conversation. We’re both strongly convinced by our experience to use different tools and workflows. It’s highly unlikely that we’ll be changing each others minds here.

                                                                          Cheers

                                                                          1. 2

                                                                            The contracts tend to be much simpler and more expressive. (…) Contracts can be open while types are closed.

                                                                            I said “first-order logic”, not “types”. Logic allows you to express things that are impossible in a programming language, like “what is the distribution of outputs of this program when fed a sample of a stochastic process?”—which your glorified test case generator cannot generate.

                                                                            Just to be clear, I’m not arguing that my approach is somehow better, or trying to convince you to use it. I’m simply explaining that having tried both, I find it works much better for me.

                                                                            I’m not trying to convince you of anything either, but I honestly don’t think you have tried using mathematical logic. You might have tried, say, Haskell or Scala, and decided it’s not your thing, and that’s totally fine. But don’t conflate logic (which is external to any programming language) with type systems (which are often the central component of a programming language’s design, and certainly the most difficult one to change). It is either ignorant or dishonest.

                                                            2. 1

                                                              You can do more with a formal spec than a test. They can be used to generate equivalent tests for one like in EiffelStudio. Then, they can be used with formal methods tools, automated or full style, to prove they hold for all values. They can also be used to aid optimization by the compiler like in examples ranging from Common LISP to Strongtalk I gave you in other comment. There’s even been some work on natural language systems for formal specs which might be used to generate English descriptions one day.

                                                              So, one gets more ROI out of specs than tests alone.

                                                              1. 2

                                                                That’s why I find Clojure Spec to be a very useful tool. My experience is that runtime contracts are a better tool for creating specifications. Contracts focus on the usage semantics, while I find that types only have an indirect relationship with them.

                                                                At the same time, contracts are opt in, and can be created where they make the most sense. I find this happens to be at the boundaries between components. I typically want to focus on making sure that the API works as intended.

                                                                1. 2

                                                                  Forgot to say thanks for Clojure spec link. That was a nice write-up. Good they added that to Clojure.

                                                              2. 1

                                                                “A static type specification is a program plain and simple. “

                                                                I dont think so but I could be wrong. My reading in formal specs showed they were usyally precise descriptions of what is to be done. The program is almost always a description of how to do something in a series of steps. Those are different things. Most formal specs arent executable on their own either since they’re too abstract.

                                                                There are formal specifications of how something is done in a concrete way that captures all its behaviors like with seL4. You could call those programs. The other stuff sounds different, though, since it’s about the what or too abstract to produce the result the programmer wants. So, I default on not a program with some exceptions.

                                                                1. 2

                                                                  It’s a metaprogam that’s executed by the compiler with your program as the input. Obviously, you can have very trivial specifications that don’t really qualify as programs. However, you also have very complex specifications as well. There’s even a paper on implementing a type debugger for Scala. It’s hard to argue that specifications that need a debugger aren’t programs.

                                                                  1. 1

                                                                    I think this boils down to the definition of “program.” We may have different ones. Mine is an executable description of one or more steps that turn concrete inputs into concrete outputs optionally with state. A metaprogram can do that: it does it on program text/symbols. A formal specification usually can’t do that due to it being too abstract, non-executable, or having no concept of I/O. They are typically input too some program or embedded in one. I previously said some could especially in tooling like Isabelle or Prolog.

                                                                    So, what is your definition of a program so I can test whether formal specs are programs or metaprograms against that definition? Also, out of curiosity too.

                                                                    1. 2

                                                                      My definition is that a program is a computational process that accepts some input, and produces some output. In case of the type system, it accepts the source code as its input, and decides whether it matches the specified constraints.

                                                                      1. 1

                                                                        Well, I could see that. It’s an abstract equivalent to mine it looks like. I’ll hold of debating that until I’m more certain of what definition I want to go with.

                                                            3. 3

                                                              That’s not a business requirement. The requirement is having a function that does what was intended

                                                              You’re comparing two separate things, though! The Idris isa proven correct function, while the python is just a regular function. If all the business wants is a “probably correct” function, the Idris code would be just a few lines, too.

                                                              1. 1

                                                                The point here is that formalism does not appear to help ensure the code is doing what’s intended. You have to be confident that you’re proving the right thing. The more complex your proof is, the harder it becomes to definitively say that it is correct. Using less formalism in Python or Idris results in code where it’s easier for the human reader to tell the intent.

                                                                1. 4

                                                                  You can say your proof is correct because you have a machine check it for you. Empirically, we see that formally verified systems are less buggy than unverified systems.

                                                                  1. 2

                                                                    Machine can’t check that you’re proving what was intended. A human has to understand the proof and determine that it matches their intent.

                                                                    1. 2

                                                                      A human had to check the intent (validate) either way. A machine can check the implementation is correct (verify).

                                                                      Like in the Idris, I have to validate that the function is supposed to sort. Once I know that’s the intention, I can be assured that it does, in fact, sort, because I have a proof.

                                                                      1. 1

                                                                        What I’m saying is that you have to understand the proof, and that can be hard to do with complex proofs. Meanwhile, other methods such as runtime contracts or even tests, are often easier to understand.

                                                                        1. 1

                                                                          That’s not how formal verification works, though. Let’s say my intention is “sort a list.” I write a function that I think does this. Then I write a formal specification, like “\A j, k \in 1..Len(sorted): j < k => sorted[j] <= sorted[k]”. Finally, I write the proof.

                                                                          I need to validate that said specification is what I want. But the machine can verify the function matches the specification, because it can examine the proof.

                                                                          1. 1

                                                                            The fact that we’re talking past each other is a good illustration of the problem I’m trying to convey here. I’m talking about the human reader having to understand specifications like \A j, k \in 1..Len(sorted): j < k => sorted[j] <= sorted[k], only much longer. It’s easy to misread a symbol, and misinterpret what is being specified.

                                                                            1. 2

                                                                              You did say “have to understand the proof” (not specification) before. I strongly agree with the latter - the language we use for writing specs can easily get so complex that the specs are more error-prone than their subjects.

                                                                              I once wrote a SymEx tool for PLCs and found that specs in my initial choice of property language (LTL) were much harder to get right than the PLC code itself. I then looked at the properties that would likely need to be expressed, and cut the spec language down to a few higher-level primitives. This actually helped a lot.

                                                                              Even if restricting the property language isn’t an option, having a standard library (or package ecosystem) of properties would probably get us rather close - so instead of \A j, k \in ... we could write Sorted(s) and trust the stdlib / package definition of Sorted to do its name justice.

                                                          2. 4

                                                            For example, here’s insertion sort implemented in Idris, it’s 260 lines of code

                                                            When this code sample has been brought up before (perhaps by you) it’s been pointed out that this is not expected to be a production implementation and more of an example of playing with the type system. There is plenty of Python golf code out there too that one could use as an example to make a point. But, if we are going to compare things, the actual implementation of sort in Python is what..several hundred lines of C code? So your Python insertion sort might be short and sweet, but no more the production code people use than the Idris one. But if the Idris one were the production implementation, I would rather spend time understanding it than the Python sort function.

                                                            It’s also entirely possible that the language doesn’t actually play a major role in software quality. Perhaps, process, developer skill, testing practices, and so on are the dominant factors.

                                                            That is likely true, IMO. I think it’s interesting that one could replace type system in the Hickey quote with “testing” or “code review” and the statement would still be true, but people seem to zero in on types. No-one serious says that we shouldn’t have testing because we still have bugs in software.

                                                            I never found that the type system was a really big help in this regard. What I want to know first and foremost when looking at code I don’t recognize is the intent of the code.

                                                            My experience has definitely not been this. Right now I’m doing maintenance on some code and it has a call in it: state.monitors.contains(monitor) and I don’t have a good way to figuring out what state or monitors is without grepping around in the code. In Ocaml I’d just hit C-t and it’d tell me what it is. I find this to be a common pattern in my life as I have tended to be part of the clean-up crew in projects lately. The intent of that code is pretty obvious, but that doesn’t help me much for the refactoring I’m doing. But experiences vary.

                                                            1. 2

                                                              When this code sample has been brought up before (perhaps by you) it’s been pointed out that this is not expected to be a production implementation and more of an example of playing with the type system.

                                                              The point still stands though, the more properties you try to encode formally the more baroque the code gets. Sounds like you’re agreeing that it’s often preferable to avoid such formalisms in production code.

                                                              But, if we are going to compare things, the actual implementation of sort in Python is what..several hundred lines of C code? So your Python insertion sort might be short and sweet, but no more the production code people use than the Idris one.

                                                              The sort implementation in Python handles many different kinds of sorts. If you took the approach of describing all of the hundreds of lines of C of that with types in Idris, that would result in many thousands lines of code. So, you still have the same problem there.

                                                              No-one serious says that we shouldn’t have testing because we still have bugs in software.

                                                              People argue regarding what kind of testing is necessary or useful all the time though. Ultimately, the goal is to have a semantic specification, and to be able to tell that your code conforms to it. Testing is one of the few known effective methods for doing that. This is why some form of testing is needed whether you use static typing or not. To put it another way, testing simply isn’t optional for serious projects. Meanwhile, many large projects are successfully developed in dynamic languages just fine.

                                                              My experience has definitely not been this. Right now I’m doing maintenance on some code and it has a call in it: state.monitors.contains(monitor) and I don’t have a good way to figuring out what state or monitors is without grepping around in the code.

                                                              In Clojure, I’d just hit cmd+enter from the editor to run the code in the REPL and see what a monitor looks like. My team has been working with Clojure for over 8 years now, and I often end up working with code I’m not familiar with.

                                                              1. 3

                                                                Sounds like you’re agreeing that it’s often preferable to avoid such formalisms in production code.

                                                                At the moment, yes. I am not a type theorist but as far as I have seen, dependent types are not at the point where we know how to use them in effectively in a production setting yet. But I do make pretty heavy use of types elsewhere in codebases I work on when possible and try to encode what invariants I can in them when possible (which is pretty often).

                                                                If you took the approach of describing all of the hundreds of lines of C of that with types in Idris, that would result in many thousands lines of code. So, you still have the same problem there.

                                                                Maybe! I don’t actually know. The types in the Idris implementation might be sufficient to get very performant code out of it (although I doubt it at this point).

                                                                In Clojure, I’d just hit cmd+enter from the editor to run the code in the REPL …

                                                                I don’t know anything about Clojure, in the case I’m working on, running the code is challenging as the part I’m refactoring needs a bunch of dependencies and data and constructs different things based on runtime parameters. Even if I could run it on my machine I don’t know how much I’d trust it. The power of dynamic types at work.

                                                                1. 2

                                                                  I don’t know anything about Clojure, in the case I’m working on, running the code is challenging as the part I’m refactoring needs a bunch of dependencies and data and constructs different things based on runtime parameters. Even if I could run it on my machine I don’t know how much I’d trust it. The power of dynamic types at work.

                                                                  There is a fundamental difference in workflows here. With Clojure, I always work against a live running system. The REPL runs within the actual application runtime, and it’s not restricted to my local machine. I can connect a REPL to an application in production, and inspect anything I want there. In fact, I have done just that on many occasions.

                                                                  This is indeed the power of dynamic types at work. Everything is live, inspectable, and reloadable. The reality is that your application will need to interact with the outside world you have no control over. You simply can’t predict everything that could happen at runtime during compile time. Services go down, APIs change, and so on. When you have a system that can be manipulated at runtime, you can easily adapt to the changes without having any downtimes.

                                                                  1. 1

                                                                    That sounds like a good argument for manipulating something at runtime, but not dynamic types. You can build statically-typed platforms that allow runtime inspection or modification. The changes will just be type-checked before being uploaded. The description of StrongTalk comes to mind.

                                                                    1. 2

                                                                      Static type systems are typically global, and this places a lot of restrictions on what can be modified at runtime. With a dynamic language you can change any aspect of the running application, while arbitrary eval is problematic for static type systems.

                                                                    2. 1

                                                                      When you have a system that can be manipulated at runtime, you can easily adapt to the changes without having any downtimes.

                                                                      There are architectural choices that address this point, in most situations, better IME. That is, standard setup of load balancer for application servers and something like CARP on the load balancers. For street cred, I’ve worked as an Erlang developer.

                                                                      1. 1

                                                                        Sure, you can work around that by adding a lot of complexity to your infrastructure. That doesn’t change the fact that it is a limitation.

                                                                        1. 1

                                                                          In my experience, if uptime is really important, the architecture I’m referring to is required anyways to deal with all the forms of failure other than just the code having a bug in it. So, again in my experience, while I agree it is a limitation, it is overall simpler. But this whole static vs dynamic thing is about people willing to accept some limitations for other, perceived, benefits.

                                                                          1. 1

                                                                            My experience is that it very much depends. I’ve worked on many different projects, and sometimes such infrastructure was the right solution, and in others it was not. For example, consider the case of the NASA Deep Space 1 mission.

                                                                            1. 2

                                                                              I’m not sure how Deep Space 1 suits the point you’re making. Remote Agent on DS1 was mostly formally verified (using SPIN, I believe) and the bug was in the piece of code that was not formally verified.

                                                                              1. 1

                                                                                The point is that it was possible to fix tis bug at runtime in a system that could not be load balanced or restarted. In practice, you don’t control the environment, and you simply cannot account for everything that can go wrong at compile time. Maybe your chip gets hit by a cosmic ray, maybe a remote sensor gets damaged, maybe a service you rely on goes down. Being able to change code at runtime is extremely valuable in many situations.

                                                                                1. 1

                                                                                  The things you listed are accountable for at build time. Certainly NASA doesn’t send chips that are not radiation hardened into space saying “we can just remote debug it”. Sensors getting damaged is expected and expecting services one relies on going down is table stakes for a distributed system. And while I find NASA examples really cool, I do not find them compelling. NASA does a lot of things that a vast majority of developers don’t and probably shouldn’t do. Remember, NASA also formally verifies some of their software components, but you aren’t advocating for that, which makes the NASA example confusing as to which lesson one is supposed to take from it. And those cosmic rays are just as likely to bring down one’s remote debugging facility as it is to break the system’s other components.

                                                                                  1. 1

                                                                                    I think you’re fixating too much on NASA here. The example is just an illustration of the power of having a reloadable system. There are plenty of situations where you’re not NASA and this is an extremely useful feature. If you can’t see the value in it I really don’t know what else to say here really.

                                                                                    1. 1

                                                                                      I’m responding to the example you gave, if you have other examples that are more compelling then I would have expected you to post that.

                                                                                      1. 1

                                                                                        What’s compelling is in in the eye of the beholder. It’s pretty clear that there’s nothing I can say that you will find convincing. Much like I’m not convinced by your position.

                                                        1. 10

                                                          Helpful hint: you can turn slack notifications off.

                                                          1. 9

                                                            When I did this my coworkers got super mad I wasn’t answering things promptly.

                                                            1. 3

                                                              Do they get mad when you try to negotiate for “Do No Distract” times in the day?

                                                              1. 4

                                                                We didn’t have a culture where people actually followed that. You could have a do not disturb time but people would interrupt you anyway. A couple of us started making fake meetings just to get some time to code.

                                                                1. 3

                                                                  Ouch. It’s telling when things get that bad.

                                                                  1. 2

                                                                    A couple of us started making fake meetings just to get some time to code.

                                                                    It’s a good trick, I’ve been doing this for years so I could make sure I got lunch and time to do work.

                                                                    1. 3

                                                                      Wow. These comments, and the recent thread about maybe not working long hours, paint a bleak picture of current work practices in the US.

                                                                2. 4

                                                                  get better co-workers

                                                                  1. 1

                                                                    I actually got the different answer. I was using slack as a message queue, when I saw a coworker that I wanted to distract, I’d slack them (via the app) and wait for an answer, but they actually prefered me to come to talk to them and bother them.

                                                                    I found this weird but complied…

                                                                  2. 7

                                                                    If you read the article, notifications are only a very small part of the problem. The author was speaking about wide scale effects happening at the organization level.

                                                                    1. 3

                                                                      This. So much this. I know that the discussion can take different forms and sometimes there are also larger organizational issues at play. But with that said, I think people often forget that they can disable notification on devices. I’ve seen co-workers across two companies leave notifications on for every single message in a channel (yes, you read that correctly) and with sound nonetheless. It baffles me.

                                                                      macOS comes with a built-in Do Not Disturb mode. Slack lets you configure your notifications so that you’re not getting notifications for each single message across a bajillion channels.

                                                                      [Slack] normalizes interruptions, multitasking, and distractions, implicitly permitting these things to happen IRL as well as online. It normalizes insanely short reply times for questions. In the slack world people can escalate from asking in a room to @person to @here in a matter of minutes. And they’re not wrong to – if your request isn’t handled in 5 minutes it’s as good as forgotten.

                                                                      Somewhere along the way we forgot that interruptions are toxic to real work. It wasn’t always this way. On day 1 of my first trading job the only instruction I received was ‘when the market is open, mute your phone.’ The subtext was ‘or else’. If someone said this to me today I’d give them a hug, and I’m not a hugger.

                                                                      I think people need this reminder today. Outside of work I see people with group chats on their phones (be it Facebook, Twitter, Hangouts, whathaveyou) that bleeps and bloops without rest. I can’t imagine living in that world.

                                                                    1. 8

                                                                      Not even the static typing advocates really believe they can write correct code with less than 100% coverage, do they?

                                                                      I certainly do. Depending on the nature of the unit tests you would otherwise write, it’s going to require a more aggressive type system than you’re used to, but this is totally within reach.

                                                                      it’s mostly the static typing people who are picking the fights

                                                                      If we consider what might motivate people to do this, the only obvious explanation is that static typing is, in fact, a lot better for a lot of things, and people who use static typing are acutely aware of this while people who use dynamic typing are only thinking “what’s the big deal?”.

                                                                      (This is also a matter of degree; if you primarily use, say, Java, you’re probably not going to appreciate static types all that much.)

                                                                      The author is using a cheap & dirty rhetorical technique, which is to make a bunch of dumb arguments that might trick some people, and then write off any criticism as “haha, just trolling!” when it doesn’t work. You can’t productively argue with someone if they’re just going to squirm their way out of any scrutiny.

                                                                      1. 2

                                                                        If we consider what might motivate people to do this, the only obvious explanation is that static typing is, in fact, a lot better for a lot of things, and people who use static typing are acutely aware of this while people who use dynamic typing are only thinking “what’s the big deal?”.

                                                                        The other obvious explanation is that static typing doesn’t help very much and people who use static typing pick fights because they’re insecure. ;)

                                                                        That’s why we can’t rely on “obvious explanations” when exploring causes, because the “obvious” explanation almost always is whatever confirms your own biases. That’s why we need rigorous, empirical evidence to match our claims. That’s one of the reasons Static vs Dynamic fights always go around in circles: we don’t actually have any good empirical evidence one way or another. It’s just people shouting “obvious” explanations at each other.

                                                                        The author is using a cheap & dirty rhetorical technique, which is to make a bunch of dumb arguments that might trick some people, and then write off any criticism as “haha, just trolling!” when it doesn’t work. You can’t productively argue with someone if they’re just going to squirm their way out of any scrutiny.

                                                                        That’s sorta the point in the article. These are cheap and dirty rhetorical techniques, but they’re the exact same techniques we use to argue whatever we do believe in. The only obvious (hah) way out is for us to do Empirical Software Engineering, which means actually objectively studying whatever it is we want to know.

                                                                        Fun story: when MacIver posted this on Twitter somebody told him “You clearly don’t understand how powerful types are, you need to check out this thing called ‘QuickCheck’…”

                                                                        1. 3

                                                                          they’re the exact same techniques we use to argue whatever we do believe in

                                                                          Where are static typing proponents saying “just trolling, bro”?

                                                                        2. 2

                                                                          if you primarily use, say, Java, you’re probably not going to appreciate static types all that much

                                                                          I think the biggest issue I see when discussing type systems is exactly this. So many people think of Java when they think of static types – but Java (outside primitives) isn’t even statically typed it just has some static helpers for it’s dynamic tag system. On top of that, Java, C, C++, etc have such un-powerful type systems that they give the whole idea a bad name due to the popularity of their bad implementations.

                                                                        1. 3

                                                                          “OOP was concerned with representing reality”

                                                                          This is a widely held belief but it’s neither the most useful definition nor original intent. Likewise classification through hierarchical taxonomies is not an essential aspect of OOP, but an unfortunate offshoot of the popular “representing reality” mindset.

                                                                          They original intent and most useful concept of OOP is essentially message passing. Smalltalk’s early (ca 1972) evolution and Hewitt’s actors influenced each other through first person exchanges between Kay and Hewitt.

                                                                          1. 3

                                                                            They original intent and most useful concept of OOP is essentially message passing. Smalltalk’s early (ca 1972) evolution and Hewitt’s actors influenced each other through first person exchanges between Kay and Hewitt.

                                                                            I think there’s a couple of common misconceptions here. The first is that Smalltalk was the “original intent” of OOP. The first OOP language was Simula-67 (ca 1968), which had polymorphic dispatch and inheritance. IIRC Smalltalk and Simula were developed independently and each contributed ideas to “modern” OOP.

                                                                            The second is that there is an “essential aspect” of OOP at all. There is no “essential” OOP in the same way there is no “essential” FP: Lisp, APL, and ML are all considered FP languages despite being wildly different from each other. I’d argue that there’s a few common “pedigrees” of OOP that are all influential and all contribute ideas that most modern OOP languages consider “essential”:

                                                                            • Simula: Modularization, Dynamic Dispatch
                                                                            • Smalltalk: Message Passing
                                                                            • CLU: Abstract Data Types, Generics
                                                                            • Eiffel: Contracts, Class Invariants*

                                                                            I think part of the reason we assume Smalltalk is the “foundation” of OOP is because the other foundational languages, for the most part, aren’t well-known today.

                                                                            *I’ve read that CLU had contracts first, but I can’t find a primary source on this.

                                                                            1. 4

                                                                              Alan Kay, The Early History of Smalltalk…

                                                                              “The whole point of OOP is not to have to worry about what is inside an object… data and control structures be done away with in favor of a more biological scheme of protected universal cells interacting only through messages that could mimic any desired behavior.”

                                                                              “Though it has noble ancestors indeed, Smalltalk’s contribution is a new design paradigm—which I called object-oriented—for attacking large problems of the professional programmer, and making small ones possible for the novice user.”

                                                                              “[Dedicated] To SKETCHPAD, JOSS, LISP, and SIMULA, the 4 great programming conceptions of the sixties.”

                                                                              “It is not too much of an exaggeration to say that most of my ideas from then on took their roots from Simula—but not as an attempt to improve it. It was the promise of an entirely new way to structure computations that took my fancy.”

                                                                              “In 1966, SIMULA was the “better old thing,” which if looked at as “almost a new thing” became the precursor of Smalltalk in 1972.”

                                                                              1. 2

                                                                                Is Haskell missing the whole point of Functional Programming because it’s not a Lisplike?

                                                                                1. 2

                                                                                  The way I see it, running all the combinations of features in OO/Actor and then running combinations for all of the features in FP the elemental thing seems to be ‘tell’ in OO/Actor and ‘ask’ in FP. ‘Tell’ enables asynchrony and ‘ask’ enables ‘laziness.’ They are quite high but different mechanisms for modularity.

                                                                                  1. 2

                                                                                    I’m sorry. Who is claiming Haskell is “missing the whole point of functional programming”?

                                                                                    1. 1

                                                                                      It’s a point of comparison. While AK was very important in The foundations of OOP, he doesn’t have a ground to claim he’s the founder or even necessarily the most significant contributor. And just because modern OOP diverges from his vision does not mean that it’s in some way diminished because of that.

                                                                                      Similar to how Haskell is very different from lisp but still counts as an FP language.

                                                                                      1. 1

                                                                                        If the history you’ve got is not the history you want, just make it up as you go along. I have no interest in a discuss like this.

                                                                                        1. 1

                                                                                          What I’m saying is that equating OOP with just Alan Kay is historically incorrect. He played a big role, yes. But so did Kristen Nygaard, David Parnas, and Barbara Liskov. Their contributions matter just as much and ignoring them is historical revisionism.

                                                                                          1. 1

                                                                                            I never equated OOP with “just Alan Kay”. I equated him correctly with coining the term and inventing the first (completely) OOP language Smalltalk. Parnas and Liskov played roles, certainly in modularity, information hiding, and abstract data types. Later on in the history of OOP I recall around 1986-7 Luca Cardelli published a paper which was intended to provide a taxonomy of OOP-related terms. He define languages like CLU (abstract data types, parametric polymorphism, but no message-passing / runtime dispatch) as “object-based” where he reserved “object-oriented” for the latter.

                                                                                            Certainly Kay never gave Nygaard the short shrift, emphasizing in countless forums Simula’s huge role in OOP.

                                                                                  2. 2

                                                                                    That’s indeed what Alan Kay thinks, but he’s not exactly a neutral historian here, since he’s obviously a pretty strong partisan on behalf of the Smalltalk portion of that lineage.

                                                                                    1. 2

                                                                                      “The Early History Of Smalltalk” is a reviewed, published (ACM HOPL) history of the early years of OOP by the person who originally used the term. If you wish to refer to that as being a “strong partisan” then I guess that’s your privilege.

                                                                                      1. 2

                                                                                        If we’re going to use the ACM as an authority here they officially recognize Dahl and Nygaard as the inventors of OOP.

                                                                                        1. 1

                                                                                          The ACM is correct and this coincides exactly with Kay’s attribution of Simula being a “better old thing” and “almost a new thing”. While Simula introduced all the key concepts of OOP, Kay coined the term to imply the new thing, which is “everything is an object” not Simula, the almost new thing, which is ALGOL + objects for some things.

                                                                                          It’s a fine line distinguishing the two, which Kay more than acknowledges and which does not disagree with the ACM’s recognition of Nygaard and Simula in the history of OOP.

                                                                              1. 9

                                                                                Thanks for making a proposal! One thing that really helps here is providing a list of some posts that fall under iot and some posts that wouldn’t.

                                                                                1. 7

                                                                                  Here’s my list from my saved folder - mostly code, a little game design, and I’ve edited out the career/entrepreneurship stuff:

                                                                                  • 2290-larubyconf2013-refactoring-fat-models-with-patterns-large
                                                                                  • Benjamin C. Pierce - A Deep Specification for Dropbox
                                                                                  • Ben Orenstein - Refactoring From Good to Great
                                                                                  • Bret Victor - Media for Thinking the Unthinkable
                                                                                  • Brian Cantrell - Fork Yeah! The Rise and Development of illumos
                                                                                  • Brian Will - Object-Oriented Programming is Bad
                                                                                  • Cybersecurity as Realpolitik by Dan Geer presented at Black Hat USA 2014
                                                                                  • Evan Czaplicki - Let’s be mainstream! User focused design in Elm
                                                                                  • Everything you need to know about cryptography in 1 hour - Colin Percival
                                                                                  • Gary Bernhardt - Boundaries (RubyConf 2012)
                                                                                  • Gary Bernhardt - Boundaries (SCNA 2012)
                                                                                  • Gary Bernhardt - Capability vs. Suitability - Mountain West Ruby Conference
                                                                                  • Gary Bernhardt - Deconstructing the Framework (Baruco 2012)
                                                                                  • Gary Bernhardt - Fast Test, Slow Test
                                                                                  • Gary Bernhardt - TDD and Unit Tests (Seattle SC Meetup Feb 2012)
                                                                                  • Gary Bernhardt - Testing Units - PyCon 2013
                                                                                  • Gary Bernhardt - The Birth and Death of JavaScript
                                                                                  • Gary Bernhardt - Those Who Forget The Past
                                                                                  • GoGaRuCo 2014- Refactoring Ruby with Monads
                                                                                  • Greg Wilson - What We Actually Know About Software Development
                                                                                  • J.B. Rainsberger - Integration Tests Are a Scam
                                                                                  • John Hughes - Why Functional Programming Matters
                                                                                  • Jonathan Blow - F2P
                                                                                  • Justin Searls - How to Stop Hating Your Tests
                                                                                  • Justin Searls - The Social Coding Contract
                                                                                  • Katrina Owen - 467 tests, 0 failures, 0 confidence (Railsberry 2013)
                                                                                  • Leslie Lamport - Thinking Above the Code
                                                                                  • Mark Lentczner - Haskell Amuse-Bouche
                                                                                  • Martin Jonasson and Petri Purho - Juice It or Lose It
                                                                                  • Mike Action - Data-Oriented Design and C++ - CppCon 2014
                                                                                  • Misko Hevery - Don’t Look For Things
                                                                                  • Misko Hevery - Unit Testing
                                                                                  • Peter Bhat Harkins - Lessons of Liskov - wroc_love.rb 2016
                                                                                  • Peter Harkins - What Comes After MVC - RailsConf 2015
                                                                                  • Richard Stallman - Free Software - TEDx Geneva 2014
                                                                                  • Rich Hickey - The Value of Values
                                                                                  • Sandi Metz - Go Ahead Make a Mess
                                                                                  • Sandi Metz - Grit and Determination
                                                                                  • Sandi Metz - Nothing is Something - RailsConf 2015
                                                                                  • Sandi Metz - The Magic Tricks of Testing (Rails Conf 2013)
                                                                                  • Scott Wlaschin - Domain modelling with the F# type system
                                                                                  • Simon Peyton-Jones - Escape From the Ivory Tower - The Haskell Journey, From 1990 to 2011
                                                                                  • Tim Ewald - Programming with Hand Tools
                                                                                  • You Suck at Excel with Joel Spolsky
                                                                                  1. 2

                                                                                    Peter Bhat Harkins - Lessons of Liskov - wroc_love.rb 2016

                                                                                    Peter Harkins - What Comes After MVC - RailsConf 2015

                                                                                    ಠ_ಠ

                                                                                    (kidding!)

                                                                                    1. 2

                                                                                      Hey, hey, how’d that jackass sneak in there?

                                                                                      (This list got a quick :%s/\.[^\.]*// and skim for business talks, I didn’t notice. Hope they’re not too out-of-place.)

                                                                                    2. 2

                                                                                      Man, you were ready for this thread!

                                                                                      1. 1

                                                                                        Yep. It came up in elsewhere about a month ago, so I’d already cleaned up ls into a markdown list.

                                                                                      2. 1

                                                                                        I’d love to take a peek at that career/entrepreneurship stuff if you’d be willing to share :-)

                                                                                      1. 9

                                                                                        I think Bob Harper’s position on “programming paradigms” is worth consideration.

                                                                                        http://www.cambridgeblog.org/2017/05/what-if-anything-is-a-programming-paradigm/

                                                                                        One of the more obvious problems with computing as a “science” in the western tradition is that the objects of our study often come into existence as an effect of our study itself. The “informatics” formulation avoids the myopic focus on physical machinery, but information itself is a slippery subject. I highly recommend Herbert Simon’s classic The Sciences of the Artificial as a starting point for those who would be serious about epistemology in this field.

                                                                                        Also, for those who would seek some kind of solid foundation in mathematics, the philosophy of mathematics itself is pertinent, from Lakatos to Lakoff and beyond. In brief, human values and lived experience are not so easily disentangled from mathematical “reality”. My advice to anyone who cares about this stuff is, start reading in the philosophy of science and technology… and don’t stop with Kuhn!

                                                                                        1. 4

                                                                                          Also Wittgenstein’s philosophical investigations is great for thinking about programming and science in general.

                                                                                        1. 1

                                                                                          How does “programming as taxonomies” compare and contrast with OOP?

                                                                                          1. 2

                                                                                            Well, it depends on what you consider OOP to be. I suspect the author was referring to Smalltalk at least a little there, but there are other possibilities.

                                                                                            1. 3

                                                                                              I’ve actually started writing a full response, and one of the ideas I’m trying to explore is how a lot of what we think of as “normal” OOP is just what survived the method wars, and before that we had much more diversity in our object taxonomies.

                                                                                              1. 1

                                                                                                is there a way I can already bookmark this post before you’ve written it please? I’m excited!

                                                                                                1. 3
                                                                                              2. 1

                                                                                                I think so. This idea of restrictive paradigms (of research and thought, rather than ‘programming paradigms’) seems commensurate with Alan Kay’s description of the pink and blue planes. The pink plane represents advances made within the current paradigm, the blue plane is accessible by asking incommensurable questions.

                                                                                              3. 1

                                                                                                I always start with a big list of programming paradigms when wondering about this stuff. Aside from fun discoveries, such lists keep us from building categories or explanations that are too narrow for the field as a whole.

                                                                                              1. 7

                                                                                                “Mumps is easily managed without the need for database administrators.”

                                                                                                50 slides of programming footguns

                                                                                                One of my favorite bits about Mumps is why dates start at 1841:

                                                                                                When I decided on specifications for the date routine, I remembered reading of the oldest (one of the oldest?) U.S. citizen, a Civil War veteran, who was 121 years old at the time. Since I wanted to be able to represent dates in a Julian-type form so that age could be easily calculated and to be able to represent any birth date in the numeric range selected, I decided that a starting date in the early 1840s would be ‘safe.’

                                                                                                1. 6

                                                                                                  I think that’s delightful. It’s no less arbitrary than Jan 1 1970, and at least there’s a cool story to it. Good on MUMPS!

                                                                                                  1. 3

                                                                                                    And for the context MUMPS was designed for - medical records - it makes perfect sense. “What is the earliest date we could ever possibly need to represent?”

                                                                                                1. -3

                                                                                                  authors of popular databases who discuss their sexist ideas openly, neo-reactionaries leading functional programming conferences.

                                                                                                  How dare people discuss controversial and offensive ideas openly? They should be forced underground so those ideas can fester without any external contradiction or moderation.

                                                                                                  And of course people with weird, icky politics should be censored from purely technical events. Who knows what kind of whacky fascist programming paradigms they might force on us otherwise?

                                                                                                  1. 29

                                                                                                    This is an incredibly bad faith excerpt to take out of context. The author was discussing doubts they had about attending the Recurse Center, and:

                                                                                                    A bigger part was the mission itself: “to get dramatically better at programming”. Did I even want to get better at programming?

                                                                                                    A lot of bad things in the world have been created by programmers: software for operating drones that bomb civilians, data-mining that violates privacy, companies that “disrupt” by dropping vast amounts of capital in to a market without any intention of building a sustainable business. A lot of bad people love programming: open source thought leaders who harbor deeply racist views, authors of popular databases who discuss their sexist ideas openly, neo-reactionaries leading functional programming conferences. The norms of programmer culture still revolve around using needless complexity as a cloak of wizardry.

                                                                                                    As @vyodaiken says, you’re demonstrating the toxic behavior the author is wary of.

                                                                                                    1. 5

                                                                                                      This is such a misguided fear (even though the author says it wasn’t realized in reality anyway) - lot’s of bad people love mathematics, science and music too, it’s no reason to question the value of those pursuits.

                                                                                                      1. 13

                                                                                                        That’s the nature of fear. I don’t know how to interpret your comment except as a criticism for the author talking about something she honestly felt, then talking more about it later when the fear wasn’t realized. How is this a problem?

                                                                                                        Tons of people worry about the impact of their work and whether they are on a path that is ultimately doing more good than harm for the world. Is the author not allowed to worry about that too? Is she not allowed to talk about it?

                                                                                                        I’m trying to give you the benefit of the doubt, but I don’t understand what else your comment could be saying.

                                                                                                        1. 0

                                                                                                          It is more about me being puzzled by the train of thought. I understand wondering if programming is worthwhile, but I don’t understand how the actions of others have any relevance at all.

                                                                                                          edit: I guess you could make the case harm is an inevitable outcome of programming.

                                                                                                        2. 4

                                                                                                          A misguided fear? The Recourse Center has designed social rules to prevent behavior we know is endemic in technical (and business) forums. The author appreciated the results of those rules. But she’s “misguided” ! In what way? Is it your contention that there is not an endemic toxic culture in tech forums? Are all those women just making it up? Is Yarvin’s hobby of smirking racism something we are obligated to ignore? How do you get to decide the validity of what other people experience?

                                                                                                          1. 2

                                                                                                            Misguided that the actions of others has bearing on your own personal value that can be derived.

                                                                                                            1. 1

                                                                                                              It has a bearing on whether I want to put up with it

                                                                                                        3. 2

                                                                                                          I wasn’t responding to that part of the article; I was responding to the part of the article I had an opinion on. What is your rule for when people are allowed to respond to things? Do they have to fully agree or disagree with the entire article first?

                                                                                                        4. 17

                                                                                                          And of course people with weird, icky politics should be censored from purely technical events. Who knows what kind of whacky fascist programming paradigms they might force on us otherwise?

                                                                                                          How dare women suggest tech and especially programming is a potentially hostile environment one might not want to enter! Preposterous. It is just “locker room talk” for programmers! Either learn to deal with it or stay out of our tree house, you icky girl!

                                                                                                          Why? Why would you focus on that sentence in a post full of great sentences about positive aspects of the Recurse Center?

                                                                                                          1. 19

                                                                                                            Reminds me of a quote from Lean Out

                                                                                                            Women in tech are the canary in the coal mine. Normally when the canary in the coal mine starts dying you know the environment is toxic and you should get the hell out. Instead, the tech industry is looking at the canary, wondering why it can’t breathe, saying “Lean in, canary. Lean in!” When one canary dies they get a new one because getting more canaries is how you fix the lack of canaries, right? Except the problem is that there isn’t enough oxygen in the coal mine, not that there are too few canaries.

                                                                                                            (from Sunny Allen’s essay What We Don’t Say)

                                                                                                            1. 6

                                                                                                              Lot’s of people have a knee jerk reaction because a lot of this stuff sounds like “remove undesirables from society/jobs/conferences”, and puts the power of who is undesirable into the hands of some questionable people.

                                                                                                              It wasn’t the point of the post though, so i agree with you.

                                                                                                              1. 8

                                                                                                                Got another Lean Out quote for you cause they’re just so damn relevant. This one from Sexism in Tech by Katy Levinson.

                                                                                                                In the least three years, I was asked not to use the words “sexism” or “racism” when speaking on a diversity panel because it might make the audience uncomfortable.

                                                                                                                Which throws into especially stark relief wyager’s comment that sparked all of this discussion, since “both sides”[1] are equally worried about censorship. But one group actually gets to say racist, sexist, discriminatory stuff and remain in charge. The other can hardly speak on panels and post on their blogs without the whole world jumping down their throats.

                                                                                                                So yeah, the knee jerk reaction you mention rings a little shallow to me.

                                                                                                                [1] I know, “both sides” is highly misleading, but it captures the duality on display here.

                                                                                                                1. 5

                                                                                                                  The other can hardly speak on panels and post on their blogs without the whole world jumping down their throats.

                                                                                                                  You mean like how people tried to ban Moldbug (presumably who the OP was talking about) from LambdaConf?

                                                                                                                  1. 4

                                                                                                                    With something akin to backchanneling over weird views on a blog totally unrelated to his behavior in conferences, too. Another I cited previously was Opalgate where a guy that didn’t agree with trans people on Twitter got hit by a storm of folks in his project wanting him ejected. They didn’t contribute anything to it like he regularly did but did demand it adopt all their political positions after ejecting its main contributor. The venom was intense with much talk of things like burning bridges and them trying to set him up to look like he supported child molestors or something.

                                                                                                                    And these are supposedly the oppressed people who have to worry about “the whole world jumping down on their throats.” The people who eject any folks who disagree with their beliefs from their own projects, conferences, and this thread. You and their other targets don’t look very powerful and oppressive from my vantage point. They were wielding more power in each of these circumstances.

                                                                                                                    1. 5

                                                                                                                      You want people who Yarvin declares are inferior to politely accept his views? Why should they?

                                                                                                                      1. 6

                                                                                                                        We separate things based on context. In conferences, he had caused no trouble at that point. The reports at the time said he just went to give talks and be helpful. On his blog or personal life, he says or does things I don’t agree with. More than many others but still same thing: many people disagreeing with many things. I’d rather have him at the conference because I don’t ban people I disagree with. If he misbehaves at conferences, then we deal with him.

                                                                                                                        My opponents have a different view. They think everyone should believe/do certain things and not believe/do other things. They should be compatible with those in every forum. If they aren’t in even one place, they are to be shamed in or ejected from every place. He was just one example of that behavior. He was an easy target since his crazy views wouldn’t bring lots of sympathy. In the Opal example, the project had been welcoming and nice to everyone with the violation being a maintainer’s actions on Twitter. Nothing stopped people from participating in the project and no evils were done in it. The maintainer did violate a rule of their politics in one public forum, though. So, an entire group of them hit that project, ordered the ejection of that member, ordered total compliance with their beliefs, trolled the hell out of them, and of course offered nothing to the project in code or other support.

                                                                                                                        I’d rather stop that kind of stuff. It’s just domination rather than anything moral or productive. We can either let a small group of people enforce their arbitrary views on everyone with no discussion or dissent allowed like they desire. Alternatively, we accept everyone under rules the various groups have a consensus on where good things we agree on are encouraged and bad things are prohibited. That maximizes the overall good and productive things we do. That’s my stance. It’s also what we usually do at Lobsters. It’s also what most successful companies and democratic governments do. What my opponents who eject people at conferences ask for is more akin to a dictatorship or theocracy since discussion/dissent is considered evil to be punished.

                                                                                                                        1. 7

                                                                                                                          I have somewhat similar thoughts as you, but here’s a thought experiment for you that might help put some things in perspective. Let’s say you are running a conference. You are invested in it and hope for it to succeed, and you have some or all power in determining who is invited to speak. After the CFP ends, you like Foobar’s talk and invite them. Sometime later, you post the list of speakers. To your surprise, a lot of people are upset about Foobar’s invitation because Foobar maintains a very controversial blog that makes a lot of people uncomfortable.

                                                                                                                          You decide to stick to your guns. You definitely appreciate that Foobar expresses controversial views and understand that it makes a lot of other people uncomfortable, but you determine that since Foobar’s controversial views are not related to the conference topic, and therefore, they should still be allowed to speak. So you communicate this to all the would-be conference goers and other invited speakers.

                                                                                                                          I think this is all pretty reasonable actually, although I do understand why some might object to this type of decision making on ethical grounds. But here’s the kicker. At this point, you hear back from N of the invited speakers and M of the people that would otherwise buy tickets. All of them feel strongly enough that they refuse to attend your conference.

                                                                                                                          So here’s the question: how big does N and/or M need to be for you to retract your invite to Foobar? Are you so ethical as to allow the conference to fail? Or are you so pragmatic as to let it succeed? Perhaps a little of both?

                                                                                                                          I think the point of this thought experiment is to demonstrate that morals/ethics aren’t necessarily the only thing at stake here. In particular, you could even be in violent agreement with Foobar but still rescind their invitation for practical reasons alone because you want the conference to succeed. I personally don’t have a strong answer to my thought experiment either, so this isn’t a “gotcha” by any means and probably more of a rhetorical proposition than anything else.

                                                                                                                          1. 2

                                                                                                                            (Sorry for delay. I was getting overwhelmed between work, email, and foums exploding. Trying to reply to everyone.)

                                                                                                                            Alright, before the thought experiment, I’ll note that the situation with that conference was a bit different per initial reports I read. The conference wasn’t experiencing a huge loss hinging on accepting or taking such people. Many people liked the presenters’ talks. Instead, a handful of political activists worked behind the scenes convince the people running it to eject a person they didn’t like regardless of what the conference thought. They probably said a lot of the same kinds of things, too, since an organizer would be receptive to them. This kind of behavior is a major reason I’m holding the line resisting the political or meta stuff such people want to work with.

                                                                                                                            Alright, now to your exploration which is more than reasonable: it’s something I’ve worried about myself.

                                                                                                                            “At this point, you hear back from N of the invited speakers and M of the people that would otherwise buy tickets. All of them feel strongly enough that they refuse to attend your conference.

                                                                                                                            It really comes down to the philosophy of the organizers I guess. There’s a few routes they might take:

                                                                                                                            1. Ideological. Do what’s perceived as right regardless. In this case, they should include their politics in their marketing to give clear signal of what’s expected. They should block or eject anyone not compatible even if the talk fails. The example you gave is one where the talk could fail. On other end, certain conferences in highly-liberal areas might fail if not doing enough to address their concerns like inclusive language.

                                                                                                                            2. Impact and/or financial success. This philosophy says do what it takes to succeed financially or just in terms of conference activity. Nothing else matters. You gave one example where a conference might have to eject folks controversial among highly-liberal people to get attendees. I’ll also note this same rule would justify reinforcing ills of society like racism or sexism at conferences under “don’t rock the boat” concept. Lecturing or politicizing typical bunch of Silicon Valley or enterprise developers, esp the privileged males, will only irritate them with lost sales. This priority is a double-edged sword.

                                                                                                                            3. In the middle. The great thing about real life is most stuff is a spectrum with tradeoffs. That’s the hard thing but also good here. An example is an organizer might set ground rules that reduce bad behavior instead of force politics front and center. Another example is ignoring diversity or bad behavior on the sales team at conferences or in meetings for enterprise segment to drive up sales since buyers often want to know their partners are “like them” or some crap. Whereas, the backend, developers or community side, can be really diverse without the haters even knowing they’re supporting an organization that heavily invests in developming minority talent. This is one of my hypothetical schemes rather than something I’ve observed outside Fortune 500 trick of having immigrants doing lots of work in background.

                                                                                                                            So, I see some possibilities here where the conference organizers’ priorities seem to be the biggest factor in whether they should accept or block someone. They might block some but not others depending on level of extremism. They might rule exclusively on behavior instead of beliefs. The crowd they’re serving might like behaviors like sexism or hate it with serving the crowd being morally context-sensitive.

                                                                                                                            I write off top of my head for honesty. I wrote that before I got to your last paragraph. I was about to say I don’t really have an answer for you past the conditional framing above. Too dependent on circumstances or whose in control. Seems you didn’t have one either, though. It is a very important consideration, though, since conferences are usually created to accomplish specific things instead of brag they were compatible with ideology of a person or group. Most of them anyway.

                                                                                                                          2. 4

                                                                                                                            My opponents have a different view. They think everyone should believe/do certain things and not believe/do other things. They should be compatible with those in every forum.

                                                                                                                            It is possible that there is a belief, or set of beliefs, which are sufficiently sociopathic that they disqualify people who hold them from a platform in any context? Is there some value for X that if someone publicly and explicitly said “X” you would refuse to support them in any way?

                                                                                                                            I hope it’s uncontroversial that the answer to both of those questions should be “yes”. In making that affirmation we’ve established that the set of things exists. Now the discussion shifts to which things belong in the set. Reasonable people can make reasonable arguments for this or that belief. I think it’s completely understandable that Moldbug’s feudalist racism would cross the threshold for a lot of reasonable people.

                                                                                                                            Put more succinctly: a society isn’t obligated to give a platform to the intolerant in deference to the abstract right of free expression. Rather the opposite: a society is made better through a vigorous assault on intolerance, in whatever form it blossoms.

                                                                                                                            1. 2

                                                                                                                              You might separate things by context but I don’t. People are not compartments. You might think other people should separate by context and not consider that e.g X is a holocaust denier when X speaks on functional programming. Great but don’t dare demand I do the same. That would be super presumptuous. BTW you appear to believe some organized group is after you. I’m unaware of any such group.

                                                                                                                              1. 1

                                                                                                                                e.g X is a holocaust denier when X speaks on functional programming. Great but don’t dare demand I do the same.

                                                                                                                                I always challenge people who say that to list all of their political beliefs on the major topics that provoke controversy somewhere to link in their profile. We’ll just link it before any comment they make so the person replying can see the entire political spectrum of who they’re talking to plus what they’re saying in that moment as one thing. Then, like you said, they can want to interact with that person in their entirety or ignore all value they may have contributed over one thing they didn’t like. I think we should heed Richelieu’s warning instead.

                                                                                                                                “BTW you appear to believe some organized group is after you. I’m unaware of any such group.”

                                                                                                                                I just cited a few. The Yarvin thing was a small group of political activists trying to get rid of someone they didn’t like in a shady way. The Opal scandal was Ehmke’s posse pummeling that project on Github with no problems within it. Ehmke’s been in quite a few of these with an openly-stated mission to force her brand of politics (“social justice”) in every forum using her Code of Conduct as leverage. Two people involved in those actions are active in this forum with both voting for a similar CoC here. Ehmke later griped about the hate she and her white-hating buddies receive online and at Github saying it was because she’s trans rather than shoving her politics down the throats of everyone she meets. I particularly loved how they bragged about hiring “token, white people” on their team. Nobody could even joke about that if they said black. Anyway, I called Ehmke out on that submission for trying to pretend her politics had nothing to do with it. Then, some organized group was after me with the community at least being more impressive in how that was handled than most forums those kind of people hit.

                                                                                                                                (Edit to emphasive these are loosely-organized, small groups that know how to say the right things hitting people not usually expecting it or knowing how to react. They create PR nightmares with passive-aggressive sophistry, basically.)

                                                                                                                                So, yeah, there’s definitely organized groups doing the exact thing I’m worried about with some here that have done it on previous forums. They always prop up the rules they use as leverage by saying they’re just trying to stop discrimination or hate speech but (a) they get to define what is or isn’t and (b) their own actions are quite discriminatory against other groups with inconsistent enforcement. Even minority members that disagree with them get hit as happened on HN same week where I got slowbanned for quoting women disagreeing with women. Give them an inch in a new place, they’ll take a mile. I’m not giving them an inch.

                                                                                                                                Note: There’s plenty of similar stuff happening at college campuses across the states, too. A lot of folks doing this sort of thing come out of them. Hard to combat since dissenting speech is considered hate speech or otherwise put down.

                                                                                                                                1. 5

                                                                                                                                  That’s not a challenge, it is an example of sealioning. I don’t have any obligation to provide you with an algorithm or to be consistent or to satisfy your sense of what’s right. My right to not read Pound’s poetry because he was a fascist or to read Celine’s early work because it is so eloquent even though he became a fascist, or to refuse to attend a conference where Yarvin speaks or to prefer the rules of Recourse center doesn’t depend on your stamp of approval. Sophie didn’t make any demands of you. On the contrary, you are demanding that she not express opinions that make you uncomfortable. Get over yourself. Go explain why Yarvin’s work is so damn great that you don’t care that he’s a smirking racist or cheer for the pseudo-science of the Google Manifesto all you want. You have the right to speak. You do not have the right to demand others approve or refrain from criticizing or even shunning you.

                                                                                                                  2. -1

                                                                                                                    Why would you focus on that sentence

                                                                                                                    Because I didn’t have anything to say about the other ones. Do you think I’m obligated to address every sentence in an article if I want to address any of them?

                                                                                                                  3. 7

                                                                                                                    The fact that we almost know who she was talking about proves that they can currently discuss these ideas openly mostly fine.

                                                                                                                    So these people express their opinions, and others are like “well now I don’t want to talk to them”. If you(*) want to barrage people with your unpopular opinions, people will stop wanting to hang out with you .

                                                                                                                    I understand the fear of being shut out of social events like conferences. But they’re social events, so if you make yourself unliked… No amount of rulemaking will solve that, I think.

                                                                                                                    The bad faith logical inverse if your argument is “everyone should be friends with everyone. No matter how much disagreement with social issues are present, someone should always be allowed to be present. This includes allowing to bully other members of the community without repurcussions ever.”

                                                                                                                    It’s the bad faith interpretation, but one that some people will make.

                                                                                                                    (*) Impersonal you

                                                                                                                    1. 5

                                                                                                                      “So these people express their opinions, and others are like “well now I don’t want to talk to them”. “

                                                                                                                      These people express opinions but want anyone disagreeing to shut up. That’s been present in replies on most threads here where people did. Allowing only one side to speak while defining any disagreement as an attack or hate is political domination.

                                                                                                                      “This includes allowing to bully other members of the community without repurcussions ever.””

                                                                                                                      There’s the word games your side is famous for. vyodaiken did it earlier redefining a rhetorical disagreement as an attack on one side but not the rhetoric of the other side that painted everyone without qualification with negative labels. In your case, the people whose politics I oppose here regularly define any disagreement as hate speech, offensive, bullying, behaviors not to be tolerated, and so on. Not all of them do but many do. You all redefine the words from the neutral, tolerable thing they are (eg disagreement or political bickering) to a new word we all have a consensus against (eg bullying, hate speech). Then, you’re arguments for action focus on the new word with its meaning whereas what was actually going on is a lesser offense which wouldn’t be justified.

                                                                                                                      So, what people supporting Sophie actually want is anyone on their side able to express their opinions without disagreement and without repurcussions ever. Whereas, anyone disagreeing with it is automatically labeled as something far worse, dismissed immediately, and for some ejected if allowed by rules. That’s always worth fighting against even if wyager’s parody was as poor a wording strategy as Sophie’s own overly-broad, only-negative portrayal of programmers.

                                                                                                                      1. 3

                                                                                                                        She never advocated censorship. She never said “most programmers” or “all programmers”. So your response is obviously not directed at her words but at something else.

                                                                                                                        1. 1

                                                                                                                          as Sophie’s own overly-broad, only-negative portrayal of programmers.

                                                                                                                          Again, this is an opinion unsupported by the data. The examples were specific, and real. The concerns are non-trivial, and real. You’re making something about you that isn’t about you.

                                                                                                                          1. 0

                                                                                                                            That’s always worth fighting against even if wyager’s parody was as poor a wording strategy as Sophie’s own overly-broad, only-negative portrayal of programmers.

                                                                                                                            wyager is arguing that people with bad values should be allowed space in public or in others’ private spaces, which is a bad value. Majority supremacists, patriarchal maximalists, authoritarians, etc. should not be allowed safe spaces, and should never be accommodated.

                                                                                                                            From your characterizations of the author’s post and how they portrayed programmers, it’s clear you’ve either not read it and are arguing from ignorance, or you have read it and are arguing in bad faith, since the passage is clearly contextualized as part of explaining an internal struggle about how best to grow as a human being.

                                                                                                                            1. 4

                                                                                                                              From your characterizations of the author’s post and how they portrayed programmers, it’s clear you’ve either not read it and are arguing from ignorance, or you have read it and are arguing in bad faith

                                                                                                                              I’ve read it. Part of learning a field and growing as a human being is a fair assessment of what’s going on in it good and bad. Author’s concerns in that section solely focus on the bad… the worst of it actually… with the people side being like talking points out of one part of a political debate. Outside of those, I usually see a wide range of claims about programmers, jobs, effects on world, etc. Author is setting up false, strictly-negative premises in either ignorance or bad faith, maybe even unintentionally due to bias, then struggling to work from within the moral straight-jacket she put on. Totally unnecessary if starting from a more accurate worldview that includes the positive and neutral people and programs.

                                                                                                                              Note that I liked all the stuff about RC in the article. I enjoyed the article right up to that point. I just mentally deleted that part so I could just think about the rest which was most important parts. As in, more corroboration and anecdotal evidence in favor of RC visits. Then, the debate started.

                                                                                                                              1. 1

                                                                                                                                Note that I liked all the stuff about RC in the article. I enjoyed the article right up to that point. I just mentally deleted that part so I could just think about the rest which was most important parts.

                                                                                                                                I feel like you’re attempting to speak in good faith, so I’m going to do the same.

                                                                                                                                This point I’ve highlighted here, that you “just mentally deleted that part”, is an example of privilege in action*. You have never had your life or well-being threatened by people or organizations like the ones the author calls out, and you have never had to be concerned with whether or not they were active or influential in the spaces you inhabited. Other people are not so lucky, and have learned from difficult experience that they need to be aware of their surroundings and who might be in them, or else they may be injured or otherwise harmed.

                                                                                                                                Some people, especially those who come from outside the main software development industries, have heard only that IT/tech has a huge problem with sexism and toxic masculine culture. Some people are members of the marginalized groups whose well-being is directly threatened by the personal values of community leaders of some of the popular software communities, as named by the author of the post. The Recurse Center attracts a lot of people from diverse and non-technical backgrounds, and many of those people share the concerns that the author had, and would appreciate having them explicitly dispelled with regards to RC, as the author did.

                                                                                                                                So the least that those with privilege, like you and I have, can do, is not make it harder for those less fortunate to engage with the playground we have (programming) that also gives us power and status. It’s bad form to raise barriers against those with a harder lot in life than we have. These kinds of messages, from “the other side” as it were to those people who might be afraid of what they’ll find when they get there, are super important. And it’s not about you, or me, or anyone here, unless they’re part of the problem. It’s for other people like the author or who might be thinking about getting into a tech career by applying to RC, but who have heard the industry has some problems.

                                                                                                                                *) note that you have this privilege, even if you are not privileged in other ways (eg, you were born into a poor family, etc.). life is complicated.

                                                                                                                                1. 1

                                                                                                                                  Since you’re being in good faith, do read this next like I’m just bluntly saying something instead of losing my shit or being loud. ;)

                                                                                                                                  “You have never had your life or well-being threatened by people or organizations like the ones the author calls out, and you have never had to be concerned with whether or not they were active or influential in the spaces you inhabited. “

                                                                                                                                  You’re assuming I don’t understand the concept because I’m presumably white male. My first school experience was being attacked or mocked because I was a “nerd.” All but a few people excluded us which happened varying degrees whole time in school. That included “minorities.” They all do to nerds what they claim others do to them, including violence by alpha males but not police. They might interrogate or arrest them if something happened involving computers if said nerd is known programmer or hacker.

                                                                                                                                  Next, I was white in a black-run, mostly-black school where they added to mockery or exclusion the fact that we were shouted down if disagreeing with any issue (especially racial) plus randomly attacked. I doubt most of these people talking about their minority concerns have been held down on a bus while black people take turns beating them with the smirking driver not reporting it. Attempts like that were too common for me until I learned kickboxing and paranoid vigilance, esp wide turns around corners. Still had to dodge fights due to rule white people can’t be allowed to win against black people either at all or too much. Varied. My friends and brothers who went to other black schools endured the same where just bending over a water fountain could be too much vulnerability. I avoided bathroom stalls, too, after seeing what that led to.

                                                                                                                                  I also got to be a man in places run by women who favored women. Essentially, whoever stayed in their good graces talking about what they talked about, being an insider, laughing at anti-male jokes, and so on had more privileges in those places. That would benefit grades, get more work hours, increase odds of promotion, even get some guys laid with those opposing sexism shamed. Unlike women on average, it’s been a while since I dealt with that but happening again in my current company. Highly-political, card-playing woman took over a specific department I was almost transfered to. After exit-interviewing her ex-employees, I blocked transfer fast before expected changes happened: she hired mostly black folks like her (esp exploitable youth), promoted only the older black women exactly like her kissing up instead of mix of races/genders who outperformed them, and politics over performance further destroyed that departments’ numbers with them saying nonsense about why. Current team is good with mix of straight/gay/lesbian, white/black, and liberal/moderate/redneck. Usually fun, interesting group with occasional in-fighting due to differences all apologize for after.

                                                                                                                                  That covers structural racism and sexism which the type of politics I fight denies even exists for whites or men despite supporting data. We get no help. What about “neo-reacitonary?” Well, I am an outspoken liberal and Union man who defends decent Muslims and calls out police corruption on the side in the rural South deep in Trump, meth, and capitalist country. Interesting enough, one insult they fling at me here is probable Hillary supporter while people I argue with on liberal forums assume I’m a right-winger. Biases… Being outspoken in rural spots led me to have to negotiate with people intent on beating or killing me right there if I got too many words wrong. Rare people but non-passive outsiders will run into them. Most online “activists” on social media talk about threats which I find are folks talking shit online or with prank calls that don’t on these issues result in hospitalizations or anything almost ever. Just irritating trolling by jerks shielded by anonymity. Pales in comparison to what even a trip for groceries can cost a white person in impoverished areas in or around Memphis, TN. The First 48 was banned from there over too much stuff to cover. Some police are gang members, too, so gotta act in a way to reduce risk of their attention.

                                                                                                                                  Since you admitted it, you might have privilege of growing up as or hanging with white people that didn’t face racism, sexism, or drug heads’ threats on regular basis. Lot of us in poor areas, minority-controlled areas, areas of opposing politics, isolated areas… these are some where many say they have similar experiences to me. We find it strange people “speaking for oppressed” as they might say ignore existence of probably millions of us due to skin color or gender. Especially rural whites given their high rates of both drug addiction and suicide, too. My friends and family have had to fight those.

                                                                                                                                  Alright, what about someone like Sophie or I who are concerned with environments where we might be facing racists or sexists that hate our group? Well, I agree with you entirely that it can be reassuring to see someone bringing that up saying it doesn’t happen at a specific location. Going from an all-black school to a mixed school where they didn’t hate us was… it was heaven. We had fun together! Likewise, groups with fair/excellent women or being around civil Southerners who only get X-ist if explicitly talking politics. I’d definitely want to know every place or group where I could avoid groups I mentioned first in favor of others if that was best I could hope for.

                                                                                                                                  That said, remember how it started was exclusively portraying the field based on worst of the worst. I don’t do that. Since we’re at that point, I’ll tell you the violent people I met were single digit percentage of each area, the negative bias was huge, there were coping mechanisms to get me past some of it, there were neutral/decent people, and some were so fair or good they inspired me to be more skilled or tough. If I talk about a field, I try not to throw them under the bus entirely or I take the counterpoint I had coming for screwing up due to emotion winning or whatever. You’ll see that in programming with C or PHP languages where I’m a strong opponent but don’t pretend they’re 100% bad even if many developers do damage. Likewise, following my politics, I’m still getting along with and exchanging tips with specific Lobsters who were strongly opposing me in prior political debates.

                                                                                                                                  So, what she was doing isn’t the only way to respond. It was a weaker, overly-broad, politically-charged claim that got low-value reactions followed by a whole battle that distracted from her main points. She set her post up to fail to quite a degree. I’d have told her to be more fair and accurate since bringing politics in is putting a spotlight and a metaphorical scope on you. The negative responses left over would have to be haters or themselves prioritizing some politics. Easy to dismiss when they have little to no ground to stand on. Those of us in minority positions unfairly have to be careful about our claims since they’ll get more scrutiny and attack.

                                                                                                                                  Since she probably made up her mind, I just mentally deleted it like I trained myself to do when saying something to that person won’t change their views IRL. Focus on good, shrug off perceived bad if not an intentional attack, and go on from there. It’s how we integrate and survive down here in our powder keg of diversity. Works fine, too, with most of us getting along well enough. :)

                                                                                                                                  “These kinds of messages, from “the other side” as it were to those people who might be afraid of what they’ll find when they get there, are super important.”

                                                                                                                                  This I disagree on if they’re aiming to affect policy or law anywhere. I’ve already seen it happen in many places with ultra-liberal universities being good examples. In those, allowing it to go too far without participation shifted power to those groups. Those groups built on their politics and power until they regularly belittle whites or males in various ways. They also try to silence disagreement on political issues saying it’s not about them. Well, if we stand to lose anything (even rep or jobs) by decree, then it is about us and we should at least weigh in. I don’t gripe about the reasonable stuff where each person has a view they can state, chance at the job, etc. I’m usually backing it.

                                                                                                                              2. 2

                                                                                                                                I’m sure all the people hit with the bad value hammer will disappear into the ether once you get your (apparently unauthoritarian) way.

                                                                                                                                1. 1

                                                                                                                                  Your false equivalence, that being intolerant of intolerance and hatred, is also cowardly stated using passive aggressive style, as well as sarcasm. That is, you are acting like a coward, lest I be accused of not speaking my point forcefully enough.

                                                                                                                                  1. 0

                                                                                                                                    I find passive aggressive sarcasm allows for remarkable concision, but whatever. I don’t respect you and your group as the arbiters of good and bad values and all people like you have done is make me care substantially less about being labeled a patriarchal maximalist or whatever you’d like. Many people I know feel similarly. We’re not going to leave the field if you succeed in banning us from the recurse center

                                                                                                                                    1. 0

                                                                                                                                      Hey, have fun hanging out with Nazis, then.

                                                                                                                                      1. 0

                                                                                                                                        Enjoy weilding whatever power that label still has while it has any at all.

                                                                                                                                        1. 1

                                                                                                                                          I don’t want to wield power. I want to not be around assholes. Are you really saying you’d rather hang out with white supremacists and gamergater pigs, than take a stand and say, “Those values are not welcome?” How is this even a question?

                                                                                                                          2. 12

                                                                                                                            Great illustration of what she wanted to avoid.

                                                                                                                            1. 8

                                                                                                                              I don’t get why people don’t want to talk about this? I don’t necessarily agree with wyager, but this type of discourse is pretty healthy IMO. It’s precisely why I prefer this site to HN, because that comment would surely have been censored by the moderators.

                                                                                                                              1. 5

                                                                                                                                It’s also completely off topic in the context, which is about using programming for good, and it’s really obnoxiously phrased to boot. Which does matter.

                                                                                                                                1. 6

                                                                                                                                  In your opinion it is obnoxious, I didn’t find it so bad, but maybe that is just me.

                                                                                                                                  1. 16

                                                                                                                                    Obnoxious is a bit subjective, but his comment is destructive (as opposed to constructive), and that’s an objective observation.

                                                                                                                                    How dare people discuss controversial and offensive ideas openly?

                                                                                                                                    This is sarcastic and demeaning.

                                                                                                                                    They should be forced underground so those ideas can fester without any external contradiction or moderation.

                                                                                                                                    Sarcastic and a strawman.

                                                                                                                                    And of course people with weird, icky politics should be censored from purely technical events.

                                                                                                                                    Sarcastic and a strawman.

                                                                                                                                    Who knows what kind of whacky fascist programming paradigms they might force on us otherwise?

                                                                                                                                    Sarcastic and a strawman.

                                                                                                                                    Here is a what a more honest, direct version of the post would be:

                                                                                                                                    I think people should be allowed to express controversial and offensive ideas openly. Otherwise, they’re pushed underground where they fester, instead of being brought out into the light where they are exposed to moderation and contradiction.

                                                                                                                                    But that wasn’t the comment we got, and for good reason. The more direct version wouldn’t be posted because it is immediately obvious that it isn’t related to this topic. The response to it might be

                                                                                                                                    The author is just talking about what makes her uncomfortable in most programming community spaces, and why the Recurse center was so valuable for her. She isn’t making an argument or saying you need to feel the same way.

                                                                                                                                    Thus it is clear that the comment, even in a less caustic form, isn’t particularly relevant. I mean, look at the originally quoted snippet in wyager’s post: it’s just a list of facts.

                                                                                                                                    1. 0

                                                                                                                                      “controversial and offensive” is a fluid social contract that changes with audience and context. The big problem is nobody can ever agree on what is controversial and offensive. At the same time people’s nuanced opinions are routinely caricatured as the most extreme version (in both directions, and I’m guilty of it too) then paraded on social media to people with no context.

                                                                                                                                      1. 3

                                                                                                                                        I try my best to avoid the words controversial and offensive. Constructive and destructive are less weighed down with baggage and relativity (though there is always room for people to mess with words). Constructive moves the conversation forward. Destructive moves it backwards.

                                                                                                                                        At the same time people’s nuanced opinions are routinely caricatured as the most extreme version […] then paraded on social media.

                                                                                                                                        Yeah, I’m a bit detached from it since I don’t use Twitter or Facebook, this being a primary reason. It’s a good example of destructive conversation. Nobody ever learns from it, nothing really improves.

                                                                                                                                      2. -5

                                                                                                                                        I’m very sorry I didn’t use the exact rhetorical style you were hoping for. In the future I will avoid using sarcasm and any other rhetorical technique that you don’t like is “destructive”.

                                                                                                                                        1. 5

                                                                                                                                          God forbid you say what you mean.

                                                                                                                                          Come off it, you know it isn’t about what I happen to prefer. If you don’t know better, then you should.

                                                                                                                                    2. 3

                                                                                                                                      Hm, I suppose it did completely derail this thread

                                                                                                                                  2. 10

                                                                                                                                    I doubt it. She’s making political points in the post instead of just talking about good things at Recurse Center. She’s putting it front and center in people’s minds as they read. Anyone reading it deserves to respond to that. That automatically means a thread might get political. It’s definitely her intention.

                                                                                                                                    Predictably, someone responded to it with thread turning to the tangent. Ive had enough politics for the week, though. So, just pointing out the obvious that statements like hers with accusations against a bunch of programmers or political statements will definitely get a reaction. She couldve got the points across without that but wanted it political.

                                                                                                                                    1. 10

                                                                                                                                      She’s not allowed to talk about politics? She makes a fairly common point: she finds the environment around programming often unpleasant or hostile and she wanted to avoid that. So she did. Many people, including myself, are put off by people who sound like that Google Memo person or worse and try to avoid it. If that makes other people uncomfortable, that’s too bad.

                                                                                                                                      1. 8

                                                                                                                                        wyager is allowed to counter her politics if she is going to bring it up. It’s not “what she was trying to avoid.” It’s what she or anyone else should expect saying what she did. All Im saying.

                                                                                                                                        Your initial comment read like one should be able to make negative, political characterizations of programmers with no reply expected.

                                                                                                                                        1. 10

                                                                                                                                          I guess for me it’s not who’s “allowed” to “counter” things or not, but is this actually a useful discussion? The comment reads to me as a wordy way of saying “I disagree with your politics”, which, ok, but what does that add? When I read the original post I could already guess some people would disagree, sure. A person doesn’t have to reply to every in-passing comment they disagree with on the internet. It wasn’t even the main point of the post!

                                                                                                                                          I’ve noticed more discussions here lately being sort of tangential sniping threads. I posted an article a few weeks ago and the entire discussion was a thread about whether people like PDFs. Ok, fine, but I posted a research paper, and the fact that you don’t like PDFs isn’t really on-topic, novel, or interesting. And then there was one last week where someone didn’t like that the title of an article ended with a question mark. I think we could use less of that kind of thing.

                                                                                                                                          1. 2

                                                                                                                                            I’ve noticed more discussions here lately being sort of tangential sniping threads. I posted an article a few weeks ago and the entire discussion was a thread about whether people like PDFs.

                                                                                                                                            I agree with this. It happens in political threads so much I voted against politics in meta. I can’t overemphasize that since, yet again, one disagreement with a political point in a submission created another situation like this. I basically just represent the dissenting side if they’re getting dogpiled or call out double standards when people pretend it’s about logic or civility rather than politics.

                                                                                                                                            I totally agree, though, about the sniping thing with me preferring some kind of rule against it if not politics in general. Maybe in addition to. It should make for a quality improvement. I’m still fine with tangents, though, so long as they’re adding insight to a discussion like the meta stuff I try to do connecting sub-fields.

                                                                                                                                          2. 7

                                                                                                                                            But he didn’t counter her politics, he attacked her. She didn’t call for suppressing anyone’s speech. She simply said she found a certain common mode of speech in tech, a mode I find offensive too, to be unpleasant and wanted to avoid it. There is no sensible way to take issue with that.

                                                                                                                                            1. 7

                                                                                                                                              She said this about programming:

                                                                                                                                              “A lot of bad things in the world have been created by programmers: software for operating drones that bomb civilians, data-mining that violates privacy, companies that “disrupt” by dropping vast amounts of capital in to a market without any intention of building a sustainable business. A lot of bad people love programming: open source thought leaders who harbor deeply racist views, authors of popular databases who discuss their sexist ideas openly, neo-reactionaries leading functional programming conferences. “

                                                                                                                                              She painted a picture of programming as if it was mostly bad things done by bad people. She painted the picture that people going to thought leaders, doing database work, or getting involved in functional programming were only going to be dealing with the worst. You’d think the profession was one of most horrible ever invented reading that stuff. Don’t ask that she properly qualify that: take her word for it without any of your own comments or reactions. She is attacking most programmers with a programmer, @wyager, reacting to that statement.

                                                                                                                                              When a man here said something similarly negative about tech industry, several of us countered him pointing out how he was vastly overstating the problem projecting the worst groups onto the average or majority in a way that was unfair to them. Like her, he exclusively considered the bad things and people in tech when judging the field instead of the vast amount of decent or productive things programmers have done many of whom were OK people. We also suggested maybe he avoid the worst if we couldn’t get rid of them since they were ultimately unnecessary to interact with being a drop in the bucket of the many people and resources out there. I don’t remember all these people being there supporting his view shocked anyone disagreed with him. This one was a woman with different set of politics. Let’s see what happened.

                                                                                                                                              So, wyager responds with a political comment that looks very motivated by emotion lacking qualifiers, consideration to others, or evidence much like Sophie’s. While Sophie’s ad hominem is allowed to stand, you imply his rhetoric shouldn’t be present at all. @jules deconstructs his aiming for purely logical or information content with some strawman which was not done to Sophie’s (or most here with similar viewpoints). @mjn said it was not adding anything new which was true about Sophie’s (or most here with similar viewpoints). These replies are exclusively given to people whose politics each person disagrees with but not people doing same things whose politics each agrees with. They’re held to a lesser standard. So, rather than it being what it appears, these comments aren’t really about addressing civility, information vs rhetorical content, and so on. You all mostly ignore those attributes for comments supporting your type of views while downvoting for opposite naturally leads to dominance of your side in those threads. As in, it’s political maneuvering by folks of one type of views against another rather than quality assurance with any consistency.

                                                                                                                                              Here’s a few where those writing thought wyager and others disagreeing were supposed to nod saying it makes sense with what happens next being too ironic and obvious:

                                                                                                                                              “How dare women suggest tech and especially programming is a potentially hostile environment one might not want to enter!” (fwg) (my emphasis added)

                                                                                                                                              “But one group actually gets to say racist, sexist, discriminatory stuff and remain in charge. The other can hardly speak on panels and post on their blogs without the whole world jumping down their throats.” (jules) (emphasis added)

                                                                                                                                              “I’m not allowed to respond about politics?” (wyager)

                                                                                                                                              “I missed the part where anyone asked for you to be deprived of that right.” (vyodaiken)

                                                                                                                                              You must have missed yourself and the others basically telling him to shut up, the downvotes adding up by a vocal minority, and wyager’s thread collapsing into oblivion where it isn’t seen unless we expand it. Quite unlike most low-info-content, political comments here that are in favor of view’s like Sophie’s not disappearing. Doesn’t look like Sophie or other women with her views would be facing the “hostile environment” with “censorship” and people “deprived” of the right to speak. That contrived scenario is instead what people that agree with her were doing to others who express themselves in a similarly low-evidence, rhetorical way like Sophie or some of their crowd, but with different views. Some of these talk about how everyone is out to get people on their side of spectrum in the same thread where they disappear their opponents’ claims. As opposed to just disagreeing or discussing. Then, they defend the low-quality, repetitive, rhetorical statements of people like Sophie on the same threads since they agree with their views.

                                                                                                                                              Gotta love politically-motivated double standards for discourse that exclusively benefit one side. Also, people talking about how folks on their side have a lot to worry about as sub-threads their opponents make sink and disappear with some clicks. That’s just too rich in reality distortion.

                                                                                                                                              1. 6

                                                                                                                                                You are completely inverting what is happening. Sophie Haskins wrote her opinion. A lot of people here are apparently very angry and want her to shut up. They position their arguments as if she argued for censorship which is a lie and are attempting to shout her down. If you disagree with her opinions, you could say: “My experience is that most programmers are nice” or “It doesn’t matter to me if people who have interesting technical ideas are racists” or otherwise - you know - disagree. But you are not doing that. Instead you are offended that she expressed her opinion and are inventing this whole oppressive regime that wants to suppress your opinions. There is a difference between freedom of speech and impunity. If people want to express racist opinions, for example, they don’t have a right to have other people applaud or pass over in silence or even listen to them. This is exactly the issue of the Google Memo. Its author is free to proclaim all sorts of men’s rights and racist claptrap on his own time, but he has no right to either have his coworkers refrain from reacting to it or have his employer decide that offensive speech in the workplace is ok. The toxic atmosphere of many tech forums is a reality. You should make an effort to understand what Sophie Haskins actually wrote instead of leading a Crusade for the right to be socially acceptable while denigrating others.

                                                                                                                                                1. 2

                                                                                                                                                  “You are completely inverting what is happening. Sophie Haskins wrote her opinion.”

                                                                                                                                                  Her opinion did not happen in isolation. You yourself mentioned that along with some other people. She is part of a group of people that are concerned with and speaking out about bad actors in tech. That’s all I’m certain about right now. Instead of being fair as you expect of me, she paints an exclusively-negative picture of tech’s contributions and the kind of people in it. As she wonders/worries aloud, what she describes is pretty far from reality of a diverse field with all kinds of people in it that mostly don’t do horrible stuff. Majority just support businesses that provide some value to consumers in the economy. Many are also volunteers in FOSS on code or communities. Many other writers whose work was submitted, including about every woman, had a more balanced view in their writing. The exceptions were those all-in on a specific brand of politics that frames tech in terms of race and gender. She writes more like them.

                                                                                                                                                  “Instead you are offended”

                                                                                                                                                  I’m neither offended, nor did I reply to her. I countered you, not her. I discussed other things as people brought them up. People like her trash-talking whole fields is something people do all the time in many ways. I don’t get offended so much as roll my eyes just to maintain peace of mind if nothing else. Whereas, people expecting nobody to reply to or counter a false, negative claim does concern me. That’s allowing one side to discuss but suppressing another in a place where that can define community norms. I often get involved when that happens. All I was doing initially before other claims appeared.

                                                                                                                                                  Now, you’re talking about racism, denigration, etc that we shouldn’t tolerate. The first to do that was Sophie in her unfair characterization of the field. If you think that’s unfair perception, then you can test if that kind of comment is acceptable to people with opposing views in this thread by going to any forum where they’re dominant submitting this version of Sophie’s claims: a white male is concerned about about going to a workplace, conference, or CompSci courses at specific colleges because “there are some bad programmers” who “hate men” behind filesystem development, “hate whites” organizating at major colleges, and support “radical views” leading community teams of major projects. Each of these people exist in the field with groups of people backing them who will shout down or eject opponents within their area of influence. So, the person you’ll ghost-write as is a non-radical, friendly, white male who is concerned about getting into programming should they run into those people they’ve read about. They just worded it like Sophie did in their context.

                                                                                                                                                  What do you think would happen? We can guess based on prior replies to claims like that. Detractors would show up in large numbers immediately citing evidence showing most people aren’t like what he worries about. They’d say he shouldn’t denigrate entire groups like women or non-whites based on behavior of a small amount. Some would say racism against whites or sexist against men are impossible based on their redefinitions of those words that make it maybe impossible. Others would say it’s unrealistic worrying to point he should know better or even distracts from “real” problems (i.e. their worries). Probably some evil, political intent since only a X-ist would say it. If he said that wasn’t his intention, they’d force him to be clear on a version they were cool with. They’d tell him he should phrase his writing more appropriately so others who are different feel safe in that space. That he must think in terms of how people might read that. The person would be dismissed as a racist, sexist idiot as they dogpiled him like many others have.

                                                                                                                                                  When this woman did it, we’re supposed to assume the best with no concerns about larger implications of what she’s saying in terms of what’s in her head or perception of what she writes. Countering it on just incorrectness like we’d do anything else is now not just dismissing bad ideas or statements: it’s “toxic behavior” that needs to be stamped out. Nah, someone said some political BS on the Internet with disagreement of various quality following. Something we do for any kind of claim here. She doesn’t deserve special treatment or defense of her poor arguments/methods any more than a male does.

                                                                                                                                                  To males, you usually have quick, small rebuttals of ideas you disagree with (esp on tech) where you didn’t do a full exploration of everything they might be thinking before you countered. It’s pretty clear you do a quick take on what they might mean, compare it to your own beliefs, and fire an efficient response. Most people do that most of the time I’d guess. You’re doing the opposite here. Whereas, I’m treating her equally to anyone else by protecting dissent and countering her overly-negative claims like I already did to a man who did the same thing before. Like I’ve done to a lot of people’s claims here and everywhere else. Clearly a political bias in action on other side if expecting her claims to get a level of acceptance or no critique that’s not expected of men here or for other topics. I say they all get treated the same from agreement to critiques or we don’t discuss that stuff at all.

                                                                                                                                                  I’ve said enough for this part of this thread as both our views are plenty clear.

                                                                                                                                                2. 5

                                                                                                                                                  She painted a picture of programming as if it was mostly bad things done by bad people . . . You’d think the profession was one of most horrible ever invented reading that stuff.

                                                                                                                                                  This is not a reasonable conclusion to draw from the passage you quoted.

                                                                                                                                                  1. 1

                                                                                                                                                    She painted a picture of programming as if it was mostly bad things done by bad people. She painted the picture that people going to thought leaders, doing database work, or getting involved in functional programming were only going to be dealing with the worst. You’d think the profession was one of most horrible ever invented reading that stuff. Don’t ask that she properly qualify that: take her word for it without any of your own comments or reactions. She is attacking most programmers with a programmer,

                                                                                                                                                    This conclusion is bonkers.

                                                                                                                                              2. 2

                                                                                                                                                She’s not allowed to talk about politics?

                                                                                                                                                I’m not allowed to respond about politics?

                                                                                                                                                1. 3

                                                                                                                                                  I missed the part where anyone asked for you to be deprived of that right.

                                                                                                                                              3. 1

                                                                                                                                                I doubt it. She’s making political points in the post instead of just talking about good things at Recurse Center. She’s putting it front and center in people’s minds as they read.

                                                                                                                                                Those “political points” are some of the more important “good things” about the Recurse Center.

                                                                                                                                              4. -5

                                                                                                                                                is there a latin phrase for “does your mom know you’re gay?”

                                                                                                                                            1. 2

                                                                                                                                              bad performance on low-end devices (and I suspect higher battery consumption, but can’t really proof this one)

                                                                                                                                              I’d actually argue the opposite here. With a traditional web app you’re sending HTML across, and you’re doing a lot of parsing each time a page loads. Parsing HTML is an expensive operation. With SPA style apps, you load the page once and pass JSON around containing just the data that needs to be loaded. So, after initial load, you should expect to get better resource utilization.

                                                                                                                                              1. 6

                                                                                                                                                I’m not sure that parsing HTML is as expensive as parsing (and compiling) Javascript though. Of course you’d pay a high price at each request of an e-commerce web app, but if you want to read an article on some blog, it is faster when you don’t have to load all of Medium’s JS app.

                                                                                                                                                Browser vendors are trying really hard to fasten the startup time of their VM but the consensus is that to get to Interactive fast, you should ship less JS or at least less JS upfront.

                                                                                                                                                Obligatory pointer to Addy Osmani’s research on the topic https://medium.com/@addyosmani

                                                                                                                                                1. 1

                                                                                                                                                  Parsing XML is notoriously expensive. In fact, it’s one of the rationales behind Google’s protocol buffers. Furthermore, even if the cost of parsing XML and JSON was comparable, you’d still be sending a lot more XML if you’re sending a whole page. Then that XML has to be rendered in the DOM, which is another extremely expensive operation.

                                                                                                                                                  To sum up, only pulling the data you actually need, and being able to repaint just the elements that need repainting is much faster than sending the whole page over and repainting it on each update.

                                                                                                                                                  1. 3

                                                                                                                                                    The problem is that incremental rendering is often paired with a CPU intensive event listener and digest loops and other crud causing massive amounts of Javascript for every click and scroll.

                                                                                                                                                    1. 1

                                                                                                                                                      That’s not an inherent problem with SPAs though, that’s just a matter of having a good architecture. My team has been building complex apps using this approach for a few years now, and it results in a much smoother user experience than anything we’ve done with traditional server-side rendering.

                                                                                                                                                2. 4

                                                                                                                                                  This seems like the exact kind of thing we can empirically verify. Do you know of any good comparisons?

                                                                                                                                                  1. 1

                                                                                                                                                    I haven’t seen any serious comparisons of the approaches. It does seem like you could come up with some tests to compare different operations like rendering large lists, etc.

                                                                                                                                                  2. 2

                                                                                                                                                    I’m not so sure, a modern HTML parser is fairly efficient. On top of that, a lot of stuff is cached in a modern browser.

                                                                                                                                                    My blog usually transfers in under 3 KB if you haven’t cached the page, around 800 B otherwise (which includes 800 bytes from Isso). My website uses less than 100KB, most of which is highly compressed pictures.

                                                                                                                                                    Most visitors only view one page an leave so any SPA would have to match load performance with the 3 KB of HTML + CSS or the 4KB of HTML+CSS plus 100KB of images…

                                                                                                                                                    A similar comparison would be required for any traditional server-side rendering application; if you want to do it in SPA, it should first match (or atleast come close to) the performance of the current server for the typical end user.

                                                                                                                                                    SPAs are probably worth thinking about if the user spends more than a dozen pages on your website during a single visit and even then it could be argued that with proper caching and not bloating the pages, the caching would make up a lot of performance gains.

                                                                                                                                                    Lastly, non-SPA websites have working hyperlink behaviour.

                                                                                                                                                    1. 1

                                                                                                                                                      I think that if your site primarily has static content, then server side approach makes the most sense. Serving documents is what it was designed for after all. However, if you’re making an app, something like Slack or Gmail, then you have a lot of content that will be loaded dynamically in response to user actions. Reloading the whole page to accommodate that isn’t a practical approach in my opinion.

                                                                                                                                                      Also, note that you can have working hyperlink behavior just fine with SPAs. The server loads the page, and then you do routing client-side.

                                                                                                                                                      1. 1

                                                                                                                                                        Also, note that you can have working hyperlink behavior just fine with SPAs. The server loads the page, and then you do routing client-side.

                                                                                                                                                        That’s how it would work in theory, however, 9/10 SPAs I meet don’t do this. The URL of the page is always the same, reloading looses any progress and I can’t even open links in new tabs at all or even if I can, it just opens the app on whatever default page it has.

                                                                                                                                                        Even with user content being loaded dynamically, I would considering writing a server app unless there will be, as mentioned, a performance impact for the typical user.

                                                                                                                                                        1. 1

                                                                                                                                                          That’s a problem with the specific apps, and not with the SPA approach in general though. Moving this logic to the server doesn’t obviate the need for setting up sane routing.

                                                                                                                                                          1. 1

                                                                                                                                                            I’ve sadly seen SPA done correctly only rarely, it’s the exception rather than the rule in my experience.

                                                                                                                                                            So I’m not convinced it would be worth it, also again, I’m merely suggesting that if you write an SPA, it should be matching a server-side app’s performance for typical use cases.

                                                                                                                                                            1. 1

                                                                                                                                                              I agree that SPAs need to be written properly, but that’s just as true for traditional apps. Perhaps what you’re seeing is that people have a lot more experience writing traditional apps, and thus better results are more common. However, there’s absolutely nothing inherent about SPAs that prevents them from being performant.

                                                                                                                                                              I’ve certainly found that from development perspective it’s much easier to write and maintain complex UIs using the SPA style as opposed to server-side rendering. So, I definitely think it’s worth it in the long run.

                                                                                                                                                              1. 1

                                                                                                                                                                I’ve built enough apps both ways now to feel confident weighing in.

                                                                                                                                                                If you build a SPA, your best case first impression suffers (parsing stutters etc), but complex client side interaction becomes easy (and you can make it look fast because you know which parts of the page might change).

                                                                                                                                                                I no longer like that tradeoff much; I find too few sites really need the rich interactivity (simple interaction is better handled with jquery snippets), and it’s easier to make your site fast when there are fewer moving parts.

                                                                                                                                                                This might change as the tooling settles down; eg webpack is getting easier to configure right.

                                                                                                                                                                1. 2

                                                                                                                                                                  The tooling for Js is absolutely crazy in my opinion. There are many different tools you need to juggle, and they’re continuously change from under you. I work with ClojureScript, and it’s a breath of fresh air in that regard. You have a single tool for managing dependencies, building, testing, minifying, and packaging the app. You also get hot code loading out of the box, so any changes you make in code are reflected on the page without having to reload it. I ran a workshop on building a simple SPA style app with ClojureScript. It illustrates the development process, and the tooling.