1. 42
  1.  

  2. 19
    1. 6

      In the second link, the horses metaphor is hilarious. All I’m saying to keep from spoiling it.

      1. 2

        Didn’t really like that second article. You can make phones and web servers and IoT devices without even a hint of unix. It’s just, most people decide not to.

        1. 1

          Maybe for phones and web servers. For IoT (aka embedded), a lot of devices aren’t UNIX. Maybe most of them. I know most in embedded are RTOS’s or custom code. I just don’t know if most in Internet-connected embedded avoid Linux.

      2. 12

        The light-grey on light-grey is too hard for me to read, I had to stop :/

        1. 3

          I removed the opacity for u element in my web inspector. Note that a value of 0.5 (instead of 0.25) is fairly reasonable.

          I also have problems with this text disappearing sometimes: https://i.imgur.com/RPOQYdX.png – I added that red line myself to indicate missing text. Also note the &em; It seems to happen when I select/hover/click text? It’s pretty intermittent. Using Firefox.

          Arguably, such frequent use of asides is not a great writing style by the way.

          FYI @zge

          edit: I think you’re missing a “not” before “because” in this sentence here?

          But people have not tried to go “beyond” Unix, because they are evil or ignorant, but because the

          1. 1

            I’m sort of conflicted about raising the value to 0.5 (currently it’s at 0.3333, and 0.6666 when hovered over) since the <u> tags are unarticulated side notes, comments or background voices – I kind of abuse it too much, I admit that.

            All I can say about the disappearing text is that it works on my machine, even though I also just use Firefox… Maybe I should try opening it in chromium or some different engine.

            Also thanks for the hypo notice. Most of it was written just before midnight, so I didn’t get around to properly go over it again. I will be reformulating some of the sections, particularly those with many <u> tags, when I have the time, so hopefully I will also be able to make it a bit easier to read too.

            1. 3

              since the tags are unarticulated side notes, comments or background voices – I kind of abuse it too much, I admit that.

              In my personal opinion, side notes should rarely be used. It breaks the flow of the text, and much of the time it’s a “hack” for writing down a proper paragraph that flows well. In other cases, it’s just an aside which isn’t too relevant to the topic at hand, in which case it should probably just be omitted; more words does not equal a better article. I have similar feelings about text in parenthesis by the way, which some people over-use (including myself ☺), especially when it’s used as a hack to clarify a badly written sentence, instead of clarifying the sentence.

              At any rate, in your case because the asides are so often interspersed in regular paragraphs with a different colour, I find it breaks the regular “flow” of the paragraph, and everything comes across as “disjointed”.

              Just my 2¢. Writing is of course very subjective, so reasonable people could disagree.

              All I can say about the disappearing text is that it works on my machine, even though I also just use Firefox… Maybe I should try opening it in chromium or some different engine.

              I mucked about some more, and can reproduce it fairly reliable by selecting text with double/triple click, but only if there is a line break between [ and ] (in which case all text before the line break disappears). I tried looking at the JS, but it’s all minified.

          2. 2

            if you’re reading on Firefox then you can activate reader mode which makes the reading experience quite pleasant. It looks like this. You can activate it by clicking the little document icon that is present on the address bar after you load a page which has a recognizable content/article part

            1. 2

              Oh, I’m sorry about that. I tried increasing the opacity, since I didn’t realize that that was a problem.

            2. 5

              I’ve been thinking about these issues in depth too. Like the problem you mention of passing a float between programs, what if we could pass more than text - but arbitrary structured, typed data. This is not science-fiction, it’s really simple to implement. We know things about programming that weren’t really known or understood back in the early UNIX times. The difficulty is that we can’t just implement it in the shell, it also needs to be common to the userspace binaries we work with all the time (like all the GNU coreutils). At the very least, why couldn’t we at least experiment with a UNIX shells and applications that interchange using tab separated values?

              On hypertext, there’s been so much excellent theory worked out - but other than the WWW - very little of it rolled out it’s worth mentioning purplenumbers on the topic of being able to link to specific parts of a document https://communitywiki.org/wiki/PurpleNumbers - we can also ask about annotations and snapshotting segments of documents to be included in others.

              1. 10

                Had me at “arbitrary structured, typed data.” - immediately thought of PowerShell, which - while just one tool of many - meets your requirement of “be(ing) common to the user space binaries we work with…”

                1. 6

                  The structured-ness of PowerShell is nice in theory, but, like every other Microsoft product, the rest of PS is totally botched in implementation. Between long, awkward-to-type command names, lack of laziness for piped data, generally poor COM support in software, and pervasive slowness, it’s easier and faster to write a shell script with grep, awk, and sed.

                  The unix shell is arcane, but I’ve yet to find anything that’s as good for quickly getting to the information I need. SQL is probably the closest, but requires data to be structured from the start.

                  1. 5

                    PowerShell Core is even available for Linux, complete with installation instructions. I haven’t yet taken time to get my head around PowerShell, even on Windows, but maybe I should.

                    1. 4

                      It’s not obvious to me how to do this completely properly. OO is the wrong approach IMHO, as you don’t want to be passing behaviour downstream. Something like algebraic data types might be promising, but then you have to send a description of the data down the pipe before any data itself?

                      Erlang’s a bit on my mind today (RIP Joe), but maybe something like its pattern-matching system would work well here?

                      1. 3

                        As a paradigm, object-oriented may not be the best approach, especially when attempting to solve the problem mentioned in the link.

                        PowerShell and ‘OO’ also don’t have to go hand-in-hand.

                      2. 2

                        PowerShell is an interesting approach. Unfortunately it has one giant mistake that makes me hate using it — the choice of Verb-Noun naming rather than Noun-Verb means I have to use Google to figure out the command I need rather than just hitting tab. (Because I nearly always know the noun already — what I need is the verb.) Unless I’m missing something, which would be great…

                      3. 8

                        what if we could pass more than text - but arbitrary structured, typed data. This is not science-fiction, it’s really simple to implement. We know things about programming that weren’t really known or understood back in the early UNIX times.

                        Wasn’t that done back in UNIX times on Lisp machines? And then, given it’s dynamic, maybe a bit later on Smalltalk systems?

                        If not arbitrary, Flex Machine seems like it fit. That was late 1970’s to 1980’s. Fewer people knew about it, though. There was also people like Hansen doing OS’s in Pascal. A brief skim of Solo paper led me to this statement: “Pascal programs can call one another recursively and pass arbitrary parameters among themselves… Solo is the first major example of a hierarchical concurrent program implemented in terms of abstract data types (classes, monitors and processes) with compile-time control of most access rights.”

                        Clearly, there were already ideas there for people to build on for doing something other than text. They just couldn’t be or weren’t applied. Then, the UNIX authors and others continued building on their ideas with minimal adoption of alternatives. Eventually, Linux ecosystem started adopting pieces of many ideas kind of bolted into and on top of it the existing system. Although it’s a legacy system, a clean-slate project could certainly do things differently. We’re seeing that start to happen with virtual machines and unikernels that reuse hosts’ drivers.

                        1. 3

                          Shells using some kind of messagepack-style interface could be interesting

                          1. 2

                            what if we could pass more than text - but arbitrary structured, typed data. This is not science-fiction, it’s really simple to implement

                            So, a BMessage then? :)

                          2. 3

                            That’s a very nice essay, but—what do you suggest as an alternative?

                            I don’t mean this in a negative way, at all, if you make a new os with a new paradigm that looks cool, I will happily switch to it.

                            1. 2

                              If it were that easy to give a good alternative, I guess we wouldn’t be in the situation about having to think about one.

                              My best guess, and what I would like to urge people to do, is to try and think contrary to established metaphors and designs. I’ve recently been thinking about a system that tries to meld operating system, programming language and compiler more or less in to one component, but it’s too vauge to to put it into words properly. Most alternatives will be failures, but hopefully controlled failures we will be able to learn from.

                              1. 3

                                I’ve recently been thinking about a system that tries to meld operating system, programming language and compiler more or less in to one component

                                Sounds a bit like templeos. See http://www.codersnotes.com/notes/a-constructive-look-at-templeos/

                                1. 2

                                  There’s Synthesis OS, written back in 92 that today would be considered a “just-in-time” operating system. And it could run SunOS binaries faster than SunOS (on the same hardware).

                                  1. 1

                                    some pointers, might be invalid: Pharo, Emacs, Inferno,

                                    1. 1

                                      Urbit has ambitions of melding those things, as well as a universal concept of network identity and ownership thereof.

                                      1. 1

                                        I liked the write-up and the interesting historical tidbits in there.

                                        I strongly agree with thinking contrary to established design - many established patterns might actually have quite low ceilings. Merging the OS, compiler and PL etc. could make sense (that’s what Smalltalk looks like). Much of the tedium and weakness in current systems is at the integration points - perhaps the dividing the ‘whole computing system’ into these specific sub-concepts needs to be rethought?

                                        In a similar vein, see https://eighty-twenty.org/2016/05/05/unix-is-incorrectly-factored and https://programmingmadecomplicated.wordpress.com/2017/08/12/there-is-only-one-os-and-its-been-obsolete-for-decades/

                                    2. 2

                                      I wish we had more non-unix operating systems to play with… From the top of my mind, I remember Windows, FreeDOS, Plan9, Haiku, AROS, MorphOS, AmigaOS, ReactOS. Anyone has other links?

                                      1. 1

                                        The thing is that most of these (I can’t say since I haven’t used all of them) are either directly or at least to a significant degree inspired by Unix. That’s why I focused on Unix, since even though it’s not that commonly used itself (Linux, *BSD, MacOS are more popular) it’s ideas continue to be found everywhere, and are assumed to be the default, proper or real way if there even is any alternative.

                                        1. 1

                                          Haiku is technically a UNIXlike under the hood, yes; but if you used the native APIs for developing GUIs, you wouldn’t really know it for the most part. Some of the items you listed in the post which have solutions that are functionally “nicer” but technically more difficult, Haiku (or BeOS before it) just solved the technical problem in the way of the nicer solution.

                                          For instance, the native email client is “maildir based”, relying on the underlying filesystem’s extended attributes, structured data can be passed between applications arbitrarily via BMessages, and so on.

                                          So while Haiku certainly doesn’t escape the UNIX philosophy (we have mostly full POSIX compatibility, bash is the default shell, etc.) we certainly are not like Linux in terms of “advanced users change things on the command line.” But you can if you still want to. :)

                                      2. 2

                                        There are different ways - it’s just Unix has lodged itself into our heads to the point we can’t think of anything else, and if we do, the first thing to correct that is a POSIX compatibility layer.

                                        1. 7

                                          I doubt it. A more likely explanation, IMO, is that people don’t want to invest (with significant risk of failure) the considerable technical and social resources for garnering adoption for something different.

                                          1. 2

                                            UNIX people can’t. I’m sure you could since you regularly work with a hardware/software architecture that was superior in some ways. ;)

                                          2. 1

                                            I think the constant asides in faded text distract from what is otherwise a very interesting argument. I recommend ditching that technique next time: move every aside into the article. Be confident!