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. 20

          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.

                      1.  

                        In the case of Clojure while it doesn’t have pattern matching built-in, it does have quite comprehensive destructuring forms (like nested matching in maps, with rather elaborate mechanisms) that works in all binding positions.

                        1.  

                          Nice! I suppose (from your post above) that pattern-matching is somehow “integrated” in the Clojure implementation, rather than just being part of the base macro layer that all users see.

                          1.  

                            I think the case is that Clojure core special forms support it (I suppose the implementation itself is here and called “binding-forms”, which is then used by let, fn and loop which user defined macros often end up expanding to). Thus it is somewhat under the base layer that people use.

                            But bear in mind this is destructuring, in a more general manner than what Python 2.x already supported, not pattern matching. It also tends to get messy with deep destructuring, but the same can be said of deep pattern matches through multiple layers of constructors.

                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. 6

                    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. 3

                                    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. 6

                                        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. 5

                                      Excellent and fascinating series! It’s far too seldom you get to see people seriously involved with a large programming language’s design do this sort of retrospective. It’s also somewhat enlightening how many of these are warts for compatibility with C/ObjC API design, for example this one.

                                      Suggest plt tag as well, maybe?

                                      1. 1

                                        It’s not really theory though. It’s more about language design decisions?

                                      1. 7

                                        This distinction is very similar to the one made in this article, except it splits the module manager into two subcategories:

                                        • Language package managers, e.g. go get, which manage packages for a particular language, globally.
                                        • Project dependency managers, e.g. cargo, which manage packages for a particular language and a particular local project.

                                        To be fair, many package managers play both roles by allowing you to install a package locally or globally. I tend to think that global package installation is an anti-pattern, and the use cases for it are better served by improving the UX around setting up local projects. For example, nix-shell makes it extremely easy to create an ad-hoc environment containing some set of packages, and as a result there’s rarely a need to use nix-env.

                                        1. 13

                                          I tend to think that global package installation is an anti-pattern

                                          From experience, I agree with this very strongly. Any “how to do X” tutorial that encourages you to run something like “sudo pio install …” or “sudo gem install …” is immediately very suspect. It’s such a pain in the hindquarters to cope with the mess that ends up accruing.

                                          1. 3

                                            Honestly I’m surprised to read that this still exists in newer languages.

                                            Back when I was hacking on Rubygems in 2008 or so it was very clear that this was a mistake, and tools like isolate and bundler were having to backport the project-local model onto an ecosystem which had spent over a decade building around a flawed global install model, and it was really ugly. The idea that people would repeat those same mistakes without the excuse of a legacy ecosystem is somewhat boggling.

                                            1. 3

                                              Gah, this is one thing that frustrates me so much about OPAM. Keeping things scoped to a a specific project is not the default, global installations of libraries is more prominently encouraged in the docs, and you need to figure out how to use a complicated, stateful workflow using global ‘switches’ to avoid getting into trouble.

                                              1. 3

                                                One big exception… sudo gem install bundler ;)

                                                (Though in prod I do actually find it easier/more comfortable to just use Bundler from APT.)

                                            1. 19

                                              Some rough thoughts: I guess I am a bit curmudgeonly about the term “crypto” getting taken over by “cryptocurrency” after several decades of use, it’s a bit galling to cede the term. Though at some point, yeah, it’s a practical reality that’s not worth confusing people over. We’ve seen cryptocurrency promotion get tagged both with crypto and merkle-trees so I’m not really sure expanding to cryptocurrency would change anything; I think all technical communities are going to continue to suffer from promotion for at least a few more years.

                                              Worth discussing, though, maybe someone has more pros or cons? Maybe it’s worth just trying for a year?

                                              1. 6

                                                I’ve renamed the crypto tag to cryptography. There’s strong support for it, it’s cheap, and implicitly ceding a little ground to scammers is a pretty negligible downside.

                                                1. 6

                                                  I think the realistic view is that it has become ambiguous and would be regardless of what the new referent that “takes over” is. What are the cons in expanding it to “cryptography” exactly? I don’t see any, only pros.

                                                  1. 2

                                                    I would rather not have any bitcoin related stuff on the site if possible.

                                                    1. 2

                                                      Add a cryptocurrency tag, then when used, show a warning like with banned domains and don’t submit the url. Sort of like a fishbait tag. You can add one for business news as well. Preventive moderation of sorts

                                                      1. 1

                                                        Tbh, I’m pretty appreciative of the similar stance for the ml tag.

                                                        On another note, I do kind of wish there was a more general programming-languages or pl-design tag, as a lot of things that get tagged plt aren’t really PL theory, more about PL design etc?

                                                        1. 1

                                                          What do you think about this plan:

                                                          1. Add suffix for cryptography
                                                          2. Add cryptocurrency
                                                          3. Hotness mod cryptocurrency of -0.5
                                                          1. 1

                                                            There are technical aspects of cryptocurrencies that are technical, on-topic, insightful (presumably? I don’t read them), and I don’t think it would be fair to apply a hotness downgrade to them.

                                                            The problem is cryptocurrency promotion/spam, which isn’t on-topic at all. Lobsters also gets a fair amount of spam on other topics like cloud wazamabobs we don’t downgrade the entire topic for it.

                                                            1. 2

                                                              If it’s described as a cryptocurrency, then it’s likely already moved into the scam category. There are interesting uses for verifiable append-only ledgers. There are interesting use cases for distributed consensus algorithms. These have nothing to do with cryptocurrencies other than the underlying technology.

                                                              1. 1

                                                                I do happen to agree that at a first approximation all cryptocurrencies are scams, but even a more charitable reading would lead them to fall under the umbrella of “business news” and thus off-topic anyway.

                                                              2. 1

                                                                I thought we use merkle-trees for the technical aspects?

                                                                A downgrade is just a downgrade; e.g. culture tags are downgraded. If the link is good, votes will still rise it to the top.

                                                            2. 1

                                                              I am in favor of expanding the existing tag to cryptography and keeping the implicit ban on cryptocurrency promotion by only keeping the relevant merkle-trees tag.

                                                            1. 5

                                                              Code is at https://github.com/jamii/imp and https://github.com/jamii/focus.

                                                              Sorry about the volume :S

                                                              1. 2

                                                                Cool work! Love interactive stuff like this!

                                                                Is there any relationship to the other IMP languages (eg. Edinburgh IMP, or the NSA’s IMP, or the little imperative languages found in Software Foundations and Concrete Semantics), or is this something completely different?

                                                                1. 7

                                                                  Totally unrelated. The name came from reading a paper about personifying compilers to make them more friendly. I felt like programming is less of a helpful assistant kind of thing and more of a folkloric deal-with-the-devil kind of thing, where you get exactly what you asked for.

                                                                  1. 1

                                                                    Ahh, so it’s meant to be ‘imp’ as in the magical creature, as opposed to being short for ‘imperative language’? That’s what I was thinking and then I got a bit confused when I stuff about relational programming, haha.

                                                              1. 5

                                                                Over time you slowly build out a list of good “node papers” (mostly literature reviews) and useful terms to speed up this process, but it’s always gonna be super time consuming.

                                                                Although it doesn’t really replace the manual thoroughness, I’ve found Connected Papers and Citation Tree to be handy tools for augmenting this process – if only to get a quick lay of the land!

                                                                1. 45

                                                                  PDFs are not mobile friendly. That’s already a strong reason for HTML.

                                                                  I know the author claims that PDF reflow allegedly solves this issue, but I’ve yet to find a reader that supports it.

                                                                  1. 21

                                                                    Strongly agree. And what about accessibility? PDFs are awkward for people who need large text accommodations. And I don’t know how amenable they are to screen readers nowadays: originally it was quite difficult to recover the text from a PDF because each line of text was an independent element with no clear indication of how they connect to each other.

                                                                    1. 2

                                                                      These days you can at least add accessibility annotations to PDFs that support devices like screen readers. Not sure how many readers support this stuff though.

                                                                    2. 2

                                                                      KOReader does a halfway decent job, but I agree it’s not nearly good enough to obviate HTML.

                                                                    1. 2

                                                                      There’s also the classic tools Isabelle and Coq. Isabelle was used to prove correctness of seL4, and Coq was used to prove the four-color theorem and to verify CompCert.. Both of these can also produce executable code, which is nice since there is less chance of divergence of code and model.

                                                                      Ada was already mentioned in a different comment, but it falls in the same category as the above.

                                                                      Then there’s the thing that drives the autonomous Paris metro, written in Event-B.

                                                                      Then there’s also Lean, although it more in the direction of mathematical work if I am not mistaken.

                                                                      I bet there’s a lot of other tools out there that I’ve forgotten, but these are also worth a look if you are interested in formal verification IMO.

                                                                      1. 3

                                                                        Also worth looking at F*, which is used in Project Everest (a formally verified TLS stack used in Firefox and Azure).

                                                                        1. 8

                                                                          Perfect place for me to shill Let’s Prove Leftpad

                                                                      1. 4

                                                                        This is very interesting. I’m currently building an ocaps version of the OCaml standard library (as part of moving everything to use effects - https://github.com/ocaml-multicore/eio). I’ll see what techniques I can copy from this!

                                                                        1. 2

                                                                          Are you familiar with this previous effort to adopt ocap ideas to OCaml? https://www.hpl.hp.com/techreports/2006/HPL-2006-116.html

                                                                          It used a source code verifier to limit programs to an ocap-safe subset.

                                                                          1. 1

                                                                            Yes; that paper is linked from the README ;-)

                                                                            I’ve never actually used Emily though. I got the impression from the paper that it was very much a prototype.

                                                                          2. 1

                                                                            Oooh, very cool that you are using effects and handlers for this! This is something I think they’d be really great at, and would love to see more languages take advantage of! See also: Why Is Crochet Object Oriented?

                                                                            One question about how effects work in Multicore OCaml: I don’t seem to see the effects appearing in the type. Eg. in lib_eunix/eunix.mli we have the following type given for alloc:

                                                                            val alloc : unit -> Uring.Region.chunk
                                                                            

                                                                            But in lib_eunix/eunix.ml there is this implementation:

                                                                            effect Alloc : Uring.Region.chunk
                                                                            let alloc () = perform Alloc
                                                                            

                                                                            Shouldn’t Alloc appear somewhere in the type of alloc, or is that not tracked by Multicore OCaml?

                                                                            1. 2

                                                                              Yes, eventually. There’s a separate effort to get effects into the type system (see https://www.janestreet.com/tech-talks/effective-programming/). But that isn’t ready yet, so we’re using a version of the compiler with only the runtime effects for now.

                                                                              1. 1

                                                                                Yeah, that’s the video I was thinking of! And yeah this explains why I’ve been confused reading the Multicore OCaml examples, so thanks for filling in the gaps in my understanding! Cool that the work can be decoupled at least (the runtime and library stuff alone seems like massive effort).

                                                                          1. 8

                                                                            Although the original post was tongue-in-cheek, cap-std would disallow things like totally-safe-transmute (discussed at the time), since the caller would need a root capability to access /proc/self/mem (no more sneaking filesystem calls inside libraries!)

                                                                            Having the entire standard library work with capabilities would be a great thing. Pony (and Monte too, I think) uses capabilities extensively in the standard library, which allows users to trust third party packages: if the package doesn’t use FFI (the compiler can check this) nor requires the appropriate capabilities, it won’t be able to do much: no printing to the screen, using the filesystem, or connecting to the network.

                                                                            1. 3

                                                                              Yes. While Rust cannot be capability-safe (as explored in a sibling thread), this sort of change to a library is very welcome, because it prevents many common sorts of bugs from even being possible for programmers to write. This is the process of taming, and a tamed standard library is a great idea for languages which cannot guarantee capability-safety. The Monte conversation about /proc/self/mem still exists, but is only a partial compromise of security, since filesystem access is privileged by default.

                                                                              Pony and Monte are capability-safe; they treat every object reference as a capability. Pony uses compile-time guarantees to make modules safe, while Monte uses runtime auditors to prove that modules are correct. The main effect of this, compared to Rust, is to remove the need for a tamed standard library. Instead, Pony and Monte tame the underlying operating system API directly. This is a more monolithic approach, but it removes the possibility of unsafe artifacts in standard-library code.

                                                                              1. 3

                                                                                Yeah, I reckon capabilities would have helped with the security issues surrounding procedural macros too. I hope more new languages take heed of this, it’s a nice approach!

                                                                                1. 4

                                                                                  It can’t help with proc macros, unless you run the macros in a (Rust-agnostic) process-wide sandbox like WASI. Rust is not a sandbox/VM language, and has no way to enforce it itself.

                                                                                  In Rust, the programmer is always on the trusted side. Rust safety features are for protecting programs from malicious external inputs and/or programmer mistakes when the programmer is cooperating. They’re ill-suited for protecting against programs from intentionally malicious parts of the same program.

                                                                                  1. 2

                                                                                    We might trust the compiler while compiling proc macros, though, yes? And the compiler could prevent calling functions that use ambient authority (along with unsafe rust). That would provide capability security, no?

                                                                                    1. 5

                                                                                      No, we can’t trust the compiler. It hasn’t been designed to be a security barrier. It also sits on top of LLVM and C linkers that also historically assumed that the programmer is trusted and in full control.

                                                                                      Rust will allow the programmer to break and bypass language’s rules. There are obvious officially-sanctioned holes, like #[no_mangle] (this works in Rust too) and linker options. There are less obvious holes like hash collisions of TypeId, and a few known soundness bugs. Since security within the compiler was never a concern (these are bugs on the same side of the airtight hatchway) there’s likely many many more.

                                                                                      It’s like a difference between a “Do Not Enter” sign and a vault. Both keep people out, but one is for stopping cooperating people, and the other is against determined attackers. It’s not easy to upgrade a “Do Not Enter” sign to be a vault.

                                                                                      1. 3

                                                                                        You can disagree with the premise of trusting the compiler, but I think the argument is still valid. If the compiler can be trusted, then we could have capability security for proc macros.

                                                                                        Whether to trust the compiler is a risk that some might accept, others would not.

                                                                                        1. 3

                                                                                          But this makes the situation entirely hypothetical. If Rust was a different language, with different features, and a different compiler implementation, then you could indeed trust that not-Rust compiler.

                                                                                          The Rust language as it exists today has many features that intentionally bypass compiler’s protections if the programmer wishes so.

                                                                                          1. 1

                                                                                            Between “do not enter” signs and vaults, a lot of business gets done with doors, even with a known risk that the locks that can be picked.

                                                                                            You seem to argue that there is no such thing as safe rust or that there are no norms for denying unsafe rust.

                                                                                            1. 3

                                                                                              Rust’s safety is already often misunderstood. fs::remove_dir_all("/") is safe by Rust’s definition. I really don’t want to give people an idea that you could ban a couple of features and make Rust have safety properties of JavaScript in a browser. Rust has an entirely different threat model. The “safe” subset of Rust is not a complete language, and it’s closer to being a linter for undefined behavior than a security barrier.

                                                                                              Security promises in computing are often binary. What does it help if a proc macro can’t access the filesystem through std::fs, but can by making a syscall directly? It’s a few lines of code extra for the attacker, and a false sense of security for users.

                                                                                              1. 1

                                                                                                Ok, let’s talk binary security properties. Object Capability security consists of:

                                                                                                1. Memory safety
                                                                                                2. Encapsulation
                                                                                                3. No powerful globals

                                                                                                There are plenty of formal proofs of the security properties that follow… patterns for achieving cooperation without vulnerability. See peer reviewed articles in https://gihub.com/dckc/awesome-ocap

                                                                                                This cap-std work aims to address #3. For example, with compiler support to deny ambient authority, it addresses std::fs.

                                                                                                Safe rust, especially run on wasm, is memory safe much like JS, yes? i.e. safe modulo bugs. Making a syscall requires using asm, which is not in safe rust.

                                                                                                Rust’s encapsulation is at the module level rather than object level, but it’s there.

                                                                                                While this cap-std and tools to deny ambient authority are not as mature as std, I do want to give people an idea that this is a good approach to building scalable secure systems.

                                                                                                I grant that the relevant threat model isn’t emphasized around rust the way it is around JS, but I don’t see why rust would have to be a different language to shift this emphasis.

                                                                                                I see plenty of work on formalizing safe rust. Safety problems seem to be considered serious bugs, not intentional design decisions.

                                                                                                1. 1

                                                                                                  In presence of malicious code, Rust on WASM is exactly as safe as C on WASM. All of the safety is thanks to the WASM VM, not due to anything that Rust does.

                                                                                                  Safe Rust formalizations assume the programmer won’t try to exploit bugs in the compiler, and the Rust compiler has exploitable bugs. For example, symbol mangling uses a hash that has 1 in 2⁶⁴ chance of colliding (or less due to bday attack). I haven’t heard of anyone running into this by accident, but a determined attacker could easily compute a collision that makes their cap-approved innocent_foo() actually link to the code of evil_bar() and bypass whatever formally-proven safety the compiler tried to have.

                                                                              1. 12

                                                                                Yes. The curse of dimensionality gets in the way of explaining high-dimensional models. Historically, this sort of opaque classifier has been used to discriminate. We have discussed this stuff before.

                                                                                1. 3

                                                                                  This is something that I think a lot about, because on the one hand opaque models can be discriminatory… but on the other hand, humans are the ultimate opaque model, and humans can lie, even to themselves, about why they made a given decision.

                                                                                  1. 4

                                                                                    Humans are compassionate more often than not, and can be reasoned with, and we try to design our societies to mitigate for our biases with checks and balances (even though we often fail at this). Machine learning models on the other hand have the ability to be used at scale, with the veneer of being more ‘rational and objective’ than humans. So I’m not sure it’s good enough to say ‘humans are opaque, so then we should be fine with machine learning models being opaque too’, which is what many comments in this thread are suggesting.

                                                                                1. 8

                                                                                  Would this also apply to other tags, in general, like obectivecobjective-c?

                                                                                  1. 15

                                                                                    Yeah, I would also second that.

                                                                                    An alternative is to rename merkle-trees to merkletrees so that it’s consistent with other hyphen-less tag names, but I personally prefer the presence of delimiters.

                                                                                    1. 2

                                                                                      Can always take the Chaotic Good approach and retrofit the rules so names in tags are followed (and preceded?) by hyphens.

                                                                                      1. 3

                                                                                        I propose that names in tags be followed by hyphens only if they end in an “odd” letter (counting starting from 1), so merkle-trees-, formalmethods-, objective-c-, rust, etc.

                                                                                        1. 1

                                                                                          Just strip the hyphens. I want o-b-j-e-c-t-i-vec to be valid, damnit!

                                                                                          1. 8

                                                                                            ObjectiVec is the name of my next OO vector library.

                                                                                    1. 30

                                                                                      And I still can’t shake off a bit of a cult-ish vibe there. Regardless whether on purpose, or purely accidental.

                                                                                      It’s not accidental. See Who Owns the Stars: The Trouble with Urbit for more background about on the political motivations behind the project.

                                                                                      1. 11

                                                                                        “[I]n many ways nonsense is a more effective organizing tool than the truth. Anyone can believe in the truth. To believe in nonsense is an unforgeable demonstration of loyalty. It serves as a political uniform. And if you have a uniform, you have an army.”

                                                                                        ― Mencius Moldbug AKA Curtis Yarvin

                                                                                        1. 2

                                                                                          What’s the context? This can be read as him raising an army by nonsense or an observation of how gullible people are by contrasting the masses to an army.

                                                                                          1. 4

                                                                                            Why not both? There’s precedent.

                                                                                            “You don’t get rich writing science fiction. If you want to get rich, you start a religion.” - L. Ron Hubbard

                                                                                            1. 2

                                                                                              That’s valid too, but combining them pretty much doubles the importance of actual context.

                                                                                              Right now it’s the equivalent of my maybe-favorite reasoning, which is that circular reasoning works because it’s predicated on the fact that circular reasoning works.

                                                                                        2. 15

                                                                                          There is nothing more boring than a personal attack to a systems creator to discredit the system. You need to assume that they are a diety that can predict exactly how every part of the system will interact with every other part.

                                                                                          The article may eventually get to that point, but after reading a third of it and not getting there I have better things to do with my life.

                                                                                          1. 33

                                                                                            Boring, sure, but not necessarily unwarranted. The author goes to great lengths to explain why it is important to him to consider not even the creator alone, but all who will benefit from a system as it grows and becomes widely known / used.

                                                                                            If Urbit were some random open source library I’d agree that attacking the author is pointless. But it’s not, it’s an entire alternative socioeconomic apparatus with the author’s political views embedded within it in a meaningful way (not just in terms of language, which has actually been changed to be less political). He has said as much himself.

                                                                                            To me, the article is more an explanation of why the author won’t participate in or support Urbit rather than a takedown of the system itself. Just like how many people (of all political stripes) don’t shop at certain stores or buy products from certain companies if they disagree strongly with the owners.

                                                                                            1. 2

                                                                                              What prevents someone from forking Urbit or starting a similar project to advance a radical anarcho-socialist platform?

                                                                                              I don’t really care, but that Yarvin guy seems to have put some effort into his work, disagreeable or not, while the opposition focuses on complaining and raging.

                                                                                              If Urbit really is a threat, aren’t online comments the least useful slacktivist countermeasure?

                                                                                              1. 10

                                                                                                What prevents someone from forking Urbit or starting a similar project to advance a radical anarcho-socialist platform?

                                                                                                We have to draw a distinction between Urbit the community and Urbit the software. TFA does discuss both (for example, the author critiques Hoon, which is part of the software). However, the discussion of Yarvin and his supporters is part of a critique of Urbit the community.

                                                                                                An example here might be people who are opposed to using VS Code because of the closed source and Microsoft connections. Most of them would probably feel fine about using a hard fork of the open source code, but that wouldn’t “be” VS Code, it would be some other project / community.

                                                                                                Honestly, it’s even a bit more complicated than this since Urbit the software is designed to reflect a particular set of social values. But I’m not overly concerned with that since a fork could (presumably without much trouble) alter the design.

                                                                                                As an aside:

                                                                                                If Urbit really is a threat, aren’t online comments the least useful slacktivist countermeasure?

                                                                                                If what you meant was that Lobsters comments are useless, talk about boring arguments… No one comes to Lobsters under the belief that their comments will change the world. We’re here to discuss topics we find interesting with people who also like to discuss those topics. The whole “ya’ll are so dumb for discussing something that interests you” meme is tired and unoriginal.

                                                                                                If what you meant was that TFA is useless, then isn’t all political commentary useless? And wouldn’t that include Yarvin’s extensive political commentary? Making an argument about something and putting it out there for others to think about is pretty much the whole point of free speech. No one is forcing you to read it, and no one is forcing you to comment on it.

                                                                                                1. 3

                                                                                                  Nothing prevents this. There’s even a quote from Yarvin from some years ago when he was still actively involved in the project saying that he had no problem with other people forking Urbit’s (open source) code and implementing another Urbit with a different namespace model.

                                                                                                  1. 2

                                                                                                    There have been many without the incompatable-with-existing-software low-performance VM or the intentionally hierachical and rent-seeking namespace/routing scheme. Scuttlebut is probably the most similar variant along the axis of ‘share write-only data in a censorship-resistant way’ (except it actually somewhat achieves the latter).

                                                                                                    For the ‘send someone some ETH to prove you care about the identity’ part of the system, you could just demand whoever you’re talking to have a message in their history where they mention a wallet ID and a planned transaction amount and time to the EFF. You have the added bonus of the money possibly doing something useful rather than going to people who are in a position to receive it precisely because they thought they’d make money or enjoy having power by rent-seeking. I guess this also achieves the feature where it props up Peter Thiel’s investment in Etherium.

                                                                                                    For the we-did-our-own-crypto-it’s-definitely-better-than-openssl in a terribly inefficient VM part, I guess you’ll have to write a scuttlebut client in brainfuck or whatever esolang takes your fancy. You could also just put in some busy loops and rewrite the hashing bit to introduce some security vulnerabilities I suppose.

                                                                                                    Sadly none of this comes with a central body of a few hundred people you need to seek permission from before you can discover peers or have your traffic routed. I guess we’ll just have to form a commune of rent-seeking tyrants or something. That part seems really hard to do under an actually p2p protocol so maybe scuttlebut falls down as a replacement there.

                                                                                                    1. 1

                                                                                                      As somebody who’s thought a lot about what properties make technology better at advancing anarchist ideals, it’s precisely the absence of hierarchy which I would prioritize above all else. Urbit prioritizes hierarchy in every aspect of its permission and identity models. I would never use it as a starting point.

                                                                                                      (Edit: fix typo)

                                                                                                      1. 1

                                                                                                        Sorry - I only now realized that this conversation took place more than a week ago. Please don’t feel any obligation to respond.

                                                                                                  2. 18

                                                                                                    It’s absolutely relevant if the system was designed to enable an anti-democratic agenda. It’s definitely boring to keep having to call the project out on that front, but it’s important to make people aware of the underlying motivations of its creator. I wouldn’t consider this necessary to do if a warning was added to the original post (I do think it’s interesting to look at the technical details of systems like this), but I assume they weren’t aware of this at the time of writing.

                                                                                                    1. 17

                                                                                                      An anti-democratic agenda is not a flaw when it comes to personal computers. If 99% of the population didn’t want me to do something with my personal computer, I would want my personal computer to anti-democratically ignore them and do what I tell it to do anyway.

                                                                                                      Of course the status quo isn’t democratically-controlled computing, it’s oligarchically-controlled computing. When I do my computing on privately-owned, closed-source platforms - Google, Facebook, Twitter, WeChat, etc.- it’s the fairly small number of people who work at those companies who control how I do my personal computing, rather than the electorate of the political unit I happen to live in.

                                                                                                      1. 8

                                                                                                        An anti-democratic agenda is not a flaw when it comes to personal computers

                                                                                                        I think you misunderstand “anti-democratic”. Yarvin has expressed support for dictatorship and slavery. Do you truly think that you would have more computing freedom in such a political environment than in a democracy?

                                                                                                        1. 3

                                                                                                          Possibly, depending a lot on the specific details of how the government of the political unit I lived in were set up. Certainly in a democracy a majority of the people could vote for politicians whose agenda includes restricting my compute freedom (for any number of reasons), and a lot of protections of individual rights in systems we call “liberal democracies” are grounded in self-consciously undemocratic processes, like judicial rulings.

                                                                                                      2. 13

                                                                                                        Which are irrelevant because the creators aren’t omniscient.

                                                                                                        Somehow Stallman enabled Google to happen with his hippie ideas about helping your neighbour. I don’t think creating the worlds largest spy agency was his primary motivation when he wanted the printers firmware source code. What matters is the interaction between the system and the world and not what the original creator intended.

                                                                                                        The article at the top points out those interactions and why they are bad. The article in the comment above is pure character assassination and who ever wrote it should feel bad.

                                                                                                        1. 3

                                                                                                          Somehow Stallman enabled Google to happen with his hippie ideas about helping your neighbour.

                                                                                                          I recommend doing some reading. The main public figure behind what you’re talking about is not RMS, but Eric S. Raymond, co-founder of the sometimes-controversial OSI and originator of the term “open source” (I think the vocabulary already illustrates a bit of a difference). Reading the FSF’s GPLv3 (or this article in particular) is enough to identify that Stallman was actively trying to forestall (wink!) the rise of something like Google on the back of FOSS. Contrast that with ESR’s term “open source”, as discussed in his book The Cathedral and the Bazaar (the name might sound familiar!).

                                                                                                          tl;dr: The best reading about the whole mess by far is this two-or-so–page article from 1999 by O’Reilly.

                                                                                                          As to your point: I guess it is character assassination in part? I think it’s also a decent discussion of the issues surrounding the Urbit project, and the significance of the dynamic between founder/maintainer and userbase. But I’ve only really given it a skim.

                                                                                                        2. 3

                                                                                                          How exactly is the design undemocratic?

                                                                                                          1. 16

                                                                                                            As a point of fact, the distribution of address space is explicitly feudal and meant to enable rent seeking. There are arguments for why this is a good or bad thing, but it is very much not democratic.

                                                                                                            1. 4

                                                                                                              Those concerns are entirely orthogonal.

                                                                                                              Feudalism and rent-seeking are both definitely bad, but it’s entirely possible for a democratic society to vote themselves both. I’d argue that many have; 29% of wealth is taxed in Australia, and ‘public-private partnerships’ (yecch) are funneling vast amounts of taxpayers money into the hands of a few individuals and companies.

                                                                                                              1. 5

                                                                                                                I disagree that this is a category error. Societies can be more or less democratic and feudalism and rent-seeking move power from the people to an elite.

                                                                                                                This is recognised by organisations like the Economist that assess a “democracy index” for various countries. Democracy is the measure of how much the people rule versus how much an elite rule and we can measure it for countries, workplaces, indeed, any community.

                                                                                                                We don’t need to imagine this, we can simply look at the world as it exists. e.g. social democracies like Norway are clearly more democratic* than liberal democracies like the UK and USA where much more power is in the hands of an elite and there is much more widespread misinformation (in large part because the media is controlled by elites), voter suppression, and disenfranchisement through poor voting systems.

                                                                                                                * I think Norway is a more democratic society because:

                                                                                                                • it uses PR so a much greater proportion of the population has a meaningful say on their elected representatives (compare the UK and USA where only swing-constituencies really matter)
                                                                                                                • there is proportionally more variety in media ownership, including significant union-allied media organisations
                                                                                                                • workers benefit from sectoral-bargaining by large and powerful unions, so bosses have less power over workers
                                                                                                                • income distribution is flatter, meaning elites have less economic power relative to the average person. In contrast, in the UK and USA proportionally more people are in poverty and they are much less likely than the rich to exert political power by voting, lobbying, protest or donations.

                                                                                                                We can see the effect of this in the high levels of voter turnout (~75% in Norway vs ~60% in the USA and UK), high level of reported trust in government and media and perhaps more controversially in poverty rates and wealth and income equality (why would a truly free population choose to give so many resources to an elite while others are malnourished?)

                                                                                                                1. 2

                                                                                                                  It’s well known that democracies can vote themselves into, or be manipulated into authoritarianism, which is exactly why it’s important to call out these attempts when we see them.

                                                                                                                  1. 4

                                                                                                                    Yes! But @friendlysock’s point was that feudalism and rent-seeking aren’t democratic. I think that’s a category error; as you point out, it’s well known that democracy can result in either or both.

                                                                                                                    1. 1

                                                                                                                      It is not a category error. You can build non-democratic things out of democratic things.

                                                                                                                      Separating from potential semantic issues. Urbit centralizes power (power over routing, power over peer discovery, namespace being distributed with some mixture of money, seniority and nepotism, voting power only being available to a select few – the senate – who are also endowed with the most of the above) in a way that is somewhere between capital-equals-power and pre-selected, recursively appointed hierarchy (ie. feudalism).

                                                                                                                      The word Democracy in the context that @friendlysock used it very clearly refers to distribution of power (as opposing centralization) rather than voting-as-a-method-of-distributing power.

                                                                                                                      It is difficult to believe that one would respond to such a post as if it were discussing voting-as-a-means-of-power-distribution if one were having a discussion in good faith, and more difficult still to believe one would double down on such an interpretation except as a rhetorical technique.

                                                                                                                      1. 1

                                                                                                                        It is difficult to believe that one would respond to such a post as if it were discussing voting-as-a-means-of-power-distribution if one were having a discussion in good faith

                                                                                                                        Let’s be clear about this, instead of beating about the bush with “it is difficult to believe”. My position is as follows:

                                                                                                                        • I wasn’t conflating Democracy with voting. In fact, I consider voting one of the major problems with modern Democracy. I’m a proponent of sortition as a replacement for voting as a potential solution.
                                                                                                                        • Democracy is orthogonal to centralization, and orthogonal to power distribution, because …
                                                                                                                        • Democracy - in the sense of Government of the people, by the people, for the people - can and has in recent times resulted in despotic centralisation of power. Steering well clear of Godwin here, I’d point to Chavez as an example.

                                                                                                                        Perhaps this is the difference that’s leading you to think I’m arguing in bad faith.

                                                                                                                        I’d argue that in every meaningful sense, a centralised despotic Government with widespread popular support can still be Democratic; it’s just that the will of the people here is the problem.

                                                                                                                        1. 0

                                                                                                                          You still seem to be intentionally confusing things that are the result of a democratic process with things that can be described as democratic.

                                                                                                                          The people of england could have a vote (or the sortition lottery winners could decide) on whether Manchester should be walled off and ruled despotically by Eddie Izzard. It would be the result of a democratic process as the people of Manchester were outvoted by everyone else in England, but the power relationship between Eddie Izzard and the people of Manchester would not be democratic.

                                                                                                                          Similarly decisions based on propaganda and populism are less democratic, and decisions justified via manipulated elections are not really democratic at all.

                                                                                                                          Any relationship which enables rent-seeking is inherently undemocratic, and any rent-seeking-enabling structure explicitly ruled by the 256 people chosen by virtue of their capital and interest in having power over said structure is not democratic at all.

                                                                                                                          Very loosely, when used as an adjective in the context above, ‘Democratic’ would mean the people with power are the people whose interests are most relevant. This is inherently and definitionally untrue in any rent-seeking relationship (although the relationship could still be a result of a greater structure which is democratic), and untrue in any system which can accurately be described as feudal.

                                                                                                                          1. 1

                                                                                                                            You still seem to be intentionally confusing things that are the result of a democratic process with things that can be described as democratic.

                                                                                                                            I think this is at the heart of our disagreement, and where we may have to agree to disagree.

                                                                                                                            I would say that a state of affairs arrived at by a democratic process is by definition democratic; although it may also be rent-seeking, feudal, or despotic. Or some combination of all three.

                                                                                                                      2. 1

                                                                                                                        Ahh, got you, sorry for misunderstanding!

                                                                                                          2. 2

                                                                                                            Indeed. But also be forewarned that the author of that article is an avowed socialist; there are distasteful politics of all flavours on display here.

                                                                                                            1. 17

                                                                                                              Not all distasteful things are equally distasteful.

                                                                                                              1. 13

                                                                                                                That’s true; but Yarvin’s politics are still pretty damn distasteful.

                                                                                                              2. 10

                                                                                                                wonder how he manages to reconcile his socialism with his distasteful politics

                                                                                                                1. 4

                                                                                                                  I think gulags were the preferred mechanism?

                                                                                                            1. 32

                                                                                                              I find this whole thread depressing.

                                                                                                              We have a long technical and economic list of why Urbit has a lot of problems and yet 2/3rds of the comments are about the politics of the guy who wrote it and has now stepped down. Character assassination is something everyone in open source has to deal with and I would have hoped people who are at least somewhat involved in the field would know better.

                                                                                                              Sacrificing scapegoats in the hope you’re not targeted never works.

                                                                                                              1. 16

                                                                                                                Urbit submissions are third-rail submissions, and have been for as long as I’ve been a member here.

                                                                                                                The best thing to do is to hide them and get on with your day.

                                                                                                                1. 13

                                                                                                                  Which is really stupid because distributed systems are the only way that we can ensure that the internet isn’t taken over but we still have no idea how to build them so they can operate at scale, work for micro-payments and not have a central server - all the crypto coins have been a huge disappointment with their ridiculous fees and the time needed for a transaction to be logged.

                                                                                                                  That Ted Nelson managed to predict the problems of an internet with no payment layer in the 60s yet we’re still no closer to solving even basic routing with payment 60 years later is dismaying.

                                                                                                                  1. 12

                                                                                                                    Nelson’s ideas about compensation and the value of information were simply wrong. If Nelson’s vision had taken place, then Wikipedia wouldn’t exist, because it would have been slowly cut to pieces by middlemen. Instead, those middlemen are relegated to the second page of search-engine results.

                                                                                                                    Instead, take a page from the communists, and distribute the means of production. Give people enough democratic control of enough computational power, and they’ll maintain common resources for everybody. The recent revolution of Libera from Freenode is instructive.

                                                                                                                    1. 5

                                                                                                                      Those middle man now edit Wikipedia for a fee.

                                                                                                                      Go to any medium to large corporation that you know where the skeletons are buried and read the article. Be amazed that all the publicly available information about corruption, fines, prison sentences and human rights abuses aren’t in Wikipedia and are relegated to the second page of search-engine results.

                                                                                                                      Which is ironically what Ted Nelson said would happen if we couldn’t monetize content so people could live of it in a capitalist society. Everything is now an ad, including Wikipedia. We are the product and we’re cheering on the free ed-vertisement like geese cheering the farmer for the free food.

                                                                                                                      1. 4

                                                                                                                        While I will admit that paid editors generally have a large advantage over volunteers in the amount of time they can dedicate, you can report particular instances of abuse to me, https://en.wikipedia.org/wiki/Wikipedia:Conflict_of_interest/Noticeboard, or other venues on or off Wikipedia, like our IRC or Discord channels.

                                                                                                                    2. 8

                                                                                                                      Monero is basically the coin you’re describing, with one-minute confirmation times and incredibly low fees (the devs are constantly solving difficult equations in the quest to lower fees), but is on the verge of being made illegal for being too-much like cash.

                                                                                                                      1. 18

                                                                                                                        I’d really like to believe that, but after bitcoin, tether, etherium and a whole bunch of other shit coins I just don’t have the mental energy to spend yet another weekend reading about a coin that will solve all the worlds problems and find out that it’s just a different flavour of pump and dump.

                                                                                                                        1. 3

                                                                                                                          Monero really does work like private cash and has quick confirmation times as @WilhelmVonWeiner said. Plus it exists right now and you can derive value from it right now. That said, it’s fair to be exhausted from the pump-and-dump garbage fest that crypto is now. I tell most of my friends that unless you’re willing to literally sift out the shit, crypto isn’t the place to be right now.

                                                                                                                          1. 3

                                                                                                                            100% agreed with you there, the early Ethereum craze really killed a lot of interest for me in shitcoins. I like the competition though because it drives innovation.

                                                                                                                            I’ll just say that Monero is at least worth reading about as it solves Bitcoin’s fungibility problem in a much more user-friendly and effective way than making people use coinjoins and careful UTXO management. Fungibility is becoming more and more important because of the advancements being made in chain analysis. KYC exchanges these days are closely watching what you do with your BTC both before & after the coins touch their systems.

                                                                                                                            It also seems to be effectively preventing mining centralization with RandomX (ASICs and GPUs aren’t cost effective to mine it), so it’s closer to the original “one CPU, one vote” idea of BTC.

                                                                                                                      2. 4

                                                                                                                        They’re third-rail submissions in large part due to the persistent campaigning of certain users, yourself included if memory serves. Let’s not pretend otherwise.

                                                                                                                        Edit: memory served poorly. :(

                                                                                                                        1. 12

                                                                                                                          I think Urbit is a project doomed for irrelevance for many reasons, and I’d rank Yarvin’s ideology around third in the list of those reasons. But if I’ve ever tried to shut down a discussion about it on this site, I’d welcome an example. It was never my intention of doing so.

                                                                                                                          1. 13

                                                                                                                            I double-checked my work and I offer you my profuse apologies. In the last year at least I can’t find you having done what I complained of. Sorry about that!

                                                                                                                            1. 12

                                                                                                                              Apology accepted!

                                                                                                                              Maybe we need a RES for lobste.rs…

                                                                                                                      3. 13

                                                                                                                        All the articles that mention Yarvin’s “politics” quote from and link to primary sources. “How dare you quote the exact words I said” is kind of a flimsy basis for claims of “character assassination”, and when the project in question is meant to enact the creator’s beliefs onto the world it is always on-topic to analyze and discuss those beliefs, since acceptance of the project’s technology is, by the project’s design, inseparable from acceptance of the creator’s “politics”.

                                                                                                                        1. 20

                                                                                                                          I’d say in this case it’s not character assassination, but rather character suicide

                                                                                                                          1. 19

                                                                                                                            Terrible, he killed himself by stabbing himself in the back twelve times.

                                                                                                                            If you look at the sources on the wiki list none of them actually link to his writing, but to people writing about his writing to explain why what he said is racist, without actually linking to any of his writing.

                                                                                                                            I find it ironic that the skill of detecting character assassination I developed to find worthwhile socialist and anarchist authors in the 00s is now something I’m using to do the same for right wingers.

                                                                                                                            1. 24

                                                                                                                              I have a limited amount of time in this Earth, and I am yet to see any evidence that trying to find out whether someone that seems a nazi is a nazi is worth spending any of it.

                                                                                                                              1. 20

                                                                                                                                You would perhaps be interested in how that exact type of thinking allowed big tobacco to use Nazi anti-smoking policies to paint all its detractors as Nazis for decades after the war and kill more people than the holocaust: https://theconversation.com/smoking-rates-in-us-have-fallen-to-all-time-low-but-how-did-they-ever-get-so-high-107185

                                                                                                                                Calling someone a word doesn’t mean they are wrong, it means you don’t have anything to say.

                                                                                                                                1. 17

                                                                                                                                  I am sure you might be able to raise all sorts of reasonable doubt over whether or not this dude is a nazi, specifically, just nazi adjacent, or just an asshole in general.

                                                                                                                                  I am not, however, a court of law. I’m just a guy, with limited time and resources (way more limited than the justice system, by the way), so I go by general heuristics and even gut feeling. And that’s truth by pretty much all of us, really, despite how rational people think they are.

                                                                                                                                  So far, all I seem of that guy points to a direction, and it ain’t a good one. There are LOTS of other people being silenced and de-platformed for inconvenient and unpopular opinions that are CERTAINLY more deserving of my time, so, this dude will seat on my nazi bucket and I will not give it a second time until extraordinary and massive evidence surfaces indicating otherwise.

                                                                                                                                  The whole point of me even posting this is that it doesn’t actually talks much about the political aspects (although it doesn’t ignore it), just goes over some very technical and concrete reasons why it’s kinda crappy.

                                                                                                                                2. 6

                                                                                                                                  “Always judge a book by its cover”?

                                                                                                                                3. 15

                                                                                                                                  If you look at the sources on the wiki list none of them actually link to his writing, but to people writing about his writing to explain why what he said is racist, without actually linking to any of his writing.

                                                                                                                                  This is not surprising given that Wikipedia cannot be trusted on controversial topics. I wish people stopped linking to Wikipedia (unless the topic is uncontroversial), and instead cited the sources directly.

                                                                                                                                  1. 9

                                                                                                                                    Imagine spending your time going on the internent to cape for someone who claimed that race determines one’s “intelligence”

                                                                                                                                    Seems like a waste of time to defend nazis online but go off I guess.

                                                                                                                                    EDIT: I love that people on this website think that my comment was unkind, off-topic and/or trolling. Great to live in 2021 where people are going to bat for extremely blatant nazis because apparently arguing for a fascist state ruled by tech CEO’s, or that race determines one’s “intelligence”, or that slavery is good isn’t enough to be considered a straight up nazi. Cool. Awesome!

                                                                                                                                    1. 14

                                                                                                                                      Thanks for (implicitly) asking for feedback! That’s a great start.

                                                                                                                                      I think your comment is about as off-topic as the rest of the thread. If you’d like to know what you did differently, your comment targets and criticizes another member for having a different opinion in a mutual conversation, and with a sarcastic tone of voice at that. It seems like the kind of comment that would be better suited for Twitter than Lobsters—a short, quippy, dismissive take that adds nothing to the conversation but to half-assedly try to shut it down and embarrass others. That’s why I chose to flag your comment as “off-topic”, for lack of a better term.

                                                                                                                                      Before you commented, I saw it as an honest conversation that was less about the story and more about how we judge people online in general, often at face value whilst ignoring the substance and context of a conversation. After you commented, it became about judging people online, while ignoring the substance and context of the conversation. So ironically, your comment does the exact thing the thread debates. Maybe a better phrase than “off-topic” would be “um, hey. that thing you’re doing right now? yeah, we were just talking about that”.

                                                                                                                                      In general, I think Lobsters is better when the authors of these types of comments actually engage with the conversation. Or, failing that, if unkind things directed at fellow denizens are just left unsaid.

                                                                                                                                      1. -6

                                                                                                                                        Imagine writing all this that I won’t read just because you want to cape for nazis.

                                                                                                                                4. 9

                                                                                                                                  FWIW what I think people are missing is that he was not great at advocating his beliefs, and probably considers his project a failure in that respect.

                                                                                                                                  He has left the project and his writings and beliefs have been disavowed by the current maintainers of the project. See the end of the FAQ: https://urbit.org/faq/

                                                                                                                                  Curtis laid the foundation for Urbit by delivering its first prototype but, since 2013, it has been refined and almost entirely rewritten by a community of developers. No one working on Urbit today had anything to do with Curtis’s writing. For the most part, we couldn’t be less interested in it.

                                                                                                                                  So I would suggest that it’s OK not to take him that seriously. Maybe 5 years ago, but not now.

                                                                                                                                  Also I remember that ironically his farewell blog post indicates that leaving the allocation of Urbit real estate to the free market produced a result he wasn’t happy with … it wasn’t in line with his notion of “fairness”


                                                                                                                                  What seems to be happening now is that the current maintainers are actually producing useful documentation about the system, moving away from all the intentional obscurantism. It does seem like Urbit is flawed as a system, but there are some interesting design elements for sure.

                                                                                                                                  Both of these docs are pretty good reading for people interested in the intersection of languages and operating systems:

                                                                                                                                  https://urbit.org/docs/hoon/overview/

                                                                                                                                  https://urbit.org/blog/io-in-hoon/

                                                                                                                                  They use regular words and are quite readable :) (in contrast, the political stuff was always danced around in a way to create plausible deniability; there’s none of that here)

                                                                                                                                  It seems obvious to me that Urbit will not succeed or become mainstream, so I’m not very threatened by it. But it has plenty of ideas that are not about policies for resource allocation (i.e. the political stuff). A lot of it is about the representation of code and data for a distributed/networked operating system.

                                                                                                                                  1. 3

                                                                                                                                    I’m really glad they are working on making it less obscure, and documenting the system. The linguistic approach to operating system design is definitely fascinating, and is what originally got me interested in Urbit in the early 2010s when I came across it (before I learned about the underlying goals of the project).

                                                                                                                                    He has left the project and his writings and beliefs have been disavowed by the current maintainers of the project. See the end of the FAQ: https://urbit.org/faq/

                                                                                                                                    Curtis laid the foundation for Urbit by delivering its first prototype but, since 2013, it has been refined and almost entirely rewritten by a community of developers. No one working on Urbit today had anything to do with Curtis’s writing. For the most part, we couldn’t be less interested in it.

                                                                                                                                    In the circumstances if they really want to convince me that they’ve cut ties, I’d want them to clearly denounce the racist and pro-slavery views of the creator, and demonstrate how they are rearchitecting the project to move away from the original feudalistic, non-egalitarian aims of the project. Given the project’s history it’s important this needs is addressed explicitly, rather than hiding behind euphemistic statements which give fascists a space to continue to work unchecked.

                                                                                                                                1. 9

                                                                                                                                  While I am far from being an expert on this topic, I have always felt that the importance of incompleteness theorems in computer science and mathematics has been overstated. Part of the reason is terminology – while it’s true in mathematical terms that “you can’t prove everything that’s true”, the statement sounds a lot deeper than it really is because the mathematicians are using a very specific definition of “proof” and “true” and “everything” that doesn’t necessarily correspond to the definitions we are all familiar with.

                                                                                                                                  I like to see incompleteness as a modeling problem. We normally choose a certain set of axioms to encode our assumptions about the world. Those axioms aren’t exhaustive, so it’s possible to imagine two systems which satisfy the axioms but differ in other important ways, leading to statements that are “true” in one system but “false” in the other. If you want to narrow the scope of your analysis, you need to introduce more axioms – so we have things like parallel postulate to separate Euclidean from non-Euclidean geometry. This is a reminder that all models are wrong, but some are useful. If we study the world through a lens of a particular set of axioms, we might be able to use the axioms to prove things about the world, but behavior we observe in the world may or may not be a consequence of those axioms.

                                                                                                                                  1. 9

                                                                                                                                    Philosophers brought up exactly this objection to Gödel’s initial work: Sure, perhaps the Peano natural numbers are incomplete, but that doesn’t mean that reality itself is incomplete or inconsistent, just that Peano’s definitions are incomplete.

                                                                                                                                    Tarski saw how to extend Gödel’s work to cover this loophole. Tarski’s Undefinability of Truth is, broadly, the claim that a sufficiently-complex formal system is always unable to talk about its own notion of truth. Here, “proof” means a sequence of logical syllogisms, “true” means proofs that start from axioms, and “everything” means any objects which are described inside the formal system. Tarski took Gödel’s statement about natural numbers, and extended it to any system which claims to talk of beauty, love, truth, etc., as long as that system also happens to know about natural numbers.

                                                                                                                                    What Gödel showed isn’t that all models of the natural numbers are wrong, but that some models of the natural numbers are useful. Rather, what they showed is that all theories of the natural numbers are incomplete at best. No finite listing of first-order axioms can fully describe the natural numbers; given any such set of axioms, Gödel showed how to generate an infinite list of axioms G₀, G₁, etc. which each denote a true-but-unprovable fact about natural numbers.

                                                                                                                                    In general, we need to understand that theories (axioms and rules) are not the same as models (objects described by the axioms and rules), or else Skolem’s Paradox will keep us up at night.

                                                                                                                                    Finally, we now know from category theory that there is a beautiful generalization of Gödel and Turing, known as Lawvere’s fixed-point theorem. Lawvere showed that Cantor, Turing, Gödel, Tarski, and others were all talking about the same situation, where a categorical construction – a transformation which can decide any possibility – is handed its own negation. Lawvere explains that the paradox comes from our interpretation of these constructions as self-referential, tying an imaginary knot which isn’t in the formal theory.

                                                                                                                                    1. 3

                                                                                                                                      Can you recommend any good accessible books (or other material) on formal model theory?

                                                                                                                                      The kind of thing that would teach precisely what is meant by a sentence (from the Tarksi Wikipedia article) such as:

                                                                                                                                      Let L be the language of first-order arithmetic, and let N be the standard structure for L.

                                                                                                                                      1. 3

                                                                                                                                        Raymond Smullyan’s Godel’s Incompleteness Theorems is a good introduction. The slick proof of the second incompleteness theorem using Löb’s theorem can be found in Boolos’ Provability Logic but that text is heavier…

                                                                                                                                        1. 2

                                                                                                                                          I recently read and enjoyed An Introduction to Gödel’s Theorems, which is comprehensive and gradual, slowly exploring everything I talked about except for Lawvere’s work. Their version of Tarski starts on p197.

                                                                                                                                          1. 2

                                                                                                                                            I recently encountered https://stopa.io/post/269, which is quick but useful.

                                                                                                                                            1. 2

                                                                                                                                              It’s hard to believe that a person could really prove that something can “never” happen — imagine if someone told you that we could never travel farther than our solar system — you’d look at them with suspicion.

                                                                                                                                              I’d need a whole lot more technical and scientific evidence before accepting humanity will travel significantly within the solar system, never mind out of it.

                                                                                                                                              1. 1

                                                                                                                                                Yeah that’s a strange phrasing. There’s plenty of math theorems that prove something can never happen. Off the top of my head, the irrationality of sqrt(2) comes to mind.

                                                                                                                                                https://en.wikipedia.org/wiki/Proof_by_contradiction#Irrationality_of_the_square_root_of_2

                                                                                                                                          2. 1

                                                                                                                                            Tarski’s Undefinability of Truth

                                                                                                                                            Interesting. This looks a bit like a formalization of the Münchausen trilemma.

                                                                                                                                          3. 6

                                                                                                                                            Yeah, I know what you mean – it’s definitely a bit frustrating when folks in programming circles bring up the halting problem and undecidability whenever you try to talk about formal verification, for example.

                                                                                                                                            I think this was kind of touched on towards the end of the video, where the presenter explains how the incompleteness theorems didn’t result in the collapse of mathematics, and we can still do a huge amount of work in spite of them. And that the result of grappling with self-reference and undecidability in mathematics was many advances that we take for granted today. So while we have learned to accept it now I think it’s still incredibly useful to teach people about.

                                                                                                                                            1. 3

                                                                                                                                              I like this way of thinking about it, but still it strikes me as incredible, and not at all obvious, that this same “parallel postulate problem” will crop up in any (sufficiently powerful) axiomatic system, and that we can prove this meta fact formally. It’s a mind-blowing intellectual achievement.

                                                                                                                                            1. 14

                                                                                                                                              I was expecting the worst, but this was actually a really well-done video explaining the issues to do with completeness, consistency, and decidability in mathematics, and how it relates to computer science. Highly recommended!

                                                                                                                                              1. 10

                                                                                                                                                Moreover, there is also a lack of knowledge about Karl Popper and the scientific method in scientific circles. For most it is counter intuitive to understand the rejection of the inductivist approach of the scientific method and the limits sets by the empirical falsification. Accepting that in empirical sciences, no theory can be proven is at the opposite how education and teaching scientific theory is done and how the transfer of knowledge occurs in academia (being lessons at university or peer-reviewed research). I wish we could accept and teach a more probabilist view of the truth without the need to set in stone everything. It goes further than just science but it is really present in the scientific discouse.

                                                                                                                                                1. 4

                                                                                                                                                  This reminds me of Gettier’s two-pager “Is Justified True Belief Knowledge?” His counter examples rely on conclusions from cogent inductive arguments being true for the wrong reasons.

                                                                                                                                                2. 3

                                                                                                                                                  The few minutes starting here are the best explanation I’ve seen of why the halting problem is undecidable.

                                                                                                                                                1. 12

                                                                                                                                                  Ironically, this circles back to the original feature RSS was invented for: updatable 3rd party widgets on the Netscape home page (which was Navigator’s default start page.)

                                                                                                                                                  1. 2

                                                                                                                                                    This was my first thought. This is a major coup for RSS!

                                                                                                                                                    1. 4

                                                                                                                                                      I guess it’s good? But never forget it was Google who almost extinguished it in the first place.

                                                                                                                                                      Was really sad when Firefox ditched live bookmarks back at the end of 2018 after holding out for so long. :/

                                                                                                                                                      1. 2

                                                                                                                                                        By killing Google reader? Or something else?

                                                                                                                                                        When Reader died, an entire ecosystem cropped up in its place. I and about a zillion other people switched to Feedly or various alternatives and didn’t miss a beat.

                                                                                                                                                  1. 4

                                                                                                                                                    Some interesting comments from the project lead over at HN.

                                                                                                                                                    And here’s the user-facing post. I created a space for Haskell here (it includes the IRC bridge to #haskell).

                                                                                                                                                    1. 1

                                                                                                                                                      I created a space for Haskell here (it includes the IRC bridge to #haskell).

                                                                                                                                                      URL changed to: https://matrix.to/#/#haskell-space:matrix.org

                                                                                                                                                      1. 1

                                                                                                                                                        How did you set the URL of the space? Been wanting to do this for Pikelet, which is currently a random hash…

                                                                                                                                                        1. 1

                                                                                                                                                          You add an alias for the room that is the space. The UI is probably missing currently, but you can use the API. https://matrix.org/docs/spec/client_server/r0.6.1#put-matrix-client-r0-directory-room-roomalias

                                                                                                                                                          1. 1

                                                                                                                                                            Is there a way to send this request from element in the browser, or so I need to do some more involved shenanigans for this?

                                                                                                                                                            1. 5

                                                                                                                                                              More involved shenanigans, sadly. Adding aliases to Spaces is top of the list for the next wave of work in the beta though.

                                                                                                                                                              1. 1

                                                                                                                                                                No worries, looking forward to it! Thanks for your efforts!

                                                                                                                                                    1. 5

                                                                                                                                                      Wow, this is great! So many FOSS projects are using Discord instead of IRC, probably because of discoverability, and how easy it is to join a new “server” (which is actually run by Discord, not by you).

                                                                                                                                                      This really reminds me of Discord because of the spaces listing on the left, which DIscord also has.

                                                                                                                                                      Sometimes you just gotta steal a feature if it works!

                                                                                                                                                      1. 1

                                                                                                                                                        Yeah, I used to use the old ‘communities’ thing for this, but spaces approach seems a bit nicer. I also use t2bot to bridge to a discord server for folks who prefer discord. Does mean I need to be logged into both though (as a moderator). I am a bit concerned at how moderation will work across a space - it would be useful to be able to apply the same policies over multiple rooms for example. Discord is still much better on that front.

                                                                                                                                                      1. 6

                                                                                                                                                        Any measurements on resource usage? My tab count on Firefox quite often exceeds 100, and with current architecture, the resident memory cost of a processes make up only a small portion of total memory usage. With Chrome, high memory usage is one of the main problems I encountered, so I fear that with this model Firefox might turn that way as well.

                                                                                                                                                        1. 3

                                                                                                                                                          I’ve also got about a 100 tabs open divided over 4 windows. Currently Firefox only has 13 processes running of which 5 are named “FirefoxCP Isolated Web Content” on macOS, so it looks like it only creates processes for recently used tabs.

                                                                                                                                                          1. 2

                                                                                                                                                            IIUC there is a process per domain (ie. not a process per tab, like in Chrome), which should cut down some memory use. But yeah I don’t know much of the specifics.

                                                                                                                                                            1. 3

                                                                                                                                                              it’s process per site

                                                                                                                                                              1. 2

                                                                                                                                                                Because the OS can just swap out the idle ones?