1. 56

    This is why we can’t have good software. This program could literally have been an empty file, a nothing at all, a name capturing the essence perfectly.

    I’m not sure I could disagree more strongly. An empty file only has the true behavior because of a bunch of incredibly non-obvious specific Unix behaviors. It would be equally reasonable for execution of this file to fail (like false) since there’s no hashbang or distinguishable executable format to decide how to handle it. At a somewhat higher level of non-obviousness, it’s really weird that true need be a command at all (and indeed, in almost all shells, it’s nottrue is a builtin nearly everywhere).

    true being implementable in Unix as an empty file isn’t elegant—it’s coincidental and implicit.

    1. 15

      I mean, it’s POSIX specified behavior that any file that is executed that isn’t a loadable binary is passed to /bin/sh (”#!” as the first two bytes results in “implementation-defined” behavior), and it’s POSIX specified behavior that absent anything else, a shell script exits true.

      It’s no more coincidental and implicit than “read(100)” advances the file pointer 100 bytes, or any other piece of standard behavior. Sure, it’s Unix(-like)-specific, but, well, it’s on a Unix(-like) operating system. :)

      1. 25

        It’s precisely specified, yes, but it’s totally coincidental that the specification says what it does. A perfectly-reasonable and nearly-equivalent specification in an alternate universe where Thomson and Ritchie sneezed five seconds earlier while deciding how executables should be handled would have precisely the opposite behavior.

        On the other hand, if read(100) did anything other than read 100 bytes, that would be extremely surprising and would not have come about from an errant sneeze.

        1. 35

          Black Mirror Episode: The year is 2100 and the world is ravaged by global warming. The extra energy aggregated over decades because non executables went through /bin/sh caused the environment to enter the tipping point where the feedback loops turned on. A time machine is invented, where one brave soul goes back in time with a feather, finds Thomson and makes him sneeze, saving humanity from the brink of extinction. But then finds himself going back to 2100 with the world still ravaged. Learns that it was fruitless because of npm and left-pad.

          1. 12

            it’s totally coincidental that the specification says what it does.

            This is true of literally all software specifications, in my experience.

            1. 8

              Surely we can agree that it is far more coincidental that an empty executable returns success immediately than that e.g. read(100) reads 100 bytes?

              1. 7

                Why isn’t 100 an octal (or a hex or binary) constant? Why is it bytes instead of machine words? Why is read bound to a file descriptor instead of having a record size from an ioctl, and then reading in 100 records?

                Just some examples. :)

                1. 5

                  Obviously, minor variations are possible. However, in no reasonable (or even moderately unreasonable) world, would read(100) write 100 bytes.

                  1. 12

                    Pass a mmap’ed pointer to read, and it shall write. :)

            2. 11

              The current (POSIX) specification is the product of historical evolution caused in part by /bin/true itself. You see, in V7 Unix, the kernel did not execute an empty file (or shell scripts); it executed only real binaries. It was up to the shell to run shell scripts, including empty ones. Through a series of generalizations (starting in 4BSD with the introduction of csh), this led to the creation of #! and kernel support for it, and then POSIX requiring that the empty file trick be broadly supported.

              This historical evolution could have gone another way, but the current status is not the way it is because people rolled out of bed one day and made a decision; it is because a series of choices turned out to be useful enough to be widely supported, eventually in POSIX, and some choices to the contrary wound up being discarded.

              (There was a time when kernel support for #! was a dividing line between BSD and System V Unix. The lack of it in the latter meant that, for example, you could not make a shell script be someone’s login shell; it had to be a real executable.)

              1. 9

                The opposite isn’t reasonable though. That would mean every shell script would have to explicitly exit 0 or it will fail.

                Every. Shell. Script.

                And aside from annoying everyone, that wouldn’t even change anything. It would just make the implementation of true be exit 0, instead of the implementation of false be exit 1.

                And read(100) does do something besides read 100 bytes. It reads up to 100 bytes, and isn’t guaranteed to read the full 100 bytes. You must check the return value and use only the amount of bytes read.

                1. 7

                  It’s not obvious to me that an empty file should count as a valid shell script. It makes code generation marginally easier, I suppose. But I also find something intuitive to the idea that a program should be one or more statements/expressions (or functions if you need main), not zero or more.

                  1.  

                    So if you run an empty file with sh, you would prefer it exits failure. And when you run an empty file with python, ruby, perl, et al., also failures?

                    Why should a program have one or more statements / expressions? A function need not have one or more statements / expressions. Isn’t top level code in a script just a de facto main function?

                    It’s intuitive to me that a script, as a sequence of statements to run sequentially, could have zero length. A program with an entry point needs to have at least a main function, which can be empty. But a script is a program where the entry point is the top of the file. It “has a main function” if the file exists.

                    1.  

                      I think whatever the answer is, it makes equal sense for Perl, Python, Ruby, shell, any language that doesn’t require main().

                      In my opinion, your last argument begs the question. If an empty program is considered valid, then existing is equivalent to having an empty main. If not, then it isn’t.

                      In any case, I don’t mean to claim that it’s obvious or I’m certain that an empty program should be an error, just that it seems like a live option.

                    2.  

                      Exactly. It sounds like arbitrary hackery common in UNIX development. Just imagine writing a semi-formal spec that defines a program as “zero characters” which you pass onto peer review. They’d say it was an empty file, not a program.

                      1.  

                        I guess true shouldn’t be considered a program. It is definitely tied to the shell it runs in, as you wouldn’t call execv("true", {"/bin/true", NULL}) to exit a program correctly. for example. true has no use outside of the shell, so it makes sense to have it use the shell’s features. That is why now it tends to be a builtin. But having it a builtin is not specified by POSIX. Executing file on the other end, is, and the spec says the default exit code it 0 or “true”. By executing an empty file, you’re then asking the shell to do nothing, and then return true. So I guess it is perfectly fine for true to jist be an empty file. Now I do agree that such a simple behavior has (loke often with unix) way too many ways to be executed, ans people are gonna fight about it for quite some time! What about these?

                        alias true=(exit)
                        alias true='/bin/sh /dev/null'
                        alias true='sh -c "exit $(expr `false;echo $? - $?`)"'
                        

                        The one true true !

                        1.  

                          It depends upon the system. There is IEFBR14, a program IBM produced to help make files in JCL which is similar to /bin/true. So there could be uses for such a program.

                          It also has the distinction of being a program that was one instruction long and still have a bug in it.

                          1.  

                            “That is why now it tends to be a builtin.”

                            Makes sense. If tied to the shell and unusual, I’d probably put something like this into the interpreter of the shell as an extra condition or for error handling. Part of parsing would identify an empty program. Then, either drop or log it. This is how such things are almost always handled.

                      2. 1

                        That would mean every shell script would have to explicitly exit 0 or it will fail.

                        I don’t see how that follows.

                        Once the file is actually passed to the shell, it is free to interpret it as it wishes. No reasonable shell language would force users to specify successful exit. But what the shell does is not in question here; it’s what the OS does with an empty or unroutable executable, for which I am contending there is not an obvious behavior. (In fact, I think the behavior of running it unconditionally with the shell is counterintuitive.)

                        And read(100) does do something besides read 100 bytes.

                        You’re being pedantic. Obviously, under some circumstances it will set error codes, as well. It very clearly reads some amount of data, subject to the limitations and exceptions of the system; zero knowledge of Unix is required to intuit that behavior.

                        1. 7

                          I don’t see how that follows.

                          You claim the exact opposite behavior would have been equally reasonable. That is, the opposite of an empty shell script exiting true. The precise opposite would be an empty shell script—i.e. a script without an explicit exit—exiting false. This would affect all shell scripts.

                          Unless you meant the opposite of executing a file not loadable as an executable binary by passing it to /bin/sh, in which case I really would like to know what the “precise opposite” of passing a file to /bin/sh would be.

                          You’re being pedantic. Obviously, under some circumstances it will set error codes, as well. It very clearly reads some amount of data, subject to the limitations and exceptions of the system; zero knowledge of Unix is required to intuit that behavior.

                          No. Many people assume read will fill the buffer size they provide unless they are reading the trailing bytes of the file. However, read is allowed to return any number of bytes within the buffer size at any time.

                          It also has multiple result codes that are not errors. Many people assume when read returns -1 that means error. Did you omit that detail for brevity, or was it not obvious to you?

                          1. 6

                            If a file is marked executable, I think it’s quite intuitive that the system attempt to execute. If it’s not a native executable, the next obvious alternative would be to interpret it, using the default system interpreter.

                        2. 3

                          Saying the behavior is totally (or even partially) coincidental is a bit strong. You’re ignoring the fundamental design constraints around shell language and giving the original designers more credit than they deserve.

                          Consider this experiment: you pick 100 random people (who have no previous experience to computer languages) and ask them to design a shell language for POSIX. How would all of these languages compare?

                          If the design constraints I’m talking about didn’t exist, then it would indeed be random and one would expect only ~50% of the experimental shell languages to have a zero exit status for an empty program.

                          I strongly doubt that is what you would see. I think you would see the vast majority of those languages specifying that an empty program have zero exit status. In that case, it can’t be random and there must something intentional or fundamental driving that decision.

                          1. 7

                            I don’t care about how the shell handles an empty file. (Returning successful in that case is basically reasonable, but not in my opinion altogether obvious.) I’m stating that the operating system handling empty executables by passing them to the shell is essentially arbitrary.

                            1. 4

                              The reason for the existence of human intelligence isn’t obvious either but that doesn’t make it random. A hostile environment naturally provides a strong incentive for an organism to evolve intelligence.

                              As far as the operating system executing non-binaries with “/bin/sh” being arbitrary, fair enough. Though I would argue that once the concepts of the shebang line and an interpreter exist, it’s not far off to imagine the concept of a “default interpreter.” Do you think the concept of a default is arbitrary?

                          2. 1

                            It’s precisely specified, yes, but it’s totally coincidental that the specification says what it does.

                            laughs That’s really taking an axe to the sum basis of knowledge, isn’t it?

                        3. 2

                          yes an empty file signifying true violates the principle of least astonishment.However if there were a way to have metadata comments about the file describing what it does, how it works, and what version it is without having any of that in the file we’d have the best of both worlds.

                          1. 2

                            true being implementable in Unix as an empty file isn’t elegant—it’s coincidental and implicit.

                            But isn’t this in some sense exactly living up to the “unix philosophy”?

                            1. 3

                              No.

                            2. 0

                              To me, the issue is whether it is prone to error. If it is not, it is culture building because it is part of the lore.

                            1. 4

                              Are you sure you can trust an old Usenet post regarding the legal status of the book? I looked around, and couldn’t really find anything, while on the other hand, it doesn’t seem to be an unknown, uncited relic either, and usually if it were freely available, some archivist somewhere would have made sure that it could be found. But that’s all guessing.

                              1. 17
                                1. 8

                                  And despite all of this, most shells have true and false as built-in commands anyway…

                                  $ type true
                                  true is a shell builtin
                                  

                                  which, imo, gives another twist to the whole debate, since useless changes are made to a “useless” (since to my knowledge the binary itself isn’t used) program. The most it can offer us, is a self-reflective lesson in the Unix ideals and their betrayals.

                                  1. 4

                                    Shell builtins aren’t used for exec calls and their ilk, no? So if you want to use false as the login shell for a an account, you’d need the “real” /bin/false?

                                    1. 1

                                      Fair enough, that’s true (pardon the pun). I was only thinking about a shell scripting environment.

                                      On the other hand, who knows how long it will take until systemd or some other do it all system totally takes over account management, making false and true superfluous in that department too.

                                    2. 3

                                      They’re built-ins on most fully featured interactive shells (bash, zsh, etc.), but on many systems the default shell-script interpreter /bin/sh is a more minimalist shell where they aren’t built-ins. That’s the case on at least Debian (dash) and FreeBSD (ash). So the default for shell scripts on such systems is that true actually does run /bin/true.

                                      1. 1

                                        The dash on my system (void, and another one running ubuntu and a server running debian(!)) claims that true was a built in command. Before writing my comment, I checked bash, where I already knew it was true, ksh on an OpenBSD system and dash on my laptop. Even the shell on my android phone (I belive the default one in /system/bin/sh) has the two program as built in components.

                                        I haven’t tried ash, but it seems to me that it’s becoming ever rarer, even if a more minimalist shell might theoretically use the binaries directly.

                                        1. 3

                                          Oops, my mistake, sorry. I had checked before posting that comment, but checked incorrectly. I did this (starting in a zsh shell):

                                          mjn@mjn:~% which true
                                          true: shell built-in command
                                          mjn@mjn:~% ls -l /bin/sh
                                          lrwxrwxrwx 1 root root 4 Jun 28  2017 /bin/sh -> dash
                                          mjn@mjn:~% sh
                                          $ which true
                                          /bin/true
                                          

                                          But I didn’t realize that the difference here is due to which, rather than true, going from builtin in zsh to not builtin in dash. Seems that making which a builtin is zsh-specific behavior, and the POSIX way to get info on how a command will be executed is command -V.

                                  1. 11

                                    Awk and the various members of the Unix shell family?

                                    1. 6

                                      Yup, I’ve looked at at 5-10 shell implementations, and all of them are essentially AST interpreters + on-the-fly parsing/evaluating.

                                      Just like Ruby was an AST interpreter that recently became a bytecode interpeter, R made the same jump recently:

                                      A byte code compiler for R

                                      https://scholar.google.com/scholar?cluster=1975856130321003102&hl=en&as_sdt=0,5&sciodt=0,5

                                      1. 1

                                        Do you happen to know how recently they’ve switched? (And an example of a large project written purely (or almost purely) in that language?) Thanks.

                                        1. 5

                                          Ruby switched in 2007, i used it for a few years before that and the speedups were quite dramatic. See https://en.wikipedia.org/wiki/YARV for a bit more info.

                                          1. 1

                                            Cool! That links to some benchmarks which saves me from trying to do them.

                                            Looks like its only about 4x on average which is hopeful (for having no bytecode).

                                          2. 3

                                            It looks like it’s around R release 2.13 and 2.14, which was around 2011. R is from the early/mid 90’s, similar to Ruby, and I think they both switched to bytecode compilers at around the same time.

                                            https://csgillespie.github.io/efficientR/7-4-the-byte-compiler.html

                                            https://cran.r-project.org/src/base/R-2/

                                            R is for data analysis, so it’s hard to say what a “large project” is. It’s also a wrapper around Fortran numeric libraries in the same way Python is a wrapper around C (or NumPy is a wrapper around Fortran.)

                                            There are thousands of libraries written in R:

                                            https://cran.r-project.org/web/packages/available_packages_by_date.html

                                            1. 1

                                              Thanks! This actually looks like a pretty good example. That website even lists package dependencies so I can try to find a long chain of pre-2011 dependencies.

                                        2. 4

                                          Unix shell, for sure. GNU awk and mawk compile to bytecode. Not sure about nawk, though the regexp implementation in nawk uses bytecode.

                                          1. 2

                                            GNU awk and mawk compile to bytecode

                                            Really? That seems wierd, since gawk is both slower than nawk and mawk. Or is it because of the features the GNU project added, that it’s overall slower?

                                            1. 6

                                              One big difference is that gawk operates on sequences of Unicode characters, while mawk and nawk operate on sequences of bytes. If your text is all ASCII, setting your locale to ‘C’ will cause gawk to also operate on bytes, which should close at least some of the performance gap. But gawk’s Unicode support can be nice if you have UTF-8. mawk and nawk will often still produce the right result on UTF-8 input, especially when non-ASCII characters are only passed through unmodified. But sometimes you get:

                                              $ echo $LANG
                                              en_GB.UTF-8
                                              $ echo "ÜNICÖDE" | gawk '{print tolower($0)}'
                                              ünicöde
                                              $ echo "ÜNICÖDE" | nawk '{print tolower($0)}'
                                              �nic�de
                                              $ echo "ÜNICÖDE" | mawk '{print tolower($0)}'
                                              �nic�de
                                              
                                          2. 1

                                            Thanks for the example. I don’t know how they work internally. Although to me, they are in the write-more-primitives-in-a-faster-language category. The primitives being the external commands called (maybe awk a bit less?).

                                            Are there examples of multi-layered library (or use) for awk and shell?

                                            Edit: typo

                                            1. 2

                                              What does “multi-layered push” mean?

                                              As for awk, when I use it, I never shell out. If I need to shell out from awk, I just write the whole thing in Go or something. So I just use the primitives exposed by awk. Though, before Go, I shelled out of awk more often.

                                              1. 1

                                                multi-layered push

                                                Oops, that’s the wrong words. That’s what I get for alt-tabbing between the comment window and a shell.

                                                I mean something like calling a library which calls another library which calls another library, with all intermediate libraries written in awk (or shell). (Or the same thing with functions if there are layers one on top of each other. By this I mean functions in one layer treats functions in the previous layer as primitives).

                                                As for awk, when I use it, I never shell out.

                                                That would be a good example then if you also have at least two layers of functions (although more would be nice).

                                          1. 12

                                            The Go project is absolutely fascinating to me.

                                            How they managed to not solve many hard problems of a language, it’s tooling or production workflow, but also solve a set to get a huge amount of developer mindshare is something I think we should get historians to look into.

                                            I used Go professionally for ~2+ years, and so much of it was frustrating to me, but large swaths of our team found it largely pleasant.

                                            1. 12

                                              I’d guess there is a factor depending on what you want from a language. Sure, it doesn’t have generics and it’s versioning system leaves a lot to be wished for. But personally, if I have to write anything with networking and concurrency, usualy my first choice is Go, because of it’s very nice standard library and a certain sense of being thought-thorugh when it comes to concurrency/parallelism - at least so it appears to be when comparing it to other imperative Java, C or Python. Another popular point is how the language, as compared to C-ish languages doesn’t give you too much freedom when it comes to formatting – there isn’t a constant drive to use as few characters as possible (something I’m very prone to doing), or any debates like tabs vs. spaces, where to place the opening braces, etc. There’s really something reliving about this to me, that makes the language, as you put it, “pleasant” to use (even if you might not agree with it)

                                              And regarding the standard library, one thing I always find interesting is how far you can get by just using what’s already packaged in Go itself. Now I haven’t really worked on anything with more that 1500+ LOC (which really isn’t much for Go), and most of the external packages I used were for the sake of convince. Maybe this totally changes when you work in big teams or on big projects, but it is something I could understand people liking. Especially considered that the Go team has this Go 1.x compatibility promise, so that you don’t have to worry that much about versioning when it comes to the standard lib packages.

                                              I guess the worst mistake one can make is wanting to treat it like Haskell or Python, forcing a different padigram onto it. Just like one might miss macros when one changes from C to Java, or currying when one switches from Haskell to Python, but learns to accept these things, and think differently, so I belive, one should approach Go, using it’s strengths, which it has, instead of lamenting it’s weaknesses (which undoubtedly exist too).

                                              1. 7

                                                I think their driving philosophy is that if you’re uncertain of something, always make the simpler choice. You sometimes go to wrong paths following this, but I’d say that in general this is a winning strategy. Complexity can always be bolted on later, but removing it is much more difficult.

                                                The whole IT industry would be a happier place if it followed this, but seems to me that we usually do the exact opposite.

                                                1. 1

                                                  I think their driving philosophy is that if you’re uncertain of something, always make the simpler choice.

                                                  Nah - versioning & dependency management is not some new thing they couldn’t possibly understand until they waited 8 years. Same with generics.

                                                  Where generics I can understand a complexity argument for sure, versioning and dependency management are complexities everyone needed to deal with either way.

                                                  1. 3

                                                    If you understand the complexity argument for generics, then I think you could accept it for dependency management too. For example, Python, Ruby and JavaScript have a chaotic history in terms of the solution they adopted for dependency management, and even nowadays, the ecosystem it not fully stabilized. For example, in the JavaScript community, Facebook released yarn in October 2016, because the existing tooling was not adequate, and more and more developers are adopting it since then. I would not say that dependency management is a fully solved problem.

                                                    1. 1

                                                      I would not say that dependency management is a fully solved problem.

                                                      Yes it is, the answer is pinning all dependencies, including transitive dependencies. All this other stuff is just heuristics that end up failing later on and people end up pinning anyways.

                                                      1. 1

                                                        I agree about pinning. By the way, this is what vgo does. But what about the resolution algorithm used to add/upgrade/downgrade dependencies? Pinning doesn’t help with this. This is what makes Minimal Version Selection, the strategy adopted by vgo, original and interesting.

                                                        1. 1

                                                          I’m not sure I understand what the selection algorithm is doing then. From my experience: you change the pin, run your tests, if it passes, you’re good, if not, you fix code or decide not to change the version. What is MVS doing for this process?

                                                          1. 1

                                                            When you upgrade a dependency that has transitive dependencies, then changing the pin of the upgraded dependency is not enough. Quite often, you also have to update the pin of the transitive dependencies, which can have an impact on the whole program. When your project is large, it can be difficult to do manually. The Minimal Version Selection algorithm offers a new solution to this problem. The algorithm selects the oldest allowed version, which eliminates the redundancy of having two different files (manifest and lock) that both specify which modules versions to use.

                                                            1. 1

                                                              Unless it wasn’t clear in my original comment, when I say pin dependencies I am referring to pinning all dependencies, including transitive dependencies. So is MVS applied during build or is it a curation tool to help discover the correct pin?

                                                              1. 1

                                                                I’m not sure I understand your question. MVS is an algorithm that selects a version for each dependency in a project, according to a given set of constraints. The vgo tool runs the MVS algorithm before a build, when a dependency has been added/upgraded/downgraded/removed. If you have the time, I suggest you read Russ Cox article because it’s difficult to summarize in a comment ;-)

                                                                1. 1

                                                                  I am saying that with pinned dependencies, no algorithm is needed during build time, as there is nothing to compute for every dependency version is known apriori.

                                                                  1. 1

                                                                    I agree with this.

                                                2. 4

                                                  I had a similar experience with Elm. In my case, it seemed like some people weren’t in the habit of questioning the language or thinking critically about their experience. For example, debugging in Elm is very limited. Some people I worked with came to like the language less for this reason. Others simply discounted their need for better debugging. I guess this made the reality easier to accept. It seemed easiest for people whose identities were tied to the language, who identified as elm programmers or elm community members. Denying personal needs was an act of loyalty.

                                                  1. 2

                                                    How they managed to not solve many hard problems of a language, it’s tooling or production workflow, but also solve a set to get a huge amount of developer mindshare is something I think we should get historians to look into.

                                                    I think you’ll find they already have!

                                                  1. 8

                                                    It’s a super easy mistake to make! They’re so tiny, and hard to find! One day we’ll have a service where you can just type “how many legs do lobsters have” without personally going to Maine and renting a boat and lobster traps to find out.

                                                    1. 7

                                                      The wikipedia article is fascinating:

                                                      Lobsters live up to an estimated 45 to 50 years in the wild, although determining age is difficult.

                                                      Research suggests that lobsters may not slow down, weaken or lose fertility with age, and that older lobsters may be more fertile than younger lobsters. This longevity may be due to telomerase

                                                      Lobster longevity is limited by their size. Moulting requires metabolic energy and the larger the lobster, the more energy is needed; 10 to 15% of lobsters die of exhaustion during moulting, while in older lobsters, moulting ceases and the exoskeleton degrades or collapses entirely leading to death

                                                      1. 5

                                                        I wonder what would happen if the exoskeleton was artificially reinforced in an old lobster. Would it live a lot longer?

                                                        1. 1

                                                          Isn’t there a similar story with squids, that they grow as long as they have the resources to do so?

                                                      1. 2
                                                        Why?

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

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

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

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

                                                        1. 7

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

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

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

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

                                                            1. 4

                                                              How often does one reverse their last jump?

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

                                                              Some other Vim features I find useful for prose:

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

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

                                                            2. 7

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

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

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

                                                            1. 32

                                                              I don’t see why this progress bar should be obnoxiously put at the top of the page. It’s cool if you wanna do a donation drive but don’t push it in the face of everybody who comes here. Honestly at first I thought this was a bar for site expense. Then I realised it’s to ‘adopt’ an emoji.

                                                              1. 7

                                                                Lobsters isn’t a daily visit for most readers, probably even for most users. They can’t see it to join in if there isn’t anything visible for it, and it has an id for adblocking if you prefer not to see it.

                                                                1. 22

                                                                  Personally a check this site quite regularly on my mobile device… which doesn’t have an ad-blocker.

                                                                  1. 13

                                                                    That sounds awful. If you’re an android user, normal uBlock Origin works on Firefox for Android just like it does on desktop. :)

                                                                    1. 3

                                                                      Or use Block This!, which blocks ads in all apps.

                                                                      1. 3

                                                                        Oh, that’s a cool little tool. Using a local VPN to intercept DNS is a neat trick. Unfortunately doesn’t help with in this case because it blocks requests to domains and not elements on a page via CSS selectors.

                                                                        That does make me want to actually figure out my VPN to home for my phone and setup a pi-hole, though.

                                                                      2. 2

                                                                        Ohh! Good to know, thanks.

                                                                      3. 2

                                                                        Firefox 57+ has integrated adblocker nowadays, on both desktop and mobile; plus, there’s also Brave.

                                                                      4. 27

                                                                        That is still annoying that I need to setup my adblocker to fix lobste.rs. So much for all the rant articles about bad UX/UI in here.

                                                                        1. 11

                                                                          maybe one could just add a dismiss button or sometimes like that? I don’t find it that annoying, but I guess it would be a pretty simple solution.

                                                                          1. 1

                                                                            I concur, either a client side cookie or session variable.

                                                                            1. 1

                                                                              Well, yeah… that’s how you could implement it, and I guess that would be the cleanest and simplest way?

                                                                          2. 2

                                                                            It’d be great to see data about that! Personally I visit daily or at least 3 times a week. Lack of clutter and noise is one of the biggest advantages of Lobsters. And specifically, I looked at the link, and I have no idea who this Unicode organization is, or their charitable performance, or even if they need the money. I’d imagine they are mostly funded by the rich tech megacorps?

                                                                            1. 1

                                                                              [citation needed] ;-)

                                                                            2. 3

                                                                              Adopting an emoji isn’t the end goal: the money goes to Unicode, which is a non-profit organization that’s very important to the Internet.

                                                                              1. 5

                                                                                If this bar actually significantly annoys you, I’m surprised you haven’t literally died from browsing the rest of the internet.

                                                                              1. 8

                                                                                Regarding Table of Contents generation, what do you think about hxtoc(1) which is part of the HTML/XML utilities by the w3c?

                                                                                Also, I’ve made a similar experience regarding a joyful discovery of CommonMark recently, but instead of using the parser you mention, I’ve taken up lowdown as my client of choice. I guess this is something it has in common with most C implementations of markdown, but especially when compared to pandoc, it was fast. It took me a fraction on a second to generate a website, instead of a dozen or more. So I guess, I wanted to see, what other clients you’ve looked into, for example discount, as an example of an another popular implementation.

                                                                                1. 5

                                                                                  Hm, I’ve actually never heard of hxtoc, lowdown, or discount!

                                                                                  I haven’t been using Markdown regularly for very long. I started it using more when I started the Oil blog in late 2016. Before that, I wrote a few longer documents in plain HTML, and some in Markdown.

                                                                                  I had heard of pandoc, but never used it. I guess cmark was a natural fit for me because I was using markdown.pl in a bunch of shell scripts. So cmark pretty much drops right in. I know a lot of people use framework-ish static site generators, which include markdown. But I really only need markdown, since all the other functionality on my site is written with custom scripts.

                                                                                  So I didn’t really do much research! I just felt that markdown.pl was “old and smelly” and I didn’t want to be a hypocrite :-) A pile of shell scripts is pretty unhygienic and potentially buggy, but that is what I aim to fix with Oil :)

                                                                                  That said, a lot of the tools you mention do look like the follow the Unix philosophy, which is nice. I would like to hear more about those types of tools, so feel free to post them to lobste.rs :) Maybe I don’t hear about them because I’m not a BSD user?

                                                                                  1. 4

                                                                                    I had heard of pandoc, but never used it.

                                                                                    It’s a nice tool, and not only for working with Markdown, but tons of other formats too. But Markdown is kind of it’s focus… If you look at it’s manual, you’ll find that it can be very finely tuned to match ones preferences (such as enabling or disabling raw HTML, syntax highlighting, math support, BibLaTeX citations, special list and table formats, etc.). It even has output options that make it resemble other implementations like PHP Markdown Extra, GitHub-Flavored Markdown, MultiMarkdown and also markdown.pl! Furthermore, it’s written by John MacFarlane, who is one of the guys behind CommonMark itself. In fact if you look at the cmark contributers, he seems to be the most active maintainer.

                                                                                    I usually use pandoc to generate .epub files or to quickly generate a PDF document (version 2.0 supports multiple backends, besides LaTeX, such as troff/pdfroff and a few html2pdf engines). But as I’ve mentioned, it’s a bit slow, so I tend to not use it for simpler texts, like when I have to generate a static website.

                                                                                    I know a lot of people use framework-ish static site generators, which include markdown.

                                                                                    Yeah, pesonally I use zodiac which uses AWK and a few shell script wrappers. You get to choose the converter, which pipes some format it, and HTML out. It’s not ideal, but other than writing my own framework, it’s quite ok.

                                                                                    Maybe I don’t hear about them because I’m not a BSD user?

                                                                                    Nor am I, at least not most of the time. I learned about those HTML/XML utilities because someone mentioned them here on lobste.rs, and I was supprised to see how powerful they are, but just how seemingly nobody knows about them. hxselect to query specific elements in a CSS-fashion, hxclean as an automatic HTML corrector, hxpipe/hxunpipe converts (and reconverts) HTML/XML to a format that can be more easily parsed by AWK/perl scripts – certainly not useless or niche tools.

                                                                                    But I do have to admit that a BSD user influenced me on adopting lowdown, and since it fits my use-case, I stick by it. Nevertheless, I might take a look at cmark, since it seems interesting.

                                                                                  2. 2

                                                                                    Unfortunately, it looks like lowdown is a fork of hoedown which is a fork of sundown which was originally based on the markdown.pl implementation (with some optional extensions), and is most likely not CommonMark compliant. Pandoc is nice because it can convert between different formats, but it also has quite a few inconsistencies.

                                                                                    One of the biggest reasons I like CommonMark is because it aims to be an extremely solid, consistent standard that makes markdown more sane. It would be nice to see more websites move towards CommonMark, but that’s probably a long shot.

                                                                                    Definitely check out babelmark if you get a chance which lets you test different markdown inputs against a bunch of different parsers. There are a bunch of example divergences on the babelmark FAQ. The sheer variety of outputs for some simple inputs is precisely why CommonMark is useful as a standard.

                                                                                    1. 3

                                                                                      Lowdown isn’t CommonMark conformant, although it has some bits in place. The spec for CommonMark is huge.

                                                                                      If you’re a C hacker, it’s easy to dig into the source to add conformancy bit by bit. See the parser in document.c and look for LOWDOWN_COMMONMARK to see where bits are already in place. The original sundown/hoedown parser has been considerably simplified in lowdown, so it’s much easier to get involved. I’d be thrilled to have somebody contribute more there!

                                                                                      In the immediate future, my biggest interest is in going an LCS implementation into the lowdown-diff algorithm. Right now it’s pretty ad hoc.

                                                                                      (Edit: I’m the author of lowdown.)

                                                                                      1. 2

                                                                                        One of the biggest reasons I like CommonMark is because it aims to be an extremely solid, consistent standard that makes markdown more sane. It would be nice to see more websites move towards CommonMark, but that’s probably a long shot.

                                                                                        I guess I can agree with you when it comes to websites like Stackoverflow, Github and Lobsters having Markdown formatting for comments and other text inputs, but I really don’t see the priority when it comes to using a not 100% CommonMark compliant tool for your own static blog generator. I mean, it’s nice, no doubt, as long as you don’t intentionally use uncertain constructs and don’t over-format your texts to make them more complicated than they have to be, I guess that most markdown implementations are find in this regard – speed on the other hand, is a different question.

                                                                                        1. 1

                                                                                          Are you saying that CommonMark should be used for comments on websites, but not for your own blog?

                                                                                          I would say the opposite. For short comments, the ambiguity in Markdown doesn’t seem to be a huge problem, and I am somewhat comfortable with just editing “until it works”. I don’t use very many constructs anyway – links, bold, bullet points, code, and block code are about it.

                                                                                          But blogs are longer documents, and I think they have more lasting value than most Reddit comments. So although it probably wasn’t strictly necessary to switch to cmark, I like having my blog in a format with multiple implementations and a spec.

                                                                                          1. 3

                                                                                            At least in my opinion, its useful everywhere, but more so for comments, because it removes differences in implementations. Often times the people using a static site generator are developers and can at least understand differences between implementations.

                                                                                            That being said, I lost count of how many bugs at Bitbucket were filed against the markdown parser because the library used resolves differences by following what markdown.pl does. I still remember differences in bbcode parsing between different forums - moving to a better standard format like markdown has been a step in the right direction… I think CommonMark is the next step in the right direction.

                                                                                            1. 1

                                                                                              The point has already been brought up, but I just want to stress it again. You will probably have a feeling for how your markup parser works anyway, and you will write according. If your parser is commonmark compliant, that’s nice, but really isn’t the crucial point.

                                                                                              On the other hand, especially if one likes to write longer comments, and uses a bit more than the basic markdown constructs on websites, having a standar to rely on does seem to me to offer an advantage, since you don’t necessary know what parser is running in the background. And if you don’t really use markdown, it doesn’t harm you after all.

                                                                                      1. -7

                                                                                        “CommonMark compliant” … lol yeah, forget it.

                                                                                        it’s a fake “standard.” They didn’t think of Markdown, invent it, or do anything to help it’s advance.

                                                                                        No one needs to “comply” with “CommonMark. The CommonMark project has been trying to take ownership of Markdown for years. It’s ridiculous and annoying.

                                                                                        1. 8

                                                                                          They didn’t think of Markdown, invent it, or do anything to help it’s advance.

                                                                                          You say “it”, when one of the reasons CommonMark exists, is that there is no single “it”, there are divergent implementations/extensions. The original implementation is not a specification, and it ‘has bugs’/is ambiguous.

                                                                                          I am not too well-informed; who is better suited to “do anything to help it’s advance”? And what did CM do wrong?

                                                                                          1. 5

                                                                                            I presume what leeflannery is referring to is that John Gruber is BDFL of Markdown and the only authority. Only he’s more like the Absent Dictator for Life, which resulted in a proliferation of implementations that sometimes conflicted with each other and Markdown and led Jeff Atwood (of StackOverflow) to establish CM.

                                                                                            Atwood’s story is here - https://blog.codinghorror.com/standard-markdown-is-now-common-markdown/

                                                                                            And here’s the Github issue with some more detail - https://github.com/commonmark/CommonMark/issues/19

                                                                                          2. 6

                                                                                            it’s a fake “standard.” They didn’t think of Markdown, invent it, or do anything to help it’s advance.

                                                                                            Every standard is fake, if you want to be pedantic about it. No C compiler has to comply with the ANSI standard, no web server has to implement the HTTP spec. Nor are these standards set in stone (good ones at least), and they develop with trends, new needs and realization of previous shortcomings.

                                                                                            What the CommonMark project want to achieve isn’t to make up some unrelated markup language, or to feel special for themselves, but “propose a standard, unambiguous syntax specification for Markdown, along with a suite of comprehensive tests to validate Markdown implementations”. And as I’ve already mention in this thread, these people aren’t nobodies, but instead it was initiated by some of the more major figures in the “markdown scene”. Sure, they don’t “own” markdown (whatever that is supposed to mean), but they are proposing a common ground to strongly define the syntax and the semantics of a markdown parser, having have already published revisions, updating their specification.

                                                                                            If it’s a good standard, people will adopt it when doing something related to markdown, otherwise they won’t. This doesn’t look like something “stupid”, if you were to ask me, but rather an incentive to create a well defined, common sensical, sane specification, to improve the current state of markdown – and if one doesn’t like it, there’s absolutely no need to worry about it or pay any attention whatsoever to the project.

                                                                                          1. 2

                                                                                            isn’t that what meta is for?

                                                                                            1. 1

                                                                                              There is meta, but I want to read other meta posts, so meta is not good for me.

                                                                                            1. 2

                                                                                              It sounds like this page misuses the “straw man” -term.

                                                                                              To “attack a straw man” is to refute an argument that was not made by anyone.

                                                                                              There are people who have used these arguments, and they’re only strawmen in the sense that they have been disassociated from the people who made the arguments.

                                                                                              1. 5

                                                                                                To “attack a straw man” is to refute an argument that was not made by anyone.

                                                                                                While this might be a definition, it’s most certainly not the only one peope think of when talking about “straw man” or “straw person” arguments. Another usage I have hear people use, and what I understand this page to imply, is to simplify or stupidify an opponents position, and then attack this easily attackable argument, thereby avoiding the actual issue. I belive that this is being done here, they take points raised against Lisp and lisp like languages, and show that these either miss the point or don’t really make sense anyways.

                                                                                                But regardlessly, if it’s a “misuse” of the term or not, I belive everyone on this site is bright enoug to understand what is intended, regardless of this or that proposed formal definition, as well as being able to enjoy an article in it’s own merit, instead of an abstract notion of total semantical correctness in regards to each term, especially when it’s not crucial to the intend of the piece.

                                                                                              1. 2

                                                                                                Wouldn’t parMap :: Strategy b -> (a -> b) -> [a] -> [b] be better fit for this example, instead of using the infix notation?

                                                                                                On a related note: Is it true that future versions of GHC want to make maps and related functions parallel by default? I remember reading about it maybe 1 1/2 years ago, but I don’t think it was an authoritative source?

                                                                                                1. 2

                                                                                                  parMap would achieve the same thing and is probably more idiomatic. I suppose I went with the more verbose version because I wanted to show how the primitives compose into something larger.

                                                                                                  The idea of automatic parallelization is interesting. My initial reaction is that just parallelizing everything would probably slow things down due to overhead (starting a spark is cheap but not free). Perhaps you could come up with some heuristics that would work well though.

                                                                                                  1. 1

                                                                                                    Are you sure you’re not thinking of data parallel haskell? I don’t see that mentioned in the linked page.

                                                                                                    https://wiki.haskell.org/GHC/Data_Parallel_Haskell

                                                                                                    Which is mostly abandoned now.

                                                                                                  1. 1

                                                                                                    Interesting project, but I have a question regarding:

                                                                                                    Python is Lisp with syntactic sugar and Lisp is Forth with syntactic sugar.

                                                                                                    Could you elaborate further on this point? I’m guessing it’s not to be taken literally, but although I have heard of the connections between Python and Lisp (map, fliter, lambda, …) I haven’t heard about the second connection. Wasn’t FORTH invented in the 1970’s and LISP in the 1950’s? I’m guessing the order of appearance isn’t strictly necessary, but you don’t often hear about newer programming languages making older ones more “difficult”.

                                                                                                    1. 3

                                                                                                      I’m guessing it’s not to be taken literally, but although I have heard of the connections between Python and Lisp (map, fliter, lambda, …) I haven’t heard about the second connection. Wasn’t FORTH invented in the 1970’s and LISP in the 1950’s?

                                                                                                      I think the idea is that Lisp is a delimited, prefix language (e.g. (foo (bar baz) quux)) while Forth is an undelimited, postfix language (e.g. quux @ baz @ bar foo, where baz & quux are words which put an address on the stack, bar is a word which pops a value from the stack and pushes a value on the stack & foo is a word which pops two values from the stack and does something).

                                                                                                      You can imagine that one could work up to a Lisp from something like OPAREN quux OPAREN baz bar CPAREN foo CPAREN in Forth, where OPAREN & CPAREN are special Forth words which do the obvious thing.

                                                                                                      1. 3

                                                                                                        Its nothing so profound. Just a remark about syntax. Its almost as bargap explained. To go from Lisp to Forth

                                                                                                        (foo (bar baz) quux)
                                                                                                        

                                                                                                        Put the function at the end of the list instead of the beginning so (func arg1 arg2 arg3) becomes (arg1 arg2 arg3 func).

                                                                                                        ((baz bar) quux foo) 
                                                                                                        

                                                                                                        And remove the parenthesis

                                                                                                        baz bar quux foo
                                                                                                        

                                                                                                        This should produce the same output when run in Forth. (Assuming constants are functions with no parameters and return the constant. And adjust for autoquoting and implicit returns.)

                                                                                                        The same goes for the Python to Lisp transfomration. Replace all syntax with calls to their dunder equivalent, put the functions inside the parenthesis and remove the comma separators (func(arg1, arg2, arg3) becomes (func args1 arg2 arg3)) and turn indented blocks into quotes (and put them as the last argument of the block heading).

                                                                                                        1. 2

                                                                                                          I still don’t see the link they’re trying to make with lisp and forth, especially considering their lisp example looks and seems nothing like lisp…

                                                                                                          consider their example

                                                                                                          bind("fib" fun([i]
                                                                                                                         [if(<(i 3) [return(1)])
                                                                                                                          return(+(fib(-(i 1)) fib(-(i 2))))]))
                                                                                                          

                                                                                                          against common lisp

                                                                                                          (defun fib (i)
                                                                                                           (if (< i 3)
                                                                                                            1
                                                                                                            (+ (fib (- i 1)) (fib (- i 2)))))
                                                                                                          
                                                                                                          1. 2

                                                                                                            To do the reverse transformation:

                                                                                                            (defun fib (i)
                                                                                                              (if (< i 3)
                                                                                                               1
                                                                                                               (+ (fib (- i 1)) (fib (- i 2)))))
                                                                                                            

                                                                                                            Put function names in front of the parenthesis.

                                                                                                            defun(fib (i)
                                                                                                             if(<(i 3)
                                                                                                                1
                                                                                                                +(fib(-(i 1)) fib(-(i 2)))))
                                                                                                            

                                                                                                            Add explicit returns.

                                                                                                            defun(fib (i)
                                                                                                             if(<(i 3)
                                                                                                                return(1)
                                                                                                                return(+(fib(-(i 1)) fib(-(i 2))))))
                                                                                                            

                                                                                                            Put square bracket for quotes to distinguish them from calls.

                                                                                                            defun(fib [i]
                                                                                                              if(<(i 3) return(1)
                                                                                                                 return(+(fib(-(i 1)) fib(-(i 2))))))
                                                                                                            

                                                                                                            Change which arguments need to be quoted and which ones don’t.

                                                                                                            defun("fib" [i]
                                                                                                              [if(<(i 3) [return(1)]
                                                                                                                  return(+(fib(-(i 1)) fib(-(i 2))))]))
                                                                                                            

                                                                                                            (Some of these transformations I’ve seen on discussions on possibilities for Lisp syntax.)

                                                                                                        1. 4

                                                                                                          As usual, David apparently fails or refuses to understand how and why PoW is useful and must attack it at every opportunity (using his favorite rhetorical technique of linking negatively connoted phrases to vaguely relevant websites).

                                                                                                          That said, the article reminds me of a fun story - I went to a talk from a blockchain lead at <big bank> a while back and she related that a primary component of her job was assuring executives that, in fact, they did not need a blockchain for <random task>. This had become such a regular occurrence that she had attached this image to her desk.

                                                                                                          1. 10

                                                                                                            What would you consider a useful situation for PoW? In the sense that no other alternative could make up for the advantages in some real life use-case?

                                                                                                            But otherwise, and maybe it’s just me, since I agree wuth his premise, but I see @David_Gerard as taking the opposite role of popular blockchain (over-)advocates, who claim that the technology is the holy grail for far too many problems. Even if one doesn’t agree with his conclusions, I enjoy reading his articles, and find them very informative, since he doesn’t just oppose blockchains from a opinion-based position, but he also seems to have the credentials to do so.

                                                                                                            1. 1

                                                                                                              Relying to @gerikson as well. I personally believe that decentralization and cryptographically anchored trust are extremely important (what David dismissively refers to as “conspiracy theory economics”). We know of two ways to achieve this: proof of work, and proof of stake. Proof of stake is interesting but has some issues and trade-offs. If you don’t believe that PoW mining is some sort of anti-environmental evil (I don’t) it seems to generally offer better properties than PoS (like superior surprise-fork resistance).

                                                                                                              1. 13

                                                                                                                I personally believe that decentralization and cryptographically anchored trust are extremely important

                                                                                                                I personally also prefer decentralised or federalised systems, when they have a practical advantage over a centralized alternative. But I don’t see this to be the case with most application of the blockchain. Bitcoin, as a prime example, to my knowledge is too slow, too inconvenient, too unstable and too resource hungry to have a practical application, as a real substitute for money, either digital or virtual. One doesn’t have the time to wait 20m or more whenever one pays for lunch or buys some chewing gum at a corner shop, just because some other transactions got picked up first by a miner. It’s obviously different when you want to do something like micro-donations or buying illegal stuff, but I just claim that this isn’t the basis of a modern economy.

                                                                                                                Cryptography is a substitute for authority, that is true, but I don’t belive that this is always wanted. Payments can’t be easily reveresed, addresses mean nothing, clients might loose support because the core developers arbitrarily change stuff. (I for example am stuck with 0.49mBTC from an old Electrum client, and I can’t do anything with it, since the whole system is a mess, but that’s rather unrelated.) This isn’t really the dynamic basis which capitalism has managed to survive on for this long. But even disregarding all of this, it simply is true that bitcoin isn’t a proper decentralized network like BitTorrent. Since the role of the wallet and the miner is (understandably) split, these two parts of the network don’t scale equally. In China gigantic mining farms are set up using specialized hardware to mine, mine, mine. I remember reading that there was one farm that predominated over at least 10% of the total mining power. All of this seems to run contrary to the proclaimed ideals. Proof of Work, well “works” in the most abstract sense, that it produces the intended results on one side, at the cost of disregarding everything can be disregarded, irrespective of whether it should be or not. And ultimately I prioritise other things over an anti-authority fetish, as do most people -which reminds us that even if everything I said is false that Bitcoin just doesn’t have the adoption to be significant enough to anyone but Crypto-Hobbiests, Looney Libertarians and some soon-to-fail startups in Silicon Valley.

                                                                                                                1. 5

                                                                                                                  there was one farm that predominated over at least 10% of the total mining power

                                                                                                                  There was one pool that was at 42% of the total mining power! such decentralization very security

                                                                                                                    1. 5

                                                                                                                      To be fair, that was one pool consisting of multiple miners. What I was talking about was a single miner controlling 10% of the total hashing power.

                                                                                                                      1. 7

                                                                                                                        That’s definitely true.

                                                                                                                        On the other hand, if you look at incident reports like https://github.com/bitcoin/bips/blob/master/bip-0050.mediawiki — the pool policies set by the operators (often a single person has this power for a given pool) directly and significantly affect the consensus.

                                                                                                                        Ghash.io itself did have incentives to avoid giving reasons for accusations that would tank Bitcoin, but being close to 50% makes a pool a very attractive attack target: take over their transaction and parent-block choice, and you take over the entire network.

                                                                                                                    2. 0

                                                                                                                      But I don’t see this to be the case with most application of the blockchain.

                                                                                                                      Then I would advise researching it.

                                                                                                                      One doesn’t have the time to wait 20m or more whenever one pays for lunch or buys some chewing gum at a corner shop

                                                                                                                      Not trying to be rude, but it’s clear whenever anyone makes this argument that they don’t know at all how our existing financial infrastructure works. In fact, it takes months for a credit card transaction to clear to anything resembling the permanence of a mined bitcoin transaction. Same story with credit cards.

                                                                                                                      Low-risk merchants (digital goods, face-to-face sales, etc.) rarely require the average 10 minute (not sure where you got 20 from) wait for a confirmation.

                                                                                                                      If you do want permanence, Bitcoin is infinitely superior to any popular payment mechanism. Look into the payment limits set by high-value fungible goods dealers (like gold warehouses) for bitcoin vs. credit card or check.

                                                                                                                      Bitcoin just doesn’t have the adoption to be significant enough to anyone but Crypto-Hobbiests, Looney Libertarians and some soon-to-fail startups in Silicon Valley.

                                                                                                                      Very interesting theory - do you think these strawmen you’ve put up have collective hundreds of billions of dollars? As an effort barometer, are you familiar with the CBOE?

                                                                                                                      1. 10

                                                                                                                        Please try to keep a civil tone here.

                                                                                                                        Also, it’s hard to buy a cup of coffee or a steam game or a pizza with bitcoin. Ditto stocks.

                                                                                                                        1. -4

                                                                                                                          It’s hard to be nice when the quality of discourse on this topic is, for some reason, abysimally low compared to most technical topics on this site. It feels like people aren’t putting in any effort at all.

                                                                                                                          For example, why did you respond with this list of complete non-sequiturs? It has nothing to do with what we’ve been discussing in this thread except insofar as it involves bitcoin. I feel like your comments are normally high-effort, so what’s going on? Does this topic sap people’s will to think carefully?

                                                                                                                          (Civility is also reciprocal, and I’ve seen a lot of childish name-calling from the people I’m arguing with in this thread, including the linked article and the GP.)

                                                                                                                          Beyond the fact that this list is not really relevant, it’s also not true; you could have just searched “bitcoin <any of those things>” and seen that you can buy any of those things pretty easily, perhaps with a layer of indirection (just as you need a layer of indirection to buy things in the US if you already have EUR). In that list you gave, perhaps the most interesting example in bitcoin’s disfavor is Steam; Steam stopped accepting bitcoin directly recently, presumably due to low interest. However, it’s still easy to buy games from other sources (like Humble) with BTC.

                                                                                                                          1. 6

                                                                                                                            IMO, your comments are not very inspiring for quality. As someone who does not follow Bitcoin or the Blockchain all that much, I have not felt like any of your comments addressed anyone else’s comments. Instead, I have perceived you as coming off as defensive and with the attitude of “if you don’t get it you haven’t done enough research because I’m right” rather than trying to extol the virtues of the blockchain. Maybe you aren’t interested in correcting any of what you perceive as misinformation on here, and if so that’s even worse.

                                                                                                                            For example, I do not know of any place I can buy pizza with bitcoin. But you say it is possible, but perhaps with a layer of indirection. I have no idea what this layer of indirection is and you have left it vague, which does not lend me to trusting your response.

                                                                                                                            In one comment you are very dismissive of people’s Bitcoins getting hacked, but as a lay person, I see news stories on this all the time with substantial losses and no FDIC, so someone like me considers this a major issue but you gloss over it.

                                                                                                                            Many of the comments I’ve read by you on this thread are a similar level of unhelpful, all the while claiming the person you’re responding to is some combination of lazy or acting dumb. Maybe that is the truth but, again, as an outsider, all I see is the person defending the idea coming off as kind of a jerk. Maybe for someone more educated on the matter you are spot on.

                                                                                                                            1. 5

                                                                                                                              There is a religious quality to belief in the blockchain, particularly Bitcoin. It needs to be perfect in order to meet expectations for it: it can’t be “just” a distributed database, it has to be better than that. Bitcoin can’t be “just” a payment system, it has to be “the future of currency.” Check out David’s book if you’re interested in more detail.

                                                                                                                        2. 8

                                                                                                                          In fact, it takes months for a credit card transaction to clear to anything resembling the permanence of a mined bitcoin transaction. Same story with credit cards.

                                                                                                                          But I don’t have to wait months for both parties to be content the transaction is successful, only seconds, so this is really irrelevant to the point you are responding to, which is that if a Bitcoin transaction takes 10m to process then I heave to wait 10m for my transaction to be done, which people might not want to do.

                                                                                                                          1. -1

                                                                                                                            Again, as I said directly below the text you quoted, most merchants don’t require you to wait 10 minutes - only seconds.

                                                                                                                          2. 5

                                                                                                                            Then I would advise researching it.

                                                                                                                            It is exactly because I looked into the inner workings of Bitcoin and the Blockchain - as a proponent I have to mention - that I became more and more skeptical about it. And I still do support various decentralized and federated systems: BitTorrent, IPFS, (proper) HTTP, Email, … but just because the structure offers the possibility for a decentralized network, doesn’t have to mean that this potential is realized or that it is necessarily superior.

                                                                                                                            Not trying to be rude, but it’s clear whenever anyone makes this argument that they don’t know at all how our existing financial infrastructure works. In fact, it takes months for a credit card transaction to clear to anything resembling the permanence of a mined bitcoin transaction. Same story with credit cards.

                                                                                                                            The crucial difference being that, let’s say the cashier nearly instantaneously hears a some beep and knows that it isn’t his responsibility, nor that of the shop, to make sure that the money is transfered. The Bank, the credit card company or whoever has signed a binding contract lining this technical part of the process out to be what they have to care about, and if they don’t, they can be sued since there is an absolute regulatory instance - the state - in the background. This mutual delegation of trust, gives everyone a sense of security (regardless of how true or false it is) that makes people spend money instead of hording it, investing into projects instead of trading it for more secure assets. Add Bitcoins aforementioned volatileness, and no reasonable person would want to use it as their primary financial medium.

                                                                                                                            If you do want permanence, Bitcoin is infinitely superior to any popular payment mechanism.

                                                                                                                            I wouldn’t conciser 3.3 to 7 transactions per second infinitely superior to, for example Visa with an average of 1,700 t/s. Even it you think about it, there are far more that just 7 purchases being made a second around the whole world for this to be realistically feasible. But on the other side, as @friendlysock Bitcoin makes up for it by not having too many things you can actually buy with it: The region I live in has approximately a million or something inhabitants, but according to CoinMap even by the most generous measures, only 5 shops (withing a 30km radius) accepting it as a payment method. And most of those just offer it to promote themselves anyway.

                                                                                                                            Very interesting theory - do you think these strawmen you’ve put up have collective hundreds of billions of dollars? As an effort barometer, are you familiar with the CBOE?

                                                                                                                            (I prefer to think about my phrasing as a exaggeration and a handful of other literary deviced, instead of a fallacy, but never mind that) I’ll give you this: It has been a while since I’ve properly engaged with Bitcoin, and I was always more interested in the technological than the economical side, since I have a bit of an aversion towards libertarian politics. And it might be true that money is invested, but that still doesn’t change anything about all the other issues. It remains a bubble, a volatile, unstable, unpredictable bubble, and as it is typical for bubbles, people invest disproportional sums into it - which in the end makes it a bubble.

                                                                                                                            1. 0

                                                                                                                              The crucial difference being that, let’s say the cashier nearly instantaneously hears a some beep and knows that it isn’t his responsibility, nor that of the shop, to make sure that the money is transfered.

                                                                                                                              Not quite. The shop doesn’t actually have the money. The customer can revoke that payment at any time in the next 90 or 180 days, depending. Credit card fraud (including fraudulent chargebacks) is a huge problem for businesses, especially online businesses. There are lots of good technical articles online about combatting this with machine learning which should give you an idea of the scope of the problem.

                                                                                                                              makes people spend money instead of hording it,

                                                                                                                              Basically any argument of this form (including arguments for inflation) don’t really make sense with the existence of arbitrage.

                                                                                                                              Add Bitcoins aforementioned volatileness, and no reasonable person would want to use it as their primary financial medium.

                                                                                                                              So it sounds like it would make people… spend money instead of hoarding it, which you were just arguing for?

                                                                                                                              I wouldn’t conciser 3.3 to 7 transactions per second infinitely superior to, for example Visa with an average of 1,700 t/s.

                                                                                                                              https://lightning.network

                                                                                                                              as @friendlysock Bitcoin makes up for it by not having too many things you can actually buy with it

                                                                                                                              This is just patently wrong. The number of web stores that take Bitcoin directly is substantial (both in number and traffic volume), and even the number of physical stores (at least in the US) is impressive given that it’s going up against a national currency. How many stores in the US take even EUR directly?

                                                                                                                              Anything you can’t buy directly you can buy with some small indirection, like a BTC-USD forex card.

                                                                                                                              It remains a bubble, a volatile, unstable, unpredictable bubble

                                                                                                                              It’s certainly volatile, and it’s certainly unstable, but it may or may not be a bubble depending on your model for what Bitcoin’s role in global finance is going to become.

                                                                                                                              1. 5

                                                                                                                                Not quite. The shop doesn’t actually have the money. The customer can revoke that payment at any time in the next 90 or 180 days, depending

                                                                                                                                You’ve still missed my point - it isn’t important if the money has been actually transfered, but that there is trust that a framework behind all of this will guarantee that the money will be there when it has to be, as well as a protocol specifying what has to be done if the payment is to be revoked, if a purchase wishes to be undone, etc.

                                                                                                                                Credit card fraud (including fraudulent chargebacks) is a huge problem for businesses, especially online businesses.

                                                                                                                                Part of the reason, I would suspect is that the Internet was never made to be a platform for online businesses - but I’m not going to deny the problem, I’m certainly not a defender of banks and credit card companies - just an opponent of Bitcoin.

                                                                                                                                Basically any argument of this form (including arguments for inflation) don’t really make sense with the existence of arbitrage.

                                                                                                                                Could you elaborate? You have missed my point a few times already, so I’d rather we understand each other instead of having two monologues.

                                                                                                                                So it sounds like it would make people… spend money instead of hoarding it, which you were just arguing for?

                                                                                                                                No, if it’s volatile people either won’t buy into it in the first place. And if a currency is unstable, like Bitcoin inflating and deflating all the time, people don’t even know what do do with it, if it were their main asset (which I was I understand you are promoting, but nobody does). I doubt it will ever happen, since if prices were insecure, the whole economy would suffer, because all the “usual” incentives would be distorted.

                                                                                                                                https://lightning.network

                                                                                                                                I haven’t heard of this until you mentioned it, but it seems like it’s quite new, so time has to test this yet-another-bitcoin-related project that has popped up. Even disregarding that it will again need to first to make a name of it self, then be accepted, then adopted, etc. from what I gather, it’s not the ultimate solution (but, I might be wrong), especially since it seems to encourage centralization, which I believe is what you are so afraid of.

                                                                                                                                This is just patently wrong. The number of web stores that take Bitcoin directly is substantial (both in number and traffic volume),

                                                                                                                                Sure, there might be a great quantity of shops (as I mentioned, who use Bitcoin as a medium to promote themselves), but I, and from what I know most people, don’t really care about these small, frankly often dodgy online shops. Can I use it to pay directly on Amazon? Ebay? Sure, you can convert it back and forth, but all that means it that Bitcoin and other crypto currencies are just an extra step for life stylists and hipster, with no added benefit. And these shops don’t even accept Bitcoin directly, to my knowledge always just so they can convert it into their national currency - i.e. the one they actually use and Bitcoins value is always compared to. What is even Bitcoin without the USD, the currency it hates but can’t stop comparing itself to?

                                                                                                                                and even the number of physical stores (at least in the US) is impressive given that it’s going up against a national currency.

                                                                                                                                The same problems apply as I’ve already mentioned, but I wonder: have you actually ever used Bitcoin to pay in a shop? I’ve done it once and it was a hassle - in the end I just bought it with regular money like a normal person because it was frankly too embarrassing to have the cashier have to find the right QR code, me to take out my phone, wait for me got get an internet connection, try and scan the code, wait, wait, wait…. And that is of course only if you want to make the trip to buy for the sake of spending money, and decide to make a trip to some place you’d usually never go to buy something you don’t even need.

                                                                                                                                Ok when you’re buying drugs online or doing something with microdonations, but otherwise… meh.

                                                                                                                                How many stores in the US take even EUR directly?

                                                                                                                                Why should they? And even if they do, they convert it back to US dollars, because that’s the common currency - there isn’t really a point in a currency (one could even question if it is one), when nobody you economically interact with uses it.

                                                                                                                                Anything you can’t buy directly you can buy with some small indirection, like a BTC-USD forex card.

                                                                                                                                So a round-about payment over a centralized instance - this is the future? Seriously, this dishonesty of Bitcoin advocates (and Libertarians in general) is why you guys are so unpopular. I am deeply disgusted that I have ever advocated for this mess.

                                                                                                                                It’s certainly volatile, and it’s certainly unstable, but it may or may not be a bubble depending on your model for what Bitcoin’s role in global finance is going to become.

                                                                                                                                So you admit that is has none of the necessary preconditions to be a currency… but for some reason it will… do what exactly? If you respond to anything I mentioned here, at least tell me this: What is your “model” for what Bitcoin’s role is going to be?

                                                                                                                        3. 14

                                                                                                                          Why don’t you believe it is anti-enviromental? It certainly seems to be pretty power hungry. In fact it’s hunger for power is part of why it’s effective. All of the same arguments about using less power should apply.

                                                                                                                          1. -1

                                                                                                                            Trying to reduce energy consumption is counterproductive. Energy abundance is one of the primary driving forces of civilizational advancement. Much better is to generate more, cleaner energy. Expending a few terrawatts on substantially improved economic infrastructure is a perfectly reasonable trade-off.

                                                                                                                            Blaming bitcoin for consuming energy is like blaming almond farmers for using water. If their use of a resource is a problem, you should either get more of it or fix your economic system so externalities are priced in. Rationing is not an effective solution.

                                                                                                                            1. 10

                                                                                                                              on substantially improved economic infrastructure

                                                                                                                              This claim definitely needs substantiation, given that in practice bitcoin does everything worse than the alternatives.

                                                                                                                              1. -1

                                                                                                                                bitcoin does everything worse than the alternatives.

                                                                                                                                Come on David, we’ve been over this before and discovered that you just have a crazy definition of “better” explicitly selected to rule out cryptocurrencies.

                                                                                                                                Here’s a way Bitcoin is better than any of its traditional digital alternatives; bitcoin transactions can’t be busted. As you’ve stated before, you think going back on transactions at the whim of network operators is a good thing, and as I stated before I think that’s silly. This is getting tiring.

                                                                                                                                A few more, for which you no doubt have some other excuse for why this is actually a bad thing; Bitcoin can’t be taken without the user’s permission (let me guess; “but people get hacked sometimes”, right?). Bitcoin doesn’t impose an inflationary loss on its users (“but what will the fed do?!”). Bitcoin isn’t vulnerable to economic censorship (don’t know if we’ve argued about this one; I’m guessing you’re going to claim that capital controls are critical for national security or something.). The list goes on, but I’m pretty sure we’ve gone over most of it before.

                                                                                                                                I’ll admit that bitcoin isn’t a panacea, but “it does everything worse” is clearly a silly nonsensical claim.

                                                                                                                              2. 4

                                                                                                                                Reducing total energy consumption may or may not be counterproductive. But almost every industry I can name has a vested interest in being more power efficient for it’s particular usage of energy. The purpose of a car isn’t to burn gasoline it is to get people places. If it can do that with less gasoline people are generally happier with it.

                                                                                                                                PoW however tries to maximizes power consumption, via second order effects , with the goal of making it expensive to try to subvert the chain. It’s clever because it leverages economics to keep it in everyone’s best interest to not fork but it’s not the same as something like a car where reducing energy consumption is part of the value add.

                                                                                                                                I think that this makes PoW significantly different than just about any other use of energy that I can think of.

                                                                                                                                1. 3

                                                                                                                                  Indeed. The underlying idea of Bitcoin is to simulate the mining of gold (or any other finite, valuable resource). By ensuring that an asset is always difficult to procure (a block reward every 10 minutes, block reward halving every 4 years), there’s a guard against some entity devaluing the currency (literally by fiat).

                                                                                                                                  This means of course that no matter how fast or efficient the hardware used to process transactions becomes, the difficulty will always rise to compensate for it. The energy per hash calculation has fallen precipitously, but the number of hash calculations required to find a block has risen to compensate.

                                                                                                                            2. 6

                                                                                                                              We’ve been doing each a long time without proof of work. There’s lots of systems that are decentralized with parties that have to look out for each other a bit. The banking system is an example. They have protocols and lawyers to take care of most problems. Things work fine most of the time. There are also cryptographically-anchored trust systems like trusted timestamping and CA’s who do what they’re set up to do within their incentives. If we can do both in isolation without PoW, we can probably do both together without PoW using some combination of what’s already worked.

                                                                                                                              I also think we haven’t even begun to explore the possibilities of building more trustworthy charters, organizational incentives, contracts, and so on. The failings people speak of with centralized organizations are almost always about for-profit companies or strong-arming governments whose structure, incentives, and culture is prone to causing problems like that. So, maybe we eliminate root cause instead of tools root cause uses to bring problems since they’ll probably just bring new forms of problems. Regulations, disruption, or bans of decentralized payment is what I predicted would be response with some reactions already happening. They just got quite lucky that big banks like Bank of America got interested in subverting it through the legal and financial system for their own gains. Those heavyweights are probably all that held the government dogs back. Ironically, the same ones that killed Wikileaks by cutting off its payments.

                                                                                                                          2. 8

                                                                                                                            In what context do you view proof-of-work as useful?

                                                                                                                            1. 11

                                                                                                                              You have addressed 0 of the actual content of the article.

                                                                                                                            1. 6

                                                                                                                              I spent most of this weekend working on a fork of RegexGenerator. It is a Java tool to generate regular expressions automatically from examples. I’ll probably try to rebase my changes onto another fork that changes the build to use Gradle.

                                                                                                                              1. 3

                                                                                                                                I find this interesting, because I one wrote an android game where one was supposed to solve regular expression-based tasks, but since I was randomly creating the strings the RE should match or not, some people suggested using something like what you are currently working on. I never got around to implementing it, partially because at the time I constantly had build problems with AndroidStudio but also because I couldn’t find any good libraries at the time - so maybe your project might turn out very helpful for my game.

                                                                                                                                What else do you plan to change or improve?

                                                                                                                                1. 1

                                                                                                                                  I’ll start by writing tests. After I raise the coverage high enough, I would also like to reduce mutable state, split up some of the larger classes, and change the representation for regular expressions. The current representation has node that contain an array of child nodes that are directly manipulated by calling code. I might also move the code to Kotlin.

                                                                                                                              1. 6

                                                                                                                                I’ve recently discovered The essence of linear algebra, and I have been recommending it to everyone I know, so I guess this is an adequate opportunity to share this, again. Not strictly CS, but since I’ve been having a bit of a struggle with Linear Algebra at university, due to my inability to “understand” it in any deeper sense than just memorising formulas, finding this has been very refreshing.

                                                                                                                                1. 40

                                                                                                                                  Thanks to the Recurse Center for inviting me to speak and for making the video. I’m here if anyone has questions.

                                                                                                                                  1. 21

                                                                                                                                    A very non-technical question: Why should Xi “only” be an editor for the next 20 years? In terms of text editors, that’s not that long. People, like me, use Editors that are nearly twice as old as I am, and the reasons don’t seem to be tied to performance or the internal structure of the implementations, but rather a core “philosophy” regarding how things are done, or how the programmer should relate to text. What does Xi have to offer regarding these “practical” qualities, that have made, for example Emacs or Vi(m) last for so long? Does Xi see itself in such a certain tradition, having a certain ideal that you aspire to, or do you set your own terms? These could seem important if one intends to write an editor that should be practically used, which is what I gathered from the video, as opposed to being a “purely academic” experiment, which would obviously have different goals and priorities.

                                                                                                                                    1. 4

                                                                                                                                      Do you plan on doing a Linux frontend yourself and would it matter performance-wise? I saw that some people are working on a gtk+ frontend but I was wondering if it will be as fast as the mac one.

                                                                                                                                      1. 4

                                                                                                                                        In my ideal world, there’d be a cross-fertilization of code and ideas so the linux front-end would be just as nice and performant as the mac one, but it’s unlikely at this point I’ll take it on myself.

                                                                                                                                        1. 2

                                                                                                                                          I just tried xi-gtk and it’s very fast. Not sure what it’s like compared to the swift one but it’s a whole lot faster than gedit.

                                                                                                                                          1. 1

                                                                                                                                            nice, thanks!

                                                                                                                                        2. 4

                                                                                                                                          Also, here is a cool demo of async loading of big text files – you can navigate and I think even edit while loading:

                                                                                                                                          https://youtu.be/sPhpelUfu8Q?t=1601

                                                                                                                                          Using immer, Clojure-like immutable data structures in C++:

                                                                                                                                          https://github.com/arximboldi/immer

                                                                                                                                          The editor is a demo of the library: https://github.com/arximboldi/ewig

                                                                                                                                          1. 3

                                                                                                                                            I just watched the video. It looks really interesting, although a lot of it was over my head!

                                                                                                                                            I more or less understand the process model, async architecture, and distributed data structures. I like that part – very Unix-y.

                                                                                                                                            But there were a lot of rendering terms I didn’t understand. Maybe because some of it is Mac-specific. But also some of the OpenGL issues. Is there any background material on text rendering you’d recommend?

                                                                                                                                            Also, I don’t understand the connection to Fuschia? I was under the impression that Fuschia was more consumer-facing, and Xi is more developer-facing. That is, I imagine most consumers don’t have text editors installed. There is no text editor on Android or ChromeOS.

                                                                                                                                            Or is xi more general than a vi/emacs replacement – is it meant to be used as part of a browser for implementing text boxes?

                                                                                                                                            1. 4

                                                                                                                                              Glad you enjoyed the talk!

                                                                                                                                              Unfortunately, there really isn’t a lot of material on text processing, especially from a modern perspective. A lot of what I learned about rendering came from reading other code (alacritty in particular), and talking to people like Patrick Walton and my teammates on Chrome and Android.

                                                                                                                                              There is an EditText widget on Android (a good chunk of my career involved working on it), but you certainly wouldn’t want to write code (or long-form text) in it. My goal with xi is to make a core lightweight and performant enough it can be used in such cases, easily embedded in apps, yet powerful enough for cases where you really do need a dedicated editor application.

                                                                                                                                            2. 2

                                                                                                                                              I feel like it’s fairly out of my league, but I’ve been thinking about implementing a Sublime Text-like editor (multiple cursors, smart brackets/quotation marks) for arbitrary text fields in web sites. Would it be possible to use Xi as a backend for something like that? Perhaps via compilation to WASM?

                                                                                                                                              1. 8

                                                                                                                                                Eventually it is my hope that something like that could work. There are some technical details (the current implementation uses threads), so it’s not an easy project. In the meantime, the excellent CodeMirror does multiple selections, and is very widely used embedded in websites.

                                                                                                                                            1. 3

                                                                                                                                              I’ve been seeing more and more about Oil Shell, but only now, after having have read this I have to say that I have found actual interest in the project. Until now, you only had a pretty website, but ideas like these really intrigue me.

                                                                                                                                              But seeing that you’ve engaged with many different shell implementations,have you taken a look a stuff like Plan 9’s rc or related tools like mk? While I personally haven’t engaged too much with either, I know there are people who certainly see these as superior, and I’m guessing that there has to be something to it?

                                                                                                                                              1. 3

                                                                                                                                                Thanks for the feedback!

                                                                                                                                                I’ve read the rc and mk papers, and discussed them with a few people on /r/oilshell [1]. This comment has an analysis of mk. As expected, there are good things and bad things about it:

                                                                                                                                                https://lobste.rs/s/azldgm/oil_comments_about_shell_awk_make#c_rat8kv

                                                                                                                                                It’s impressive given its age, but I think it has been surpassed. Ditto for rc. Although rc and es certainly are cleaner and smaller than bash, bash can do everything they can. As I recall, both of them were under 10,000 lines of C code, and there’s only so much you can do in that space.

                                                                                                                                                More links here: https://github.com/oilshell/oil/wiki/ExternalResources

                                                                                                                                                [1] https://www.reddit.com/r/oilshell/

                                                                                                                                              1. 1

                                                                                                                                                How stable is this now? I heard about this about a year ago, and I found it very interesting, but I remember them warning against using it in production systems. Has anyone got any practical experience with porter?