1. 17

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

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

    1. 45

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

      1. 14

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

        1. 19

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

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

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

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

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

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

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

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

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

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

            1. 3

              that was certainly not my intention.

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

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

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

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

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

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

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

            1. 2

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

              1. 1

                It is an important feature of OCaml.

                1. 3

                  I am aware - was focusing on dynamically typed languages.

              2. 7

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

                1. 1

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

                  1. 1

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

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

              3. 11

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

                I find it surprising that people find this surprising.

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

                1. 3

                  That’s always been the Scheme philosophy:

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

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

                  1. 4

                    No changes to the core language needed.

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

                    1. 5

                      This is rather unrelated to the overall discussion, but as a user of the match macros in Scheme, I must say that I find the lack of integration into the base forms slightly annoying. You cannot pattern-match on a let or lambda, you have to use match-let and match-lambda, define/match (the latter only in Racket I think), etc. This makes reaching for pattern-matching feel heavier, and it may be a partial cause to their comparatively lower usage. ML-family languages generalize all binding positions to accept patterns, which is very nice to decompose records for example (or other single-case data structures). I wish Scheme dialects would embrace this generalization, but they haven’t for now – at least not Racket or Clojure.

                2. 8

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

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

                  1. 5

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

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

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

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

                    Rather than:

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

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

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

                    looks like pattern matching to me

                    1. 2

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

                      1. 5

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

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

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

                        1. 3

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

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

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

                      2. 3

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

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

                        1. 25

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

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

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

                          1. 7

                            less useful in presence of list comprehension

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

                            1. 6

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

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

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

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

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

                              1. 8

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

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

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

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

                                Well, I claimed

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

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

                                1. 4

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

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

                                  1. 4

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

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

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

                                2. 4

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

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

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

                                  1. 2

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

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

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

                                    1. 1

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

                                      1. 5

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

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

                                    2. 5

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

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

                                    3. 1

                                      I think the issue is more about pattern matching being a late addition to Python, which means there will be lots of code floating around that isn’t using match expressions. Since it’s not realistic to expect this code to be ported, the old style if … elif will continue to live on. All of this adds up to a larger language surface area, which makes tool support, learning and consistency more difficult.

                                      I’m not really a big fan of this “pile of features” style of language design - if you add something I’d prefer if something got taken away as well. Otherwise you’ll end up with something like Perl 5

                                    1. 3

                                      I remember trying to learn C++ for Win32 when I was a kid. The amount of boilerplate and int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow);, just to get “Hello, World!” going made the threshold too high. After QBasic and Turbo Pascal, I started learning 16-bit and 32-bit Assembly instead, and it was much easier.

                                      If I were to teach programming to a beginner today, I would start with Crystal, because:

                                      • It has a human friendly Ruby-like syntax.
                                      • It compiles to native. It’s conceptually satisfying to be able to go from a short program to an actual executable.
                                      • No boilerplate is needed to get going with a real program.
                                      • No #!/usr/bin/env python and # -*- coding: utf-8 -*-. No if __name__ == "__main__" (which are not strictly needed, but commonly used).
                                      • No weird operator overloaded std::cout << ... << std::endl;.
                                      • No (cdr (cons 'SUBJECT 'VERB)). Heads attached to tails is not an intuitive way to think about a list of three numbers.
                                      • No abbreviated printf("%2$d %2$#x; %1$d %1$#x",16,17) (which is handy later on, but cryptic to a beginner).
                                      • Going up one abstraction level in Crystal, to if or def does not require to keep track of indentation, curly brackets or parentheses. The block just ends with end.

                                      After that, I would set up a fun domain that pointed to a Linode or Cloud server that was running a simple Crystal web server. Then I would set up a GitLab git repository with CI, so that when the kid made changes to the simple Crystal web server and typed git push, the domain would reflect the changes or they could check the CI web page if the test failed. This way they could experiment with the code and also easily share the results with friends and family, just by giving them the domain (“kids-name-says-hello.com”).

                                      They would also learn modern development practices, but with the low threshold of only having to:

                                      • Edit a very short Crystal source file.
                                      • Learning to type git commit -a -m "Message" and git push.
                                      • Check the CI pipeline web page for if there were any issues.

                                      The next step could be to teach them very basic HTML (no CSS) and how to add images to the web page, and then how to play sounds if images are clicked on. Add silly noises and it’s bound to be a hit.

                                      The next goal after that would be to draw colorful circles on that web page by using TypeScript.

                                      With basic Crystal, HTML, git usage and TypeScript under their belt, they should have a solid start. Once they were ready for it, creating a small game with Crystal and SFML, or in TypeScript, would be a possibility.

                                      Of course, all kids are different and are motivated by different things, but this is one of many possible ways I would envision that someone could get into programming and find it interesting and fun, with an emphasis on being able to share the results.

                                      1. 1

                                        No #!/usr/bin/env python and # -- coding: utf-8 --. No if __name__ == “__main__”.

                                        I agree these things are weird but you absolutely don’t need them to start hacking around in Python.

                                        1. 2

                                          I agree, but having to keep track of indentation levels is still a disadvantage of Python. At least in the very beginning, IMO.

                                      1. 41

                                        The whole bloody web stack. It’s an insane pile of dodgy shit.

                                        No I don’t mean rewrite firefox or something like that. A complete tear down and redesign.

                                        1. 8

                                          Developers always want to rewrite code and think that almost everything that has been written before is bad. This can be correct, but is often wrong.

                                          This subjective opinion needs more substance to not be brushed off as yet another developer calling something “bad”, IMO.

                                          1. 6

                                            This subjective opinion needs more substance to not be brushed off as yet another developer calling something “bad”, IMO.

                                            Yet it’s the third most upvoted opinion, so I suspect there’s something to it!

                                            I’ll take a stab at my view into why JohnCarter is right. “The web” today could mean anything along a spectrum of

                                            • The display of plain text
                                            • The display of hypermedia
                                            • Systems that allow basic CRUD operations on hypermedia
                                            • Rich web applications
                                            • The browser as an executable container - think of WebGL games
                                            • A whole damn OS that supports peripherals

                                            There are two dramatically different models at play: on one end, the website as document makes perfect sense. But when you’re building a WebGL/WASM app that lets you plug your piano in, what does a DOM get you anyways?

                                            And we live in the annoying middle: HTML/JS/CSS has become the lowest common denominator, but devs are free to pick and choose from higher in the spectrum without any real negative feedback – which means a browser is no longer something any one person can really understand, let alone build. As a result, only the worlds largest advertising company can really keep up with delivering one.

                                            So if I could wave the magic wand and build the world from scratch I’d either make the browser subsume the entire OS – give me a rumpkernel that boots Firefox, no POSIX no nothin, OR I’d draw a line and make browsers “things that can render hypermedia” or “things that can do arbitrary network connections/rendering and drawing”, and if you tried to make one do the other you’d be laughed out of the room.

                                            1. 3

                                              Slight misunderstanding here…. @owen is on to it.

                                              I don’t think I can rewrite firefox better. Don’t want to even try.

                                              Look at it this way. If I printed out the whole stack of standards the current firefox or chrome is based on and told you to read them…..

                                              It would be stack of paper insanely high, a fair bit of it would not be complied with, a vast stack would be in the per browser docs and a another large bit would not even be documented.

                                              A large chunk of the reason for the massive ecosystem of javascript frameworks is they have been tested into the shape of something that sort of works on the main browsers.

                                              If you looking for consistency of design or architectural principles…. you might find traces in the older stuff… and then a flood of “ah, shit. Let’s just maximally kludge what we have to make cool shit” thereafter.

                                              I believe the point of consistency of design and of architectural principles is to select the trade off points you wish to hit and then permit the implementer and clients to rely on massively simplifying assumptions.

                                              ie. If you do that well, you explicitly take some use cases off the table, but make everything literally several orders of magnitude simpler and easy to understand, implement and use.

                                              1. 1

                                                Developers always want to rewrite code and think that almost everything that has been written before is bad. This can be correct, but is often wrong.

                                                I agree with the first bit, but not the second. Almost everything in the software world. The bit people are often wrong about is the idea that rewriting it will give something less bad.

                                            1. 4

                                              If the internet stopped functioning, would you be left helpless?

                                              Yes, in terms of application deployment, I think all of us would.

                                              1. 11

                                                Most important addition: we now have :smile!

                                                kinda

                                                1. 3

                                                  The :smile command is there, but the feature seems to be broken. It does not smile.

                                                1. 24

                                                  This is getting tiresome. It’s always the same points rehashed. Why beat the same dead horse?

                                                  1. 12

                                                    Because they are beating a dead horse and ignoring that Go is an excellent pony.

                                                    Many languages are weak at limiting ever expanding dependencies and build times. Go addresses this, and also has an excellent deployment story.

                                                    Go was created partly out of frustration with C++ within Google and addresses many things that takes years to see that are problems in the first place.

                                                    1. 6

                                                      This. Go does a lot of things wrong, but it got so much things right, ebough to make itself relevant.

                                                      1. 6

                                                        … addresses many things that takes years to see that are problems in the first place.

                                                        Very eloquently said. Throwing the kitchen sink into a language means supporting a ton of problematic patterns and footguns.

                                                        For example, even though I think everyone, even in the Go community, accepts that generics are pretty useful, doing them well means trade-offs. When you’ve seen some of the bizarre ways people abuse them in C++, it should give you pause that they’re always-good-no-caveats. Which is why the Featherweight Go paper that forms the model for Go’s eventual generics plan is heartening — it may not be perfect either, but it applies some wisdom to the right way to go about it without jumping into the deep end.

                                                        1. 4

                                                          C++ templates are also unusually terrible as far as templates go. I don’t think this is a strong argument.

                                                          I think this is less “Templates let you write really bad code” and more “C++ lets you write really bad code with templates.” For instance, D templates are much nicer - and more powerful.

                                                      2. 9

                                                        This is getting tiresome. It’s always the same points rehashed. Why beat the same dead horse?

                                                        As someone who changed languages from PHP to Go, after all these years I … still have no clue why people feel the need to do that.

                                                        But I’ve learned to smile. In my imagination I pat the “smart” developer on the head and just continue with my day. You know, making useful stuff that people like. If people need to vent, let them vent. But don’t take a blog post as gospel, just because it contains a lot of strong opinions.

                                                        1. 6

                                                          Why beat the same dead horse?

                                                          Usually because someone is forcing them to write Go and the terrible pain it causes them squirts out in a blog post.

                                                          1. 3

                                                            I do not see how anybody is “forced” to write Go. The market is so hot right now that anyone can just switch jobs if they are forced to program in a language they do not like.

                                                          2. 2

                                                            It looks like the author is a D-lang person.

                                                            You know the meme, about D programmers, misunderstood who think their language is the best, etc.

                                                            1. 4

                                                              The goal is definitely GNU-free, but yea, it still depends on gmake to build some packages. It’s the only GNU dependency, too. A gmake replacement would finish the job.

                                                              1. 4

                                                                Seems that you would have to replace freetype as well.

                                                                Curious to read a little bit more about the rationale though. What’s so wrong about GNU software?

                                                                1. 20

                                                                  I think one advantage is that GNU has had something of a “monopoly” in a few areas, which hasn’t really improved the general state of things. The classic example of this is gcc; everyone had been complaining about its cryptic error messages for years and nothing was done. Clang enters the scene and lo an behold, suddenly it all could be improved.

                                                                  Some more diversity isn’t a bad thing; generally speaking I don’t think most GNU projects are of especially high quality, just “good enough” to replace Unix anno 1984 for their “free operating system”. There is very little innovation or new stuff.

                                                                  Personally I wouldn’t go so far so make a “GNU free Linux”, but in almost every case where a mature alternative to a GNU project exists, the alternative almost always is clearly the better choice. Sometimes these better alternatives have existed for years or decades, yet for some reason there’s a lot of inertia to get some of these GNU things replaced, and some effort to show “hey, X is actually a lot better than GNU X” isn’t a bad thing.

                                                                  1. 8

                                                                    A LOT of people have soured on GNU/FSF as a result of the politics around RMS and the positions he holds.

                                                                    1. 3

                                                                      A lot of people were soured on them long before that; the whole GPL3 debacle set a lot of bad blood, the entire Open Source movement was pretty much because people had soured on Stallman and the FSF, the relentless pedantry on al sorts of issues, etc. Of course, even more people soured on them after this, but it was just the last in a long line of souring incidents.

                                                                      Was (re)watching some old episodes of The Thick of It yesterday; this classic Tucker quote pretty much sums up my feelings: “You are a fucking omnishambles, that’s what you are. You’re like that coffee machine, from bean to cup, you fuck up.”

                                                                      1. 1

                                                                        For sure. Never seen The Thick Of It but I love Britcoms and it’s on my list :)

                                                                        I’ve always leaned towards more permissive licenses. We techies love to act as if money isn’t a thing and that striving to make a living off our software is a filthy dirty thing that only uncool people do.

                                                                        And, I mean, I get it! I would love NOTHING more than to reach a point in my life where I can forget about the almighty $ once and for all and hack on whatever I want whenever I want for as long as I want! :)

                                                                    2. 4

                                                                      Yeah, when I hear “GNU” I think cruft. And this is from someone who uses emacs! (I guess you could argue it’s the exception that proves the rule, since the best thing about emacs is the third-party ecosystem).

                                                                      And this is only about GNU as an organization, to be clear. I have no particular opinions on the GPL as a license.

                                                                      1. 2

                                                                        Even Emacs is, unfortunately, being hampered by GNU and Stallman, like how Stallman flat-out refused to make gcc print more detailed AST info for use in Emacs “because it might be abused by evil capitalists”, and the repeated drama over the years surrounding MELPA over various very small issues (or sometimes: non-issues).

                                                                        1. 2

                                                                          Yeah, it’s really unfortunate :/

                                                                    3. 12

                                                                      From the site:

                                                                      Why
                                                                      • Improve portability of open source software
                                                                      • Reduce requirements on GNU packages
                                                                      • Prove the “It’s not Linux it’s GNU/Linux …” copypasta wrong
                                                                      1. 2

                                                                        Why not? (I’m not affiliated with the project, you’d have to ask the people maintaining it)

                                                                        1. 6

                                                                          Yeah, “why not?” is a valid reason imvho. I would like to know which one it theirs in actuality. I often find that the rationale behind a project is a good way to learn things.

                                                                          And fair enough, I assumed you were affiliated. FWIW, Freetype is not a GNU project, but it is indeed fetched from savannah in their repos, which I found slightly funny.

                                                                          ETA: it also seems to be a big endeavor so the rationale becomes even more interesting to me.

                                                                          1. 1

                                                                            My rationale was partially to learn things, partially for the memez and partially as an opportunity to do things the way I want (all these people arguing about init systems, iglunix barely has one and I don’t really need anything more). I wanted to do Linux from scratch to learn more about Linux but failed at that and somehow this ended up being easier for me. I think I definitely learnt more trying to work out what was needed for myself rather than blindly following LFS.

                                                                        2. 1

                                                                          There is nothing inherently wrong with gnu software; I just like to have choice.

                                                                          1. 1

                                                                            Freetype is available under its own permissive license.

                                                                            1. 1

                                                                              That’s correct! I downloaded https://download-mirror.savannah.gnu.org/releases/freetype/freetype-2.11.0.tar.xz just to double check, and here is the license:

                                                                              FREETYPE LICENSES
                                                                              -----------------
                                                                              
                                                                              The FreeType  2 font  engine is  copyrighted work  and cannot  be used
                                                                              legally without  a software  license.  In order  to make  this project
                                                                              usable to  a vast majority of  developers, we distribute it  under two
                                                                              mutually exclusive open-source licenses.
                                                                              
                                                                              This means that *you* must choose  *one* of the two licenses described
                                                                              below, then obey all its terms and conditions when using FreeType 2 in
                                                                              any of your projects or products.
                                                                              
                                                                                - The FreeType License,  found in the file  `docs/FTL.TXT`, which is
                                                                                  similar to the  original BSD license *with*  an advertising clause
                                                                                  that forces  you to explicitly  cite the FreeType project  in your
                                                                                  product's  documentation.  All  details are  in the  license file.
                                                                                  This license is suited to products which don't use the GNU General
                                                                                  Public License.
                                                                              
                                                                                  Note that  this license  is compatible to  the GNU  General Public
                                                                                  License version 3, but not version 2.
                                                                              
                                                                                - The   GNU   General   Public   License   version   2,   found   in
                                                                                  `docs/GPLv2.TXT`  (any  later  version  can  be  used  also),  for
                                                                                  programs  which  already  use  the  GPL.  Note  that  the  FTL  is
                                                                                  incompatible with GPLv2 due to its advertisement clause.
                                                                              
                                                                              The contributed  BDF and PCF  drivers come  with a license  similar to
                                                                              that  of the  X Window  System.   It is  compatible to  the above  two
                                                                              licenses (see files `src/bdf/README`  and `src/pcf/README`).  The same
                                                                              holds   for   the   source    code   files   `src/base/fthash.c`   and
                                                                              `include/freetype/internal/fthash.h`; they wer part  of the BDF driver
                                                                              in earlier FreeType versions.
                                                                              
                                                                              The gzip  module uses the  zlib license (see  `src/gzip/zlib.h`) which
                                                                              too is compatible to the above two licenses.
                                                                              
                                                                              The  MD5 checksum  support  (only used  for  debugging in  development
                                                                              builds) is in the public domain.
                                                                              
                                                                              --- end of LICENSE.TXT ---
                                                                              
                                                                          2. 4

                                                                            Why would anyone want to write a GNU make replacement when GNU make exists?

                                                                            1. 3

                                                                              Having it under a more permissive license is a very valid reason though. Guess why FreeBSD is writing their own git implementation…

                                                                              If the only tool for a task is closed-source then there is a project trying to make an open-source one. If the only open-source tool for a task is under a copyleft license then there is a project trying to make a non-copyleft one. Once a project is BSD, MIT or public domain we can finally stop rewriting it.

                                                                              1. 2

                                                                                If avoiding copyleft is the goal then the Linux kernel is a weird choice. And important parts of the FreeBSD kernel (zfs) are under a copyleft license too (CDDL).

                                                                                1. 1

                                                                                  I find OpenBSD to be one of the best choices as far as license goes. I’ve been slowly moving all my Debian machines to OpenBSD in the past year (not only because of the license, but because it’s an awesome OS).

                                                                                  1. 1

                                                                                    I haven’t tried using OpenBSD in earnest since are around 1998. I prefer a copyleft to a BSD style license personally but maybe I’ll take another look. And I hear that tar xzf blah.tar.gz might even work these days.

                                                                                    1. 1

                                                                                      It gets improved with every new major release, I’ve used it consistently for the past 3 or 4 releases and there’s always noticeable improvement in performance, user-land tools, drivers, arch support, etc. I’d definitely give it a try again!

                                                                                2. 1

                                                                                  This is fine reasoning but relativized. After all, I could just as easily say that if the only tool for a task is under a non-copyleft license, then there is a project trying to make a GNU/FSF version; once GNU has a version of a utility, we can stop rewriting it.

                                                                                3. 2

                                                                                  They don’t want to do that. They want a non-GNU replacement for GNU make

                                                                                  1. 1

                                                                                    They could just fork GNU make. That would work right?

                                                                                    1. 4

                                                                                      Or use bsdmake.

                                                                                      1. 2

                                                                                        bsdmake is in fact included, but it can’t build all gmake makefiles unfortunately.

                                                                                        1. 3

                                                                                          I used to do a fair bit of packaging on FreeBSD, and avoiding things like GNU make, autotools, libtool, bash, etc. will be hard and a lot of effort. You’ll essentially have to rewrite a lot of project’s build systems.

                                                                                          Also GTK is GNU, and that’ll just outright exclude whole swaths of software, although it’s really just “GNU in name only” as far as I know.

                                                                                        2. 1

                                                                                          No bmake isn’t enough to build the Linux kernel

                                                                                        3. 1

                                                                                          Depends on their goals. Some people don’t like GNU or GPL projects. If that’s the case then probably not.

                                                                                          1. 4

                                                                                            If they don’t like GPL projects then using the Linux kernel is a weird choice.

                                                                                          2. 1

                                                                                            The entire point here is to not contain any GNU code, so no.

                                                                                            1. 5

                                                                                              zlib is derived from GNU code (gzip) so anything that includes zlib or libpng etc will “contain GNU code”. This includes for example the Linux kernel.

                                                                                              1. 6

                                                                                                He didn’t say they’ve achieved their goal. It’s still a goal.

                                                                                                Why does it seem like you’re trying to “gotcha” on any detail you can refute?

                                                                                                It’s just someone’s project.

                                                                                                1. 3

                                                                                                  I’m trying to understand the goal. If the goal is avoiding software that originated from the GNU project that is probably futile. The GNU project has been a huge, positive influence on software in general.

                                                                                                  1. 5

                                                                                                    You know the goal. They stated it. The parent comment to you stated it again.

                                                                                                    It might be futile, but luckily we don’t control other peoples free time and hobbies, so they get to try if they want. You seem to be taking personal offense at the goal.

                                                                                        4. 1

                                                                                          For fun

                                                                                      2. 3

                                                                                        From the site:

                                                                                        Iglunix is a Linux distribution but, unlike almost all other Linux distributions, it has no GNU software¹

                                                                                        ¹With the exception of GNU make for now

                                                                                        1. 1

                                                                                          Yes I still haven’t been able to replace a couple projets. For self hosting gnu make is all that’s left, for chromium bison (and by extension gnu m4) and gperf are all that’s left.

                                                                                        1. 7

                                                                                          Containers are great. They are like universal executables for servers. But Kubernetes can, in my experience, be a major hassle with little benefit.

                                                                                          1. 15

                                                                                            Zig is such a promising language.

                                                                                            I hope it becomes great for deploying applications as well, and plays nicely with various package managers and Linux distros.

                                                                                            Deployment seems to be an afterthought for some programming language ecosystems.

                                                                                            1. 25

                                                                                              Deployment seems to be an afterthought for some programming language ecosystems.

                                                                                              If you check the 4th commit in ziglang/zig repository, the commit that first populated the README.md file with a set of goals for the project, this goal is listed:

                                                                                              • Friendly toward package maintainers.

                                                                                              I’ve been a Debian and Ubuntu package maintainer in the past, and I even picked up another Debian Developer from the airport in order to sign each other’s gpg keys (part of the procedures to gaining upload access).

                                                                                              I’ve also been involved in the Node.js ecosystem - looks like I have 76 packages under my name.

                                                                                              I’m familiar with what distribution maintainers want to achieve for their users, and the problems they are faced with in terms of packaging, as well as what upstream project maintainers want to achieve for their users, and I’m intimately familiar with how these goals can sometimes conflict. I fully intend to use this insight to help both parties work more effectively with each other for the end user when it comes to the Zig package manager, ecosystem, and communities.

                                                                                              1. 3

                                                                                                That sounds perfect! Thanks for creating Zig, I really like the philosophy behind it.

                                                                                                Now all I’m longing for is Zig++, a language just like Zig, but with added syntactic sugar. ;)

                                                                                            1. 11

                                                                                              For embedded, mobile and high-performance computing, Linux-based systems already won, in terms of popularity.

                                                                                              Ruling the desktop OS world and providing a system for people that just want to watch movies and play games has been an implicit non-goal for the Linux community for several decades now, with the exception of a few distros like Ubuntu and Pop!_OS. And that is completely fine!

                                                                                              Linux Desktop users should ideally be part of a whole where the “payment” for using the system is to try to contribute back. This way, everyone benefits, and the community thrives.

                                                                                              Let Android, ChromeOS, Windows, macOS, iOS, Fuchsia, Haiku and others deal with the support burden that these users represents. People that want to contribute and participate can help each other over to Wayland (and possibly Sway as well). People that just want a stable Linux desktop can use Xfce4 + Xorg now and forever and ever.

                                                                                              Triple win.

                                                                                              1. 2

                                                                                                Neovim can now :smile !

                                                                                                It’s not as encouraging as the ViM :smile, though. :)

                                                                                                1. 2

                                                                                                  Swimming in the ocean, reading, creating music and spending time with family. Maybe some hobby/open source programming or an hour of two playing the game of Go.

                                                                                                  1. 15

                                                                                                    I agree. Changing go get to mean go get ...@latest makes more sense than bothering users with deprecation warnings and then changed behavior. Why break the user experience?

                                                                                                    1. 14

                                                                                                      Personally I think it’s massively confusing to change the behaviour of a command based on which directory you’re in.

                                                                                                      What’s the best path forward? I don’t know … but the sooner this “GOPATH/modules schism” goes away in the Go tooling the better IMHO. I’ve been confused about this as well, and I’ve been programming Go full-time for over five years – it’ll be even more confusing for people newer to Go who never worked with GOPATH.

                                                                                                      1. 5

                                                                                                        it’ll be even more confusing for people newer to Go who never worked with GOPATH.

                                                                                                        I’m one of these people! And I still have no idea what GOPATH is all about, other than it causing confusing issues for me when trying to build some go projects :(

                                                                                                        1. 2

                                                                                                          Think of GOPATH as $HOME but only for Go, it’s stdlib, your go projects, and dependencies pulled in. The whole of the Go ecosystem on your computer in one directory.

                                                                                                          1. 3

                                                                                                            I found being forced to use a specific location for projects, set in an env variable, to be confusing and annoying. After my comment above, I read a bit more about modules and that’s definitely how I would have expected things to work from the beginning. Better late than never I suppose!

                                                                                                            1. 1

                                                                                                              I always disliked GOPATH, but it’s not very hard: all code goes in to GOPATH, and that’s pretty much it. Easy-peasy. It’s mostly the two different “modes” that the tooling can operate on that’s confusing and can take you by surprise, especially if you’re not familiar with GOPATH.

                                                                                                      1. 26

                                                                                                        I know Matthias F. I know Matthew B. I know RMS. And other people. I respect their accomplishments. I also know that people can be very difficult. As one friend puts it, some people have a user interface that is broken. I also know that the greater one’s distance from a person, the more likely the depiction of a person can be distorted, showing for example one dimension but not others. As with everything in society these days, I yearn for a way for people to work things out. I don’t want anyone to be ostracized. I don’t want anyone to not feel welcome. This is a very difficult problem, but we must work on it. It is good to talk about these issues, but I want the discussion to be fair. I’m all for inclusiveness, but not at the cost of exclusion.

                                                                                                        1. 57

                                                                                                          This is a classic response to someone calling out people that misbehave. “Bob is not that bad, once you get to know him”. But that’s beside the point!

                                                                                                          If Bob is pushing other people down through his behavior, it is right to criticize his behavior, and maybe also remove responsibility from Bob, no matter how nice he “really” is.

                                                                                                          1. 25

                                                                                                            This is a classic response to someone calling out people that misbehave

                                                                                                            Not to mention that “I’m all for inclusiveness, but not at the cost of exclusion” is an impossible situation to begin with: https://en.wikipedia.org/wiki/Paradox_of_tolerance

                                                                                                            That shit just does not work, as proven time and time again. People looking the other way and making excuses for abusive behavior is how we got to this situation of people being driven out in the first place.

                                                                                                            1. 8

                                                                                                              1000% agreed. This is part and parcel of the technology community having gone mainstream a while ago. The fallacies we used to indulge in to excuse bad behavior are showing themselves to be more and more ugly as we bring them into the light.

                                                                                                              1. 4

                                                                                                                Diversity tends to shine light where it needs it the most.

                                                                                                            2. 8

                                                                                                              I am ranting a bit, and I hope it does not come across as directed at you. I do not mean it that way. I’m a couple of levels down in this thread and it seems like somehow we’ve gone off the rails regarding what the topic is.

                                                                                                              I don’t care if Bob is a good person or not. I care if we’re all being invited to judge him publicly and decide whether he’s good or not. I don’t participate in these activities and I don’t tolerate others that do. Of course, other people are free to do whatever they’d like. My point is that the one unyielding rule I’ve found regardless of context is that productive teams cannot carry on this way with the public story-telling back-and-forth. It’s corrosive. That observation is completely orthogonal to what kinds of behavior I’d tolerate in a team, which, frankly, is nobody’s business but mine and the teams I join. (They also tend to change from situation-to-situation. People aren’t statues, and standards aren’t the Ten Commandments. Situation matters.)

                                                                                                              1. 27

                                                                                                                You speak as though Butterick’s comments are taking place in a vacuum, or worse, are arising unprompted. But please remember that the only reason he feels it necessary to write this piece is that his life has been disrupted, he has suffered poor behavior, and now he has had to withdraw from a community that he had dedicated significant resources to.

                                                                                                                I know you haven’t raised the specter of ‘cancel culture’, but phrasing like ‘we are all being invited to judge him publicly’ speak to a similar enough view of the proceedings; and the fallacy operating with both this critique as well as larger complaints about ‘cancel culture’ is this: you and I come to this post from a null position. This is understandable; we, and the vast majority of readers, are not members of this particular community and have no experience with its members. And from our position of no experience, it seems we are being invited to judge someone we don’t know. That feels icky and unnecessary.

                                                                                                                But Butterick is not asking us to judge someone. I don’t think he cares particularly that we, who have no stake in this, walk away with a solid negative judgment of the personal qualities of another person. What he cares is to provide an account of his experience, because: in light of a widespread taboo against airing dirty laundry, if you didn’t know about his experience, his conduct is confusing and probably not very flattering. Here’s someone who dedicated themselves to a language and a community: wrote code, wrote books about it. And ‘suddenly’ (to an observer), he drops off the map. This represents a loss of social capital, probably a loss of real livelihood, and raises questions about him and his fitness to this kind of work.

                                                                                                                In light of that experience (again, one that is centered around Matthew Butterick and his desire to manage his own reputation and professional prospects, as opposed to a desire to manage your view of a third party), you can hopefully understand why he feels the need to give an account of what he has actually been experiencing, even though that includes the unpleasant work of publicizing the shittiness of another person.

                                                                                                                I will wager with you that, oh, 95 out of 100 of those folks who have publicized the toxicity of leaders, bosses and executives over the last little while have been motivated similarly. In other words, I wager that they too definitely would have preferred to conduct themselves exactly as you prefer: to keep their personal experience private, to settle things through private channels, and to negotiate via their existing personal relationships. Unfortunately, toxic people (abusers, whatever you want to call them) are usually toxic because they have a position, personality, and skill set that neutralizes exactly that approach.

                                                                                                                In conclusion: I invite you to reread that article from the perspective of its author. From the perspective of the uninitiated reader, it would seem to be about some other figure who we don’t know from Adam. But I don’t think it is.

                                                                                                                1. 18

                                                                                                                  I don’t care if Bob is a good person or not.

                                                                                                                  If he’s in your team, you should. The whole problem here exists because people are going out of their way to ‘not participate’ in judging a bad person as bad. If you don’t root out assholes, you’re complicit to their behaviour.

                                                                                                                  Come on, there’s a few witness statements in this thread, in this small corner of the internet, that corroborate the story. People are being warned against his antics. No one that goes “I’m surprised and have only had positive experiences with him”. Even the positive ones are hedging. That’s damning evidence.

                                                                                                                  1. 3

                                                                                                                    I want to add here that we’re talking about good/bad along some specific axis. People have many traits and can be good in many ways, while bad in others. The context here is that someone is e.g. bad for the community.

                                                                                                                  2. 7

                                                                                                                    If this had been a team in an organization or business, I would agree with you. Airing private laundry publicly is not constructive.

                                                                                                                    But this is an open source project, where transparency and being public are important factors.

                                                                                                                    If someone is pushing other people down through their behavior, repeatedly, it’s balanced that they also receive criticism and possibly removal of responsibility, publicly, IMO.

                                                                                                                    1. 5

                                                                                                                      Perhaps I’m wrong when it comes to FOSS. I don’t know. I’ve been wrong many times before :)

                                                                                                                      I know that open source is much more like running a charity or a minimum-wage restaurant: each person’s spirit and morale have to be very high for them to stay dedicated over any length of time.

                                                                                                                      I’m happy to see various open source teams publicly announce their team norms. Folks can then either select in or out depending on how those standards make them feel.

                                                                                                                      But trying to take interpersonal human communication, an emergent behavior involving perhaps millions of years of evolution, and digitizing it? That doesn’t sound workable to me.

                                                                                                                      As a personal example, I’ve been online since the net came up. I try as hard as I can to be a nice person online and understand other people’s viewpoints. But I don’t doubt for a moment that either through chance encounters or cherry-picking I could be made out to be a horrible monster. People change, and little slices here and there of printed text can tell us but very little.

                                                                                                                      This doesn’t work for me, even in an open source environment. Even with clear and written boundaries, too much here is random, subjective, and prone to personality conflicts. For some people, their personalities just don’t mesh with one another. I’m trying, but I just can’t see this as a useful thing for people who actually care about writing good code that helps others. I’m trying, and I’m open to being wrong, but so far I’m not getting anywhere near changing my mind on this. Apologies.

                                                                                                                      1. 14

                                                                                                                        But I don’t doubt for a moment that either through chance encounters or cherry-picking I could be made out to be a horrible monster.

                                                                                                                        Read thru this whole thread. Of the five people (so far) recounting first-hand experience with this person, 100% of them say that their experience is consistent with the story in the post. I have a hard time to believe that’s due to cherry-picking.

                                                                                                                        1. 3

                                                                                                                          Read thru this whole thread. Of the five people (so far) recounting first-hand experience with this person, 100% of them say that their experience is consistent with the story in the post.

                                                                                                                          Also read through the HN thread which contains first-hand reports (neilv, rebelshrug, …) saying otherwise.

                                                                                                                          1. 19

                                                                                                                            Toxic people aren’t toxic to everybody all the time.

                                                                                                                            1. 16

                                                                                                                              My childhood bully wasn’t a bully to everyone, either. He had great friends who supported him, and his behavior. There is literally an example of this, right now, in US Politics; but the example is as old as humanity.

                                                                                                                              This doesn’t make the bullying behavior right, and it doesn’t make the person speaking up about the bullying wrong. The bully, however, is almost always in the wrong.

                                                                                                                              1. 1

                                                                                                                                With childhood bullies (which by the way no one in education cares to fully address), there is generally no ambiguity as to the harmfulness of the aggressor’s intent. Thus, that analogy breaks down here, where it is not clear as to where exactly lies this anecdotal accusation in the spectrum from it being a subjective taking-offense to being an intended harm (giving-offense). Some people, for instance, would interpret the below stern behavior (and it is possible to be stern without being offensive), as reviewed by someone from ratemyprofessors.com, to be “bullying”,

                                                                                                                                I hated [Matthias’s] guts while in his class, but in retrospect he’s almost certainly the best teacher I’ve ever had. As somebody said above, this guy is absolutely brilliant. He will kick your butt, but it’s all for your own good in the end. He seems to really care about teaching, and it shows.

                                                                                                                                (Have you ever seen a victim describe their childhood bully this way?)

                                                                                                                                Besides, bullying behaviour is not uncommon among people who are not normally characterized as ‘bullies’ - inasmuch as they are covert. Example here. I used to work for a company (based on San Francisco, incidentally) where this sort of behaviour was not uncommon.

                                                                                                                                The Racket core team, and people who closely work with Matthias, would be in a better position than us passerby’s (who know nothing but a few anecdotes) to fairly assess the facts of the matter.

                                                                                                                                1. 8

                                                                                                                                  The Racket core team, and people who closely work with Matthias, would be in a better position than us passerby’s (who know nothing but a few anecdotes) to fairly assess the facts of the matter.

                                                                                                                                  What facts are you disputing, exactly? In nearly every case of human-to-human problem it boils down to a proverbial “he-said, she-said” type argument. The “facts” here are, for sure, a one sided account of how Matthias’ actions made people feel. I’m certainly not in a position to assess this. But, I can acknowledge that there are many people who feel this way after interactions with Matthias and decide for myself whether or not I want to risk seeing this behavior first hand, or avoid it. (FWIW, I stopped contributing to Racket. Not because of Matthias directly, but there is definitely something in the air in that community, that I’ve never been able to articulate)

                                                                                                                                  Butterick did not write a hit piece. People are, and will interpret it as that. His piece answered the question “Why did I leave the Racket Community?” and I think he fairly presented his side of things. I also trust him based on previous knowledge of him from years past. Matthias, if he feels so inclined, or other members of the Racket community should certainly present their side of the “argument” here, but that should never discount Butterick’s feelings, or reasoning for this. Butterick feels he was wronged, presented reasons for why he feels that way, and took actions he deemed necessary, resulting in him no longer contributing to the community (a great loss, honestly). Any interpretation beyond that, or other anecdotes are your responsibility to consider if you feel like it, or ignore if you don’t.

                                                                                                                                  As a community, I hope that the discussion being had here is a wake up call. People are actively being discouraged from collaborating on the Racket project as a result of behavior stemming from it (I don’t think it’s only Matthias’ fault, fwiw). My guess is that nothing will change, and Racket will never ever meet its full potential outside of academia. This has never seemed to be a goal anyway, though, there has been mention of it, and it is certainly the case that members of the community would like this to change.

                                                                                                                                  1. 0

                                                                                                                                    Matthias, if he feels so inclined, or other members of the Racket community should certainly present their side of the “argument” here, but that should never discount Butterick’s feelings, or reasoning for this. Butterick feels he was wronged, presented reasons for why he feels that way, and took actions he deemed necessary, resulting in him no longer contributing to the community (a great loss, honestly). Any interpretation beyond that, or other anecdotes are your responsibility to consider if you feel like it, or ignore if you don’t.

                                                                                                                                    Exactly my point. Butterick feels he was wronged; this much we know as facts of the matter (and there is no need to put the word in scare-quotes; I’m using it in its dictionary definition sense). What we don’t know, as facts, is whether Matthias is a ‘bully’ (your word) or, whether how Butterick feels is a result of “Matthias’ fault” (also, your words). The feelings of Butterick, you or me alone do not automatically establish Matthias to be ‘bully’ (as opposed to merely being stern, for instance). You are entitled to your opinion, of course … but whether that is in line with the facts of the matter or not (so as to use as a basis to make any genuinely positive changes in the Racket community) is a different thing entirely.

                                                                                                                                    1. 7

                                                                                                                                      Matthias is a ‘bully’ (your word) or, whether how Butterick feels is a result of “Matthias’ fault” (also, your words).

                                                                                                                                      The actions of Matthias, and the inactions of the Racket Core Team (“Everyone just shrugged and moved on. I was encour­aged to do the same.”) are literally the reasons cited for Butterick’s moving on.

                                                                                                                                      The feelings of Butterick, you or me alone do not automatically establish Matthias to be ‘bully’ (as opposed to merely being stern, for instance).

                                                                                                                                      Right. But, the collective feelings of others, can certainly establish a pattern that we can look at. An Elementary school administrator might look past one isolated incident, of kid A pushing around kid B as almost hearsay. But, if kid B, kid C, kid D, kid E, kid F, and then a number of anonymous comment cards talk about being pushed around by kid A, it’s a bit harder to ignore, don’t you think? Even if that kid is top in his class, and in retrospect, “great at helping their fellow students succeed” – is the behavior somehow more excusable?

                                                                                                                                      Anyway, as kid Z in this fictional Elementary school, if I hear of all of these accounts, I’m going to be cautious about interacting with kid A.

                                                                                                                                      Incidentally, this is why a prosecution in a court system attempts to establish “patterns” of abuse in crimes against other humans. It’s a lot easier for a jury to believe an accuser’s side of the events when there’s a pattern of the same / similar behavior.

                                                                                                                                      1. 6

                                                                                                                                        The feelings of Butterick, you or me alone do not automatically establish Matthias to be ‘bully’ (as opposed to merely being stern, for instance). You are entitled to your opinion, of course … but whether that is in line with the facts of the matter or not

                                                                                                                                        Felleisen has published an apology where he basically admitted to the bullying (as much as bullies ever do, anyway), so the facts aren’t in dispute.

                                                                                                                                    2. 2

                                                                                                                                      (Have you ever seen a victim describe their childhood bully this way?)

                                                                                                                                      I didn’t address this before, but have you heard of Stockholm Syndrome?

                                                                                                                                      1. 2

                                                                                                                                        I didn’t address this before, but have you heard of Stockholm Syndrome?

                                                                                                                                        At that link

                                                                                                                                        1. 2

                                                                                                                                          There’s no consensus on what “Stockholm Syndrome” is, but I bet you knew exactly what I was referring to when I wrote it…

                                                                                                                                        2. 2

                                                                                                                                          Your own link immediately notes that the research on Stockholm syndrome existing is severely lacking— and that the situation for which it is named does not match up with the purported effects.

                                                                                                                                          I know of several educators that made me react similarly to the reviewer: I honestly believe compassion is a better way to teach 100% of the time, but the ‘tough on students’ facade is effective for them too, so what do I know.

                                                                                                                                          1. 3

                                                                                                                                            No. Stockholm Syndrome does not directly apply to the situation, in so much as students are not being held captive by their teachers (under most circumstances!). The reason for bringing this up is that it is a related phenomenon (victim is apologetic / empathetic after trauma), however dubious it actually is.

                                                                                                                                            Relatedly: do you dismiss the cycle of domestic abuse, too?

                                                                                                                                            1. 3

                                                                                                                                              I don’t think it’s even a related phenomenon. I think the simplest solution is most likely. The student didn’t like his teaching style at the time, but when he looked back he saw that it was effective for him. There’s no trauma or brainwashing involved. This has happened to me many times before in many different contexts, some interpersonal, some personal.

                                                                                                                                              I’m not dismissing the existence of trauma bonding and PTSD, which I think is what you might have meant by Stockholm Syndrome. These are both serious, real things. I just thought that Stockholm Syndrome was a poor choice of armchair diagnosis, considering its dubious origins.

                                                                                                                                              1. 3

                                                                                                                                                Keep in mind that the original discussion was about bullying, and that the answer to @srid’s direct question of “have you seen a victim describe their childhood bully this way?” Is what I was replying to, directly.

                                                                                                                                                The answer, is yes. Yes I have. Childhood bullies are great examples of situations in which there is often an eventual “the bully toughened me up,” in retrospect, and “I respect them, have empathy, etc, etc, etc.”

                                                                                                                                                This entire pattern of having empathy for abusers, and reminded me of “Stockholm Syndrome,” in which a similar pattern is purported.

                                                                                                                                                1. 1

                                                                                                                                                  Oh I see, sorry. I thought you were saying the student was displaying signs of Stockholm syndrome. I haven’t really heard that line about bullies in real life ever, although I have seen it a lot in media (there was a whole anti-bullying craze, which might be where some of the ‘have empathy for bullies!’ rhetoric comes from). It’s a hazy line between ‘tough but wants the best out of you’ and ‘just an inconsiderate asshole’ that I think a lot of people cross without knowing. It’s probably better to not do the whole ‘tough but fair’ thing in the first place.

                                                                                                                                          2. 1

                                                                                                                                            This was exactly what leapt into my head when I read that paragraph.

                                                                                                                              2. 7

                                                                                                                                This is a very prominent figure in a public community. I just don’t want when people meet one of the authors of the Little Schemer to find a gigantic asshole. It makes the community look bad, and Matthias is more than capable of acting better. The other author, Dan Friedman, I should stress is one of the kindest, sweetest, thoughtful researchers I have ever met.

                                                                                                                                1. 7

                                                                                                                                  This is a very prominent figure in a public community. I just don’t want when people meet one of the authors of the Little Schemer to find a gigantic asshole.

                                                                                                                                  I’m not really a Scheme person; I played around with it for a bit several years ago and found it fun in insightful, but ultimate also found it hard to build actual actual programs in, so not really practical for me.

                                                                                                                                  The Little Schemer, however, is easily my favourite programming book. It’s just fun, almost cheerful, and also quite good at actually teaching Scheme. A lot of books that try to be “fun” usually aren’t very good at actually teaching stuff, and books that are good at teaching stuff are usually a bit of a dry affair. Combing both effectively (and in such an unique way) is rare.

                                                                                                                                  Programming books are not the best way to gauge the author’s personality, but it’s just so contrary to the impression I got from the book that I had to triple-check that this was really the same Matthias Felleisen and wasn’t somehow a confusing two people with similar names.

                                                                                                                                  People are complex I guess 🤷

                                                                                                                                  1. 5

                                                                                                                                    I think the style of presentation of the Little books is Friedman’s, as he’s written several other books in the series with other people like The Little Prover, The Reasoned Schemer and The Little Typer.

                                                                                                                                  2. 4

                                                                                                                                    The other author, Dan Friedman, I should stress is one of the kindest, sweetest, thoughtful researchers I have ever met.

                                                                                                                                    I never met him personally, but he must be quite the guy. They held a conference in honor of him on his sixtieth birthday. Fun fact: the conference was colloquially known as DanFest.

                                                                                                                            1. 10

                                                                                                                              This was the second time in about a week that the banned user used a weird analogy where tobacco companies called critics of smoking Nazis:

                                                                                                                              https://lobste.rs/s/prlffn/urbit_good_bad_insane#c_mqlafh

                                                                                                                              The deleted comment repeated that, and implied that the “fat acceptance movement” caused deaths, linking them to Nazis somehow?

                                                                                                                              The banning of the user and the deletion of the comment were related but separate.

                                                                                                                              1. 14

                                                                                                                                (Cw)

                                                                                                                                Not only that, they specifically compared the deaths caused by nazis to the number of deaths caused by big tobacco in what I can only imagine was either a brazen defense of one of the worst human rights violations in history let alone recent memory, or more likely shameless flame baiting, since they decided to mention nazis, tobacco, and “fatness” all together, while denouncing the “culture war” in the same breath. If that’s not textbook trolling, I’m not really sure what is.

                                                                                                                                Anyways I’d consider keeping the comments around, but in a place that requires just enough digging so that people don’t accidentally run into particularly toxic content.

                                                                                                                                On second thought I think I’d prefer keeping the comments removed, but with a more precise summary / context on what line it crossed. It’s a bit weird to allow for a trolls crowning achievement to live on in perpetuity, but we also want to have enough info to have confidence in a ban being appropriate.

                                                                                                                                1. 5

                                                                                                                                  This famous historian of science named his book on the tobacco industry “Golden Holocaust”, sounds like Stanford should ban him for making a comparison https://history.stanford.edu/publications/golden-holocaust-origins-cigarette-catastrophe-and-case-abolition

                                                                                                                                  1. 10

                                                                                                                                    Arguably insensitive, but offset somewhat by the fact that it’s a serious work of scholarship? The author’s intent is clear.

                                                                                                                                    It does not sound like this poster’s comment was a serious work of scholarship.

                                                                                                                                    1. 2

                                                                                                                                      If all comments should be possible to back up with a serious work of scholarship, we should all be banned.

                                                                                                                                    2. 7

                                                                                                                                      There is a serious legitimate point to be made here; the Nazis were anti-smoking, although not always for the right reasons (”The Jew uses cigarettes to destroy us!”), and this connection has been abused to deflect criticism.

                                                                                                                                      But the location and way it was done was … less than ideal. In particular the Genocide Olympics of “kill[ed] more people than the holocaust” just comes off as weird and dismissive of the Holocaust. The comment for which they got banned was even worse with “Gotta hand it to them [the Nazis], they killed fewer people with the Holocaust than big tobacco did”. It’s one thing to say “this is horrible, it killed even more people than the Holocaust!” and quite another to say “gotta hand it to them, at least they didn’t kill as many people as […]!” I didn’t read that book, but I’d wager it used the “this is horrible, it killed even more people”-kind of rhetoric.

                                                                                                                                      All of that being said, on the face of it I’d personally take a more good faith interpretation of being misguided and foolish rather than support of Nazis, but I don’t know if there’s any context/history with this user.

                                                                                                                                      1. 3

                                                                                                                                        Judging by Proctor’s Wikipedia page he’s long been interested in the anti-smoking campaigns of Nazi Germany, so no doubt the title is an allusion to that.

                                                                                                                                        Edit this letter especially is an interesting read.

                                                                                                                                  1. 9

                                                                                                                                    1m30.6s on a 32 core Threadripper. Not a fair comparision by any metric, but pretty amusing.

                                                                                                                                    1. 9

                                                                                                                                      With that type of speed, you can just compile the kernel at boot… https://bellard.org/tcc/tccboot.html

                                                                                                                                      1. 5

                                                                                                                                        Of course it’s Fabrice Bellard. This kind of whacky shenanigans is exactly the kind of thing I’ve come to expect from him. His focus seems to be relatively narrow (C, Linux), but his work is still breathtaking.

                                                                                                                                        UPDATE: He’s the author of qemu. Of course he is.

                                                                                                                                        1. 4

                                                                                                                                          Don’t forget ffmpeg, oh and the 4G mobile base station implementation.

                                                                                                                                          If I could stay a tenth as focused & productive I would probably feel I was doing well.

                                                                                                                                          1. 2

                                                                                                                                            And, most recently, QuickJS. So many impressive projects from one person.

                                                                                                                                    1. 28

                                                                                                                                      Rust’s style of borrow checking is a revolutionary idea because it makes practical things that were impossible before, outside of research languages. I don’t think that will go away any time soon.

                                                                                                                                      Whether Rust itself is “the wave of the future” or not is still undecided, and frankly irrelevant. Maybe it is, or maybe it will become a Simula or SNOBOL that is mainly important for the ideas it pioneered and inspired in later languages. If I’m using something else as my main language in ten years it will be because it’s better than Rust. It’s a high bar, but certainly a conceivable one.

                                                                                                                                      1. 27

                                                                                                                                        I think Rust is way past the infancy stage, and is here to stay.

                                                                                                                                        • Rust has a lot of momentum and is gaining popularity quickly. About 3 years ago number of Rust users and projects has surpassed Scala, D, Nim, and Haskell, and it’s way ahead them now, and growing. crates.io is growing faster than rubygems.org, and is already 40% of its size. Because of it’s niche Rust will never be as popular as mainstream GC languages, but it’s not an “alt-lang” anymore either.

                                                                                                                                        • Rust has been explicitly designed as a practical language, not an experiment. It’s used in production. I know big companies where Rust is now a hard dependency for critical components, maintained by entire teams (not one dev’s side project any more).

                                                                                                                                        • Rust is based on a lot of pre-existing research languages. In terms of rough syntax and post-ALGOL features there’s already some convergence between Rust, Kotlin, Swift, and TypeScript. The latter two are probably here to stay too, so they’ll keep Rust looking normal.

                                                                                                                                        • In Rust’s niche of systems programming + safety there’s no competition. There’s lots of competition in easy GC languages, but that’s not Rust’s niche. There are other systems languages, some of which are nice, but without equal safety guarantees they don’t have the same hook that Rust has (e.g. Rust is getting into Linux because it’s safer, not because it’s nicer).

                                                                                                                                        • There’s no obvious flaw (known yet) that a potential Rust-killer could address to displace Rust. New Rust users suffer learning the borrow checker, but it’s not a big issue for experienced users. Rust users are very satisfied with the language.

                                                                                                                                        • Rust 1.0 has been released 6 years ago. Even if a Rust-killer was released tomorrow, Rust already has a significant head start and a track record. Rust is still being developed and evolving, so it can put up a fight by copying features from potential Rust-killers (and use the editions to delay ending up like C++).

                                                                                                                                        Oops, my comment is longer than the article now :)

                                                                                                                                        1. 15

                                                                                                                                          Rust can still suffer from feature creep and long compilation times for large projects. These are things that takes a couple of years to see how they pan out.

                                                                                                                                          1. 4

                                                                                                                                            I think you’re probably right, I just also remember when Java was The Next Killer Thing and am not about to jump to any conclusions.

                                                                                                                                            1. 17

                                                                                                                                              Did that really end up being wrong? The initial imagined usecase for it (Applets) didn’t pan out, but a quarter of a century later it’s still the #5 programming language on Stackoverflow (really, number #3 if you accept that SQL and HTML/CSS aren’t so much competing with it as working in concert with it) and it’s probably still #1 in corporate circles.

                                                                                                                                              It’s not my idea of a killer programming language, but the prediction that it was going to eat the world does seems to have largely bore out, just differently than the initial expectation.

                                                                                                                                              1. 7

                                                                                                                                                And indeed java was the next big thing, look at how popular it is nowadays :-). It made garbage collection as mainstream as it could be.

                                                                                                                                              2. 2

                                                                                                                                                In Rust’s niche of systems programming + safety there’s no competition

                                                                                                                                                You don’t hear much about it, but Ada has been in this space for 40 years.

                                                                                                                                                There’s no obvious flaw (known yet) that a potential Rust-killer could address to displace Rust

                                                                                                                                                Rust is good, but it has trouble enforcing large scale constraints on programs, which often show up in Real-Time systems, for which Ada was designed. For example, Ada’s Ravenscar profile detects behavior at compile-time in your program which will lead to unpredictable behavior in high-integrity applications.

                                                                                                                                                1. 4

                                                                                                                                                  I deliberately haven’t mentioned Ada, because the metrics I have are biased towards open-source, and by these metrics Ada is dead.

                                                                                                                                                  1. 3

                                                                                                                                                    If your point is open source specific, you should say that, but deliberately ignoring a language because it historically been used for closed source systems is misleading.

                                                                                                                                                    EDIT: I realized I probably came off as combative, which wasn’t my intent. I just don’t think those metrics capture really what’s happening since there’s a lot of closed source development. I just know for sure that OCaml is actively used for some companies critical systems but it doesn’t show up well on those metrics.

                                                                                                                                                    1. 4

                                                                                                                                                      I mean other langues have public package repositories and online communities, so they’re comparable this way. Ada isn’t, so I didn’t compare it.

                                                                                                                                                      Back to the original point: the fact that Ada is used so differently — closer to DoD than GitHub – also means it’s not a direct Rust competitor. Rust’s openness, vendor-neutrality, community, and availability of open-source libraries are its assets too.

                                                                                                                                                      1. 4

                                                                                                                                                        means it’s not a direct Rust competitor. Rust’s openness, vendor-neutrality, community, and availability of open-source libraries are its assets too.

                                                                                                                                                        Your point was that there was no safe systems programming equivalent to Rust, my point is that there is, it’s just not well known or used publicly. Ada may have originated from the DoD, but the major Ada implementation, GNAT and a lot of tooling and libraries are GPLv3 or a limited form with a runtime exception. I agree that there’s not really a well established Ada community and it’s just now providing a similar solution to Cargo or CPAN. There’s a lot more than you’d expect, but it’s sort of distributed right now (Ada Utility Library, GNATColl, GNAT, etc.) However, if people feel like they missed getting in on the ground floor of a major programming language and open source library development, there’s huge opportunity on a mature language available.

                                                                                                                                                        I’m unsure how Rust has vendor-neutrality though when there’s only one main Rust implementation, whereas Ada is an ISO standard and has a full public battery of compiler tests for implementers.

                                                                                                                                                        The DoD vs Github thing may have been true a few years ago, but there’s been a major push from the main Ada vendor, AdaCore, to split off and open source as much as possible, in a eerily similar way to what Mozilla has done (disclaimer: I’m not involved with AdaCore, so I don’t know how far this goes, or what their long term plan is).

                                                                                                                                                  2. 1

                                                                                                                                                    Can you tell me more about these large scale constraints? Are we talking like, latency/memory constraints?

                                                                                                                                                    1. 3

                                                                                                                                                      Just to give a few examples, there’s per-package (module) constraints like the Pure aspect, which ensures a module has no state and depends on none that has state. There’s also a pragma called “Restrictions” which can do various things like prohibit all or various types of dynamic allocation, prohibit floating point, prohibit the use of recursion, ensure no dependence on other specific modules of code, and so on.

                                                                                                                                                      1. 1

                                                                                                                                                        Those all sound like things that could be written as rustc lints. If an industry or organization had such requirements they could maintain lints that do exactly that, and enforce them via #[foo] attributes. Of course, there may be points I’m not thinking of that wouldn’t be possible as a lint as well.

                                                                                                                                                        1. 2

                                                                                                                                                          It really doesn’t sound like something that can be done with rustc lint. It sounds most similar to Safe Haskell to me. At the very least, cargo will be involved in addition to rustc.

                                                                                                                                                2. 5

                                                                                                                                                  I 100% believe that Rust is the beginning of a new generation of programming languages. I don’t suspect that Rust will be popular in 10 years, but I’d be willing to bet money that there WILL be at least a few statically typed languages in 10 years that will have obvious roots in Rust.

                                                                                                                                                  Don’t misunderstand my next sentence- I’m not saying that Rust invented anything. But, look at how many languages are implementing things like enums/ADTs and pattern matching “all of a sudden” (Python?! Are you for real?!). Look at Swift (which came out after Rust) looking to switch to a Rust-like lifetime/borrow mechanism. Look at ranges in C++.

                                                                                                                                                  1. 8

                                                                                                                                                    I think it’s likely that many languages will be influenced by Rust, since there are already dozens of such projects over at /r/ProgrammingLanguages and other places.

                                                                                                                                                    But if there’s any one that will be popular in 10 years, it already exists now and you might have heard of it! That is, Rust itself took 8-9 years to become 1.0 and it’s existed for close to 15 years now! Languages just take a long time, so I think in 10 years Rust will still be the top choice … for people who want a “Rust-like” language :)

                                                                                                                                                    I made a similar argument when someone was asking about alternatives to Matlab that are not Julia. If you haven’t heard of it already, it’s not likely you’ll be using it in production in 10 years!

                                                                                                                                                    1. 6

                                                                                                                                                      It is wild how long it takes the average language to gain mainstream popularity. For example, Python is one of the “new” hot languages of the last decade, but it is older than Linux!

                                                                                                                                                      1. 2

                                                                                                                                                        Python is a weird story, IMO. I don’t know anything about the language’s actual history, so my perception could be wrong. But I feel like it really just had a huge surge for some reason around 2005-2010-ish. I don’t exactly know what caused it or why it wasn’t very popular before then, but it’s really interesting that people just suddenly “discovered” it many years after it had been around. For a while, it seemed like everything was written in Python: desktop applications, CLI tools, server backends, data science code, etc.

                                                                                                                                                        To be fair, the other viable languages for doing apps in 2005-ish were probably C++, Java, and whatever was in Microsoft land - C# I guess? I can see why Python would be appealing in that environment.

                                                                                                                                                        1. 3

                                                                                                                                                          I started using Python in 2003, and I agree it had a bump in popularity in the 2005-2010 era (although it still grew enormously in the last decade).

                                                                                                                                                          I think it just takes that long to build a useful language – especially the libraries. I don’t think it was just “discovered” – the key is that it gained a lot of critical functionality.

                                                                                                                                                          For example Travis Oliphant was beating the drum hard for NumPy and array programming in the 90’s and early 2000’s (writing a ton of code, documentation, explaining it at PyCon, etc.). And 10 or 15 years later that led to Pandas, Torch, Tensorflow, etc. which are a big part of why Python is popular now. (Ruby, JavaScript, PHP, and Perl all pretty much lack this functionality.)

                                                                                                                                                          Guido had almost nothing to do with this! (although obviously he had his hand in so many other critical Python features)

                                                                                                                                                          And I remember in 2005 or 2006, Python web programming was immature. I used CherryPy, and there was Twisted. It seems like the ecosystem has converged on Flask and Django to some extent. So it just took effort to build all of that. Ruby also seemed to lack web programming until Rails (afaik).

                                                                                                                                                          In 2003, the meme was that Python was a cleaner Perl, but it lacked libraries. People said Perl was a better choice because it had CPAN. Fast forward a few years and now everyone talks about how Python has more bindings for libraries than say Go or Rust! It just takes time.

                                                                                                                                                          1. 2

                                                                                                                                                            Thanks for the insight. As I said, I was kind of passive observer, as I was just barely learning to program in 2007-ish.

                                                                                                                                                        2. 1

                                                                                                                                                          Yup, Python and Ruby are of a similar vintage, and they both took more than a decade before getting popular. I hadn’t heard of Python before 2003, and it started in 1990 or so. I agree it had a big bump in popularity in the 2005-2010 era.

                                                                                                                                                          I think it just takes that long to make a useful language.

                                                                                                                                                          JavaScript was arguably not very popular before 2005 or so, about a decade after its creation. And it really got popular in 2009 with node.js.

                                                                                                                                                          Ditto for R – it started in 1995, and I started using it in 2009 or so, and a lot of people still haven’t heard of it.

                                                                                                                                                          PHP and Perl seem to have gotten fairly popular out of the gate. It would be interesting to know why that is. I think one reason is that PHP was basically a bunch of libraries at first, and not a programming language! It was tightly coupled to Apache, which was becoming huge because people wanted an open source web server.

                                                                                                                                                        3. 1

                                                                                                                                                          Yes, that’s a good point, of course. The probability of a language surviving increases as it continues to survive. That sounds almost tautological, but it isn’t.

                                                                                                                                                        4. 3

                                                                                                                                                          I don’t suspect that Rust will be popular in 10 years

                                                                                                                                                          Out of interest, why do you say this? Is there a specific reason/reasons why you think its popularity will plateau/wane?

                                                                                                                                                          1. 3

                                                                                                                                                            It’s mostly a hunch, but there are a couple of half-baked reasons:

                                                                                                                                                            • Statistically speaking, it’s just a safe bet, because there are tons of languages at any given time, but only a few that have lived and thrived for 20+ years (probably single-digits: C, C++, Java, Python, PHP, C#, JavaScript… that’s it? Unless you count LISP, Fortran, Haskell, and Perl as “living and thriving” which I don’t).
                                                                                                                                                            • Error handling. I mostly like Rust’s error handling mechanism, but I suspect that it’s too tedious for most people and I think there’s room for languages to try other things that may end up being better. Tangentially, my controversial opinion is that checked exceptions deserve another attempt besides how they were implemented by Java. Rust’s approach would be improved (ergonomically) by either ad-hoc enum types or actual inheritance.
                                                                                                                                                            • Async and Futures, etc. I have a feeling that async/await syntax is a fad for this decade-ish and that in 10 years we’ll all think it was sooo stupid and that “concurrency hoobajoobs” is clearly the right way to do concurrency/async. I don’t have any particular complaint about async, colored functions, Futures, etc- I just see that it’s been very cargo-culty across the entire programming language ecosystem- very similar to OOP in the 90s and similar to FP and monad-all-the-things today.
                                                                                                                                                            • I also have a hunch that structural typing will become more popular for statically typed languages. That may or may not affect Rust depending on how soon that happens and how cemented Rust is in particular niches.
                                                                                                                                                            1. 2

                                                                                                                                                              Not GP, but I think other languages could improve upon Rust.

                                                                                                                                                              C identified the high-level patterns that assembly programmers were using: if statements, loops… and it gave us constructs to speak in those higher-level terms.

                                                                                                                                                              I think a language could identify the common patterns that Rust programmers often use, and then offer those more directly, with less complexity.

                                                                                                                                                              Some other promising avenues: https://cone.jondgoodwin.com/ is making borrow checking easier by complementing it with other memory management strategies, and http://strlen.com/lobster/ is pushing static analysis to be near the borrow checker’s speed.

                                                                                                                                                              1. 15

                                                                                                                                                                Replacing languages is an infrequent event. Programming languages are very often invented and designed, but mustering the resources to bring a language of the scope of Rust to industry adoption is really hard and needs a lot of dedication and sweat.

                                                                                                                                                                Programming languages are very hard to argue for, spending-wise. And given that Rust is one of the only languages currently being adopted by all the major companies, they will think hard about the delta that languages following it will bring.

                                                                                                                                                                1. 2

                                                                                                                                                                  I could agree with your phrasing of “adopted by all the major companies”, though I might have phrased it like “adopted by some parts of a lot of major companies, for some things”.

                                                                                                                                                                  I’m probably speaking from my own bubble, but I don’t really see that Rust has taken off yet. In my day to day job, I see these very clear trends: Obj-C to Swift, Java to Kotlin, Javascript to Typescript. For most actively developed projects where I work, that migration is either underway or in the plans. But I’m not seeing the C++ to Rust transition I would have hoped for. It’s not really even considered that seriously.

                                                                                                                                                                  From experience, I can only guess that, while Rust is perfect on paper, its difficult learning curve and complexity is what’s holding it back. With that in mind, I wouldn’t be surprised if Rust keeps growing but some other systems language surpasses it in a decade or so, probably one that has the safety and speed of Rust but without the complexities.

                                                                                                                                                                2. 4

                                                                                                                                                                  C didn’t come into a world where everyone was writing in assembly; its creators had already been involved in Multics, which was programmed in PL/1, for instance. Burroughs had been using ALGOL as its systems language, as had many others, etc.

                                                                                                                                                            2. 6

                                                                                                                                                              Ada has had accessibility checks since 1995, through it’s system of making its pointer-like types into actual types which depend on the lifetime in which they’re declared.

                                                                                                                                                              1. 4

                                                                                                                                                                I really have to check Ada out, even if only for the historical context. I keep hearing all kinds of interesting things about it. The cynic in me feels like there must be a huge catch, like it must have something that just makes it horrible to work with…

                                                                                                                                                                1. 12

                                                                                                                                                                  The catch is verbosity due to no macros or preprocessor, and then eventually you figure out that verbosity is a signal from the language that you’re going about your problem in the wrong way.

                                                                                                                                                                  In general it feels like finding a old but super advanced spaceship crashed in your yard that works just fine, but if you tell anyone you’re using it they think you’re just crazy.

                                                                                                                                                                  1. 2

                                                                                                                                                                    What’s the concurrency story like?

                                                                                                                                                                    (Yes I keep popping up on your comments and no I still haven’t managed to really crack ada open. Maybe I should, and should look at how to link it to other stuff with more active library communities)

                                                                                                                                                                    1. 5

                                                                                                                                                                      Built into the language you have “protected objects” which provide mutual exclusion to shared resources, and “tasks” which provide the ability to spin off work. You coordinate (rendezvous) with a task by calling one of its “entries”, which are sort of like a procedure call version of “await aTask.asyncFunction();” but “protected objects” can also add guards to these to cause a task to wait in a queue until specific conditions are fulfilled.

                                                                                                                                                                      Queueing is handled by the language, and as part of these features is a construct called “select” which lets a task “accept” one of multiple entries another flow of execution is waiting on. Since this is built into the language, you also get time-outs waiting on conditions for free, as well as a form of select which will execute a different flow if an entry on a task or protected object would block or if one of the flows exceeds a time limit, like it a calculation takes too long.

                                                                                                                                                                      What’s super helpful is that because Ada features are opt-in rather than opt-out, you can ignore tasks and protected objects until you understand more of the language, and then define tasks within your functions to split work later on.

                                                                                                                                                                      active library communities

                                                                                                                                                                      You can get super far with just the standard library defined by Ada itself, and also the freely available GNAT and GNATCOLL libraries.

                                                                                                                                                                      1. 2

                                                                                                                                                                        That’s cool. It sounds kind of like an actor model, and should be easy to build the necessary functionality on top if one wanted “proper” actors.

                                                                                                                                                            1. 4

                                                                                                                                                              Also, as far as I know: If another package exposes enums, you can’t choose a random one of those without modifying the original package.

                                                                                                                                                              1. 1

                                                                                                                                                                FreeBSD would be more differentiated if they could offer a GNU-less default installation.

                                                                                                                                                                1. 4

                                                                                                                                                                  There is chance that FreeBSD 13.1 will be GPL-less.

                                                                                                                                                                  Here is the current progress:

                                                                                                                                                                  https://wiki.freebsd.org/GPLinBase

                                                                                                                                                                  The remaining parts are:

                                                                                                                                                                  … and from what I know that’s it.

                                                                                                                                                                  All other components of FreeBSD are not licensed under GNU license.

                                                                                                                                                                  1. 3

                                                                                                                                                                    FreeBSD is actively working on kicking out GPL code from base.

                                                                                                                                                                  1. 4

                                                                                                                                                                    This is an educational and well crafted puzzle that just takes a few minutes to complete. I learned something.

                                                                                                                                                                    I think there are many conclusions that can be drawn from the solution to the puzzle, but I don’t think Lobsters has a way to discuss it without spoiling it.

                                                                                                                                                                    1. 4

                                                                                                                                                                      Rot13-ing spoilers is the classic technique.

                                                                                                                                                                      1. 1

                                                                                                                                                                        Va cenpgvpr, guvf cnegvphyne ceboyrz pbhyq unir orra nibvqrq ol whfg abg hfvat WninFpevcg.