1. 80
    SourceHut + Plan 9 = <3 osdev sourcehut.org

  2. 36

    Probably the single most popular piece of Plan 9 heritage used all over the world: UTF-8.


    1. 9

      I really enjoy this bit of whimsy. It’s a fun environment and it’s great to see folks keeping it alive. I’ve noticed that the 9p protocol lives on in unexpected places (QEMU, crostini).

      Next I’d like to see DOS (like FreeDOS) so that projects like https://www.brutman.com/mTCP/mTCP.html can get CI. There’s no real reason to do this other than for fun, which means there’s every reason to do it ; )

      1. 8

        Bell Labs has been merged into Nokia, I wonder if there are any p9 devs left there.

        1. 13

          None that I’m aware of.

          That said, 9front is still fairly active. Commits this year:

          cpu% hg log -d '2020-1-1 to 2020-05-11' | grep '^changeset:' | wc -l

          And the last month:

          cpu% hg log -d '2020-04-11 to 2020-05-11' | grep '^changeset:' | wc -l
          1. 5

            Could you imagine a Plan 9 Nokia phone?! Actually, I wonder how hard it would be to create a mobile version of Plan 9… the very opinionated GUI that insists on e.g. a middle mouse button doesn’t give me hope.

            1. 7

              If it hadn’t been a few years too early, Plan 9’s successor Inferno might have been a contender on phones.

                1. 8

                  In addition to hellaphone, there are already people working on running Inferno on the PinePhone.

                2. 5

                  There was an ipaq version[1]. It apparently used the side buttons for chording, and Plan 9 ships with an on-screen keyboard with hand writing recognition that was written as part of the port.

                  That said, what exists is not a very good fit for modern touch UIs. The underlying GUI system should work fine, but /dev/gesture would need to be created (could be done easily as a userspace file server), and applications would need to be purpose-written or heavily modified.

                  [1] ipaq: https://en.wikipedia.org/wiki/IPAQ#/media/File:PocketPC-HP-iPAQ-h2210.jpg

              1. 8

                The Go programming language is a direct descendant of Plan 9, along with Linux and BSD’s /proc filesystems, user namespaces, and more.

                What does it mean that Go descends from Plan 9? I can see how /proc and user namespaces would be inspired by features from Plan 9, but I don’t see the connection with Go (unless the author means they were both created by the same people).

                1. 30

                  What does it mean that Go descends from Plan 9

                  The first go compilers were copy-pastes of the Plan 9 C compiler, with a new frontend. You can compare, for example, https://github.com/golang/go/tree/release-branch.go1.4/src/cmd/cc and https://code.9front.org/hg/plan9front/file/965e0f59464d/sys/src/cmd/cc

                  The concurrency model is based off Rob Pike’s experiments with Squeak, Newsqueak, Alef, and Limbo (One of which, by the way, did have generics).

                  1. 12

                    There are several pieces of Go that are explained by plan 9. Originally the c compiler used to compile go was the plan 9 compiler (6c iirc). Struct Embedding is borrowed from plan 9 c. http://doc.cat-v.org/plan_9/programming/c_programming_in_plan_9

                    The library interfaces (like net.Dial) are borrowed from plan9 https://9fans.github.io/plan9port/man/man3/dial.html

                    Channels and a M:N threading model: http://man.cat-v.org/plan_9/2/thread

                    1. 9

                      Plan 9 -> Inferno -> Limbo -> Go

                      The lineage is directly tracable, and a lot of Go features (channels and goroutines in particular) are directly taken from Plan 9.

                      1. 7

                        There is a philosophical connection too, if I may call it that.

                        On Plan9, most things of importance are implemented as file servers. This makes Plan9 pretty much the ultimate “existing tools work with new objects” system. (aside: I highly recommend the “Unix, Plan 9 and the Lurking Smalltalk” paper on this topic).

                        Programming in Go also has this feeling of “existing tools work with new objects”, due to the ubiquitous use of interfaces: error, io.{Reader,Writer}, net.Conn, and so forth. Almost all the Go code you will ever write uses these. Everything works well together. This in itself is nothing revolutionary: other languages have I/O streams as well (or iostreams even, ha!). But Go is designed for these pretty much from the bottom up, and due to the fact that the runtime abstracts away asynchronous I/O where possible, performance is commendable too.

                        1. 3

                          The build system and compiler are built very similarly to Plan9 counterparts.

                        2. 4

                          Where can I find more information about why Plan 9 is amazing, especially how it compares/contrasts to Linux or Unixes?

                          1. 9

                            I found this paper to be a wonderful walkthrough. I highly recommend getting a copy of 9front running, and going through some the exercises in the paper.

                            It’s very long, but definitely a great way to get a feel for how some of the concepts in Plan 9 are applied.

                            Edit: Since I was reminded how much I like this paper, I decided to submit it as a story.

                            1. 5

                              Some goodies from Plan 9 were ported to *nixes, for example procfs, unfortunately not all of them (Plan 9 like process namespaces).

                              1. 7

                                Unfortunately, the best piece of plan 9 is impossible to port: A unified, interposable way of doing everything, so you don’t have to think about huge numbers of special cases and strange interactions between features. 9p is, more or less, the only way to talk to the OS, and the various interfaces that are exposed over it can be transparently swapped out with namespaces, allowing you to replace, mock out, or redirect across the network any part of the system that you want.

                                1. 4

                                  Well, Linux namespaces got 90% of the way there, although they certainly didn’t get their ergonomics.

                                2. 3

                                  I just watched the video https://www.youtube.com/watch?v=3d1SHOCCDn0

                                  Found the way the presenter explained the core concept very understandable. It is 40 minutes long.

                                3. 8

                                  Wasn’t the consensus that “regular” (non-release) sourcehut posts are just advertising? Or has that changed, because @ignaloidas seems to have been posting a lot of their content recently.

                                  1. 22

                                    Clearly this was of interest since it was voted to the top of the site. There’s also interesting technical detail in here. I am a bit of a DeVault fanboy but tbh I think this is better content than a lot of the personal blog posts that get submitted here.

                                    1. 6

                                      There’s also interesting technical detail in here.

                                      Fair enough, I just don’t think every announcement should be reposted here.