Threads for vletrmx

  1. 12

    This is interesting, and I think I agree with many arguments when it comes to the reasons java, OCaml, Haskell, Go, etc. haven’t replaced C. However the author cites rust only briefly (and C++ not at all?) and doesn’t really convince me why rust isn’t the replacement he awaits: almost all you can do in C, you can do in rust (using “unsafe”, but that’s what rust is designed for after all), or in C++; you still have a higherer-level, safer (by default — can still write unsafe code where needed), unmanaged language that can speak the C ABI. Some projects have started replacing their C code with rust in an incremental (librsvg, I think? And of course firefox) because rust can speak the C ABI and use foreign memory like a good citizen of the systems world. Even C compilers are written in C++ these days.

    To me that’s more “some were meant for no-gc, C ABI speaking, unsafe-able languages” than “some were meant for C”. :-)

    1. 17

      Besides Rust, I think Zig, Nim, and D are strong contenders. Nothing against Rust, of course, but I’m not convinced it’s the best C replacement for every use case. It’s good to have options!

      Nonetheless, I imagine C will linger on for decades to come, just due to network effects and economics. Legacy codebases, especially low-level ones, often receive little maintenance effort relative to usage, and C code is incredibly widespread.

      1. 15

        I love Rust, but I think Zig and D (in the ‘better C’ mode and hopefully their new borrow checker) are closer to the simplicity and low-level functionality of C. Rust is a much nicer C++, with simpler (hah!) semantics and more room to improve. C++ is, unfortunately, a Frankenstein monster of a language that requires a 2000 page manual just to describe all the hidden weird things objects are doing behind your back. Every time I have to re-learn move semantics for a tiny project, I want to throw up.

        1. 3

          i was also wondering, while reading the article, how well ada would fit the author’s use case (i’m not at all familiar with the langauge, i’ve just heard it praised as a safe low-level language)

          1. 1

            The lot of them! It was kind of a large gap between C and Python/Perl/Ruby/Java.

            1. 12

              Maybe I’m the archetype of a C-programmer not going for Rust. I appreciate Rust and as a Mathematician, I like the idea of hard guarantees that aren’t a given in C. However, Rust annoys me for three main reasons, and these are deal-breakers for me:

              • Compile time: This is not merely the language’s fault, and has more to do with how LLVM is used, but there doesn’t seem to be much push to improve the situation, either. It annoys me as a developer, but it also really annoys me as a Gentoo user when a Firefox compilation takes longer and longer with each subsequent Rust release. Golang is a shining example for how you can actually improve compilation times over C. Admittedly, Rust has more static analysis, but damn is it slow to compile! I like efficiency, who doesn’t? Rust really drops the ball there.
              • Standard library/external libraries: By trying to please everyone and not mandating certain solutions, one is constantly referred to this or that library on GitHub that is “usually used” and “recommended”. In other cases, there are two competing implementations. Sure, Rust is a young language, but for that reason alone I would never choose it to build anything serious on top of it, as one needs to be able to rely on interfaces. The Rust developers should stop trying to please everybody and come up with standard interfaces that also get shipped with the standard install.
              • Cargo/Package management: This point is really close to the one before it: Cargo is an interesting system, but really ends up becoming a “monosolution” for Rust setups. Call me old-fashioned, but I like package managers (especially Gentoo’s) and Cargo just works around it. When installing a Rust package, you end up having to be connected to the internet and often end up downloading dozens of small crates from some shady GitHub repos. I won’t make the comparison with node.js, given Cargo can be “tagged” to a certain version, but I could imagine a similar scenario to leftpad in the future. Rust really needs a better standard library so you don’t have to pull in so much stuff from other people.

              To put it shortly: What I like about C is its simplicity and self-reliance. You don’t need Cargo to babysit it, you don’t need dozens of external crates to do basic stuff and it doesn’t get in the way of the package manager. I actually like Rust’s ownership system, but hate almost anything around it.

              1. 16

                C doesn’t even have a hash table. It needs more external libraries to do basic stuffs, not less.

                1. 5

                  See, I feel the exact opposite when it comes to Cargo vs. system’s package manager: managing versions of libraries using your system’s package manager is a royal pain in the ass or outright impossible when you have multiple projects requiring different versions of a library. In my experience with C and C++, you’ll end up using CMake or Meson to build exactly the same functionality that Cargo deploys for you, at a much higher cost than just adding one line in a configuration file.

                  In fact, my biggest gripe with C and C++ is that they still depend on a 3-step build system (preprocessing, compiling, linking) each of which requires you to specify the location of a group of files. I get why having header files was attractive in the 1970s when you counted your computer’s memory in KBs, but it makes writing and maintaining code such a pain in the ass when compared with a modern module system.

                  The funniest bit is I used to consider all these things as ‘easy to deal with’ when all I did was write C/C++ code 15 years ago. Nowadays, having to switch from Go, Rust or any other language to C for a small project makes me want to cry because I know I’ll spend about 20% of the time managing bullshit that has nothing to do with the code I care about.

                  1. 9

                    Build systems in C give a feeling of craftsmanship. It takes a skill to write a Makefile that correctly supports parallel builds, exact dependencies, interruptions and cleanups, etc. And so much work into making it work across platforms, and compilers.

                    And then Cargo just makes it pointless. It’s like you were king’s best messenger trained to ride the fastest stallions, and Cargo’s like “thanks, but we’ve got e-mail”.

                    1. 2

                      LOL, I guess it’s a matter of age. When I first started programming, I’d love all that stuff. I can’t count how many libraries and tools I re-implemented or extended because they didn’t do something exactly the way I wanted it. Or the nights I spent configuring my Linux machine to work just right. Or the CPU time I spent re-encoding all of my MP3 collection to VBR because it’d save 5% of storage.

                      Now, I learned Cargo for a tiny project and I keep swearing every time I have to start a Python virtualenv because it’s just not easy enough, goddammit!.

                  2. 2

                    This is a fair criticism of C, personally I would love to see a set commonly used data structures added to the C standard library. However, currently in the C world you either write your own or use something like glib, neither of these cases require the equivalent of Cargo.

                    1. 4

                      However, currently in the C world you either write your own or use something like glib, neither of these cases require the equivalent of Cargo.

                      Neither does using the Rust standard library, which also has a hash table implementation (and many other useful data structures). You can just use std and compile your project with rustc.

                      1. 1

                        We’re talking about dependencies in general, not just hash tables. FRIGN’s point is that the Rust standard library is lacking, so you end up needing crates.

                        1. 3

                          But you and FRIGN are complaining about the Rust standard library compared to C. The Rust standard library is much more comprehensive than the C standard library or the C standard library + glib. So, the whole point seems to be void if C is the point of comparison.

                          If you are comparing to the Java standard library, sure!

                          1. 1

                            But you and FRIGN are complaining about the Rust standard library compared to C.

                            Not really. The point being made is that a typical Rust application has to download a bunch of stuff from Github (crates), where as a typical C application does not.

                            1. 8

                              That’s just because it’s convenient and most people don’t really care that it happens. But it’s not inherent to the tooling:

                              $ git clone -b ag/vendor-example https://github.com/BurntSushi/ripgrep
                              $ cd ripgrep
                              $ cargo build --release
                              

                              Other than the initial clone (obviously), nothing should be talking to GitHub or crates.io. You can even do cargo build --release --offline if you’re paranoid.

                              I set that up in about 3 minutes. All I did was run cargo vendor, setup a .cargo/config to tell it to use the vendor directory, committed everything to a branch and pushed it. Easy peasy. If this were something a lot of people really cared about, you’d see this kind of setup more frequently. But people don’t really care as far as I can tell.

                              where as a typical C application does not

                              When was that last time you built a GNU C application? Last time I tried to build GNU grep, its build tooling downloaded a whole bunch of extra goop.

                              1. -2

                                Nice strawman, I said a typical C application, not a typical GNU C application.

                                1. 5

                                  TIL that a GNU C application is not a “typical” C application. Lol.

                                  1. -1

                                    None of the C code I’ve worked on was written by GNU, and most of the C code out in the real world wasn’t written by GNU either. I find it frankly bizarre that you are seriously trying to suggest that GNU’s practices are somehow representative of all projects written in C.

                                    1. 3

                                      You said “a typical C application.” Now you’re saying “representative” and “what I’ve worked on.”

                                      If the implementation of coreutils for one of the most popular operating systems in history doesn’t constitute what’s “typical,” then I don’t know what does.

                                      Talk about bizarre.

                                      Moreover, you didn’t even bother to respond to the substance of my response, which was to point out that the tooling supports exactly what you want. People just don’t care. Instead, you’ve decided to double down on your own imprecise statement and have continued to shift the goal posts.

                                      1. 0

                                        and most of the C code out in the real world wasn’t written by GNU either.

                                        ^ typical

                                        I don’t have the time or patience to debate semantics though.

                                        As for your other point, see FRIGN’s comment for my response. (It doesn’t matter what’s possible when the reality is random crates get pulled from github repos)

                    2. 1

                      C doesn’t even have a hash table.

                      Why do you say “even”? There are many hash table implementations in C, with different compromises. It would be untoward if any of them made its way into the base language. There are other things missing in C which are arguably more fundamental (to me) before hash tables. It is only fair if all of these things are kept out of the language, lest the people whose favorite feature has not been included feel alienated by the changes.

                    3. 15

                      but there doesn’t seem to be much push to improve the situation

                      Definitely not true. There are people working on this and there has been quite a bit of progress:

                      $ git clone https://github.com/BurntSushi/ripgrep
                      $ cd ripgrep
                      $ git checkout 0.4.0
                      $ time cargo +1.12.0 build --release
                      
                      real    1:04.05
                      user    1:51.42
                      sys     2.282
                      maxmem  360 MB
                      faults  736
                      $ time cargo +1.43.1 build --release
                      
                      real    19.065
                      user    2:34.51
                      sys     3.101
                      maxmem  740 MB
                      faults  0
                      

                      That’s 30% of what it once was a few years ago. Pretty big improvement from my perspective. The compilation time improvements come from all around too. Whether it’s improving the efficiency of parallelism or micro-optimizing rustc itself: here, here, here, here, here, here or here.

                      People care.

                      The Rust developers should stop trying to please everybody and come up with standard interfaces that also get shipped with the standard install.

                      That’s one of std’s primary objectives. It has tons of interfaces in it.

                      This criticism is just so weird, given that your alternative is C. I mean, if you want the C experience of “simplicity and self-reliance,” then std alone is probably pretty close to sufficient. And if you want the full POSIX experience, bring in libc and code like its C. (Or maybe use a safe interface that somebody else has thoughtfully designed.)

                      When installing a Rust package, you end up having to be connected to the internet

                      You do not, at least, no more than you are with a normal Linux distro package manager. This was a hard requirement. Debian for example requires the ability to use Cargo without connecting to the Internet.

                      and often end up downloading dozens of small crates from some shady GitHub repos.

                      Yup, the way the crates.io model works means the burden of doing due diligence is placed on each person developing a Rust project. But if you’re fine with the spartan nature of C’s standard library, then you should be just fine using a pretty small set of well established crates that aren’t shady. Happy to see counter examples though!

                      but I could imagine a similar scenario to leftpad in the future.

                      The leftpad disaster was specifically caused by someone removing their package from the repository. You can’t do that with crates.io. You can “yank” crates, but they remain available. Yanking a crate just prevents new dependents from being published.

                      Rust really needs a better standard library so you don’t have to pull in so much stuff from other people.

                      … like C? o_0

                      1. 10

                        This point is really close to the one before it: Cargo is an interesting system, but really ends up becoming a “monosolution” for Rust setups. Call me old-fashioned, but I like package managers (especially Gentoo’s) and Cargo just works around it.

                        C has just been in the luxurious position that its package managers have been the default system package managers. Most Linux package managers are effectively a C package managers. Of course, over time packages for other languages have been added, but they have mostly been second-class citizens.

                        It is logical that Cargo works around those package managers. Most of them are a mismatch for Rust/Go/node.js packages, because they are centered around distributing C libraries, headers, and binaries.

                        but I could imagine a similar scenario to leftpad in the future.

                        Rust et al. certainly have a much higher risk, since anyone can upload anything to crates.io. However, I think it is also an illusion that distribution maintainers are actually vetting code. In many cases maintainers will just bump versions and update hashes. Of course, there is some gatekeeping in that distributions usually only provide packages from better-known projects.

                        Rust really needs a better standard library so you don’t have to pull in so much stuff from other people.

                        You mean a large standard library like… C?

                        1. 3

                          C has just been in the luxurious position that its package managers have been the default system package managers.

                          This just isn’t true, if you look at how packages are built for Debian for example you will find that languages such as Python and Perl are just as well supported as C. No, the system package managers are for the most part language agnostic.

                          1. 5

                            This just isn’t true, if you look at how packages are built for Debian for example you will find that languages such as Python and Perl are just as well supported as C.

                            Most distributions only have a small subset of popular packages and usually only a limited number of versions (if multiple at all).

                            The fact that most Python development happens in virtual environments with pip-installed packages, even on personal machines, shows that most package managers and package sets are severely lacking for Python development.

                            s/Python/most non-C languages/

                            No, the system package managers are for the most part language agnostic.

                            Well if you define language agnostic as can dump files in a global namespace, because that’s typically enough for C libraries, sure. However, that does not work for many other languages, for various reasons, such as: no guaranteed ABI stability (so, any change down the chain of dependencies needs to trigger builds of all dependents, but there is no automated way to detect this, because packages are built in isolation), no strong tradition of ABI stability (various downstream users need different versions of a package), etc.

                            1. 5

                              No, most development happens in virtualenv because python packaging is so broken that if you install a package you cannot reliably uninstall it.

                              If we didn’t have a package manager for each language then the packages maintained by the OS would be more comprehensive, by necessity. Basically having a different packaging system for each programming language was a mistake in my view. I have some hope that Nix will remedy the situation somewhat.

                              edit: it’s also difficult to reply to your comments if you substantially edit them by adding entirely new sections after posting…

                              1. 5

                                No, most development happens in virtualenv because python packaging is so broken that if you install a package you cannot reliably uninstall it.

                                I have no idea what you mean here. Can’t you use dpkg/APT or rpm/DNF to uninstall a Python package?

                                If we didn’t have a package manager for each language then the packages maintained by the OS would be more comprehensive, by necessity.

                                We are going in circles. Why do you think languages have package managers? Technical reasons: the distribution package managers are too limited to handle what languages need. Social/political reasons: having the distributions as gatekeepers slows down the evolution of language ecosystems.

                                I have some hope that Nix will remedy the situation somewhat.

                                Nix (and Guix) can handle this, because it is powerful enough to implement the necessary language-specific packaging logic. In fact, Nix’ buildRustCrate is more or less an implementation of Cargo in Nix + shell script. It does not use Cargo. Moreover, Nix can handle a lot of the concerns that I mentioned upthread: it can easily handle multiple different versions of a package and ABI-instability. E.g. if in Nix the derivation of say the Rust compiler is updated, all packages of which Rust is a transitive dependency are rebuilt.

                                As I said, traditional package managers are built for a C world. Not a Rust, Python, Go, or whatever world.

                        2. 4

                          The first problem is a technical one, unless Rust is doing things such that it can’t be compiled efficiently, but the latter two are cultural ones which point up differences in what language designers and implementers are expected to provide then versus now: In short, Rust tries to provide the total system, everything you need to build random Rust code you find online, whereas C doesn’t and never did. Rust is therefore in with JS, as you mention, but also Perl, Python, Ruby, and even Common Lisp now that Quicklisp and ASDF exist.

                          I was going to “blame” Perl and CPAN for this notion that language implementations should come with package management, but apparently CPAN was made in imitation of CTAN, the Comprehensive TeX Archive Network, so I guess this goes back even further. However, the blame isn’t with the language implementers at all: Packaging stuff is one of those things which has been re-invented so many times it’s bound to be re-invented a few more, simply because nobody can decide on a single way of doing it. Therefore, since language implementers can’t rely on OS package repos to have a rich selection up-to-date library versions, and rightly balk at the idea of making n different OS-specific packages for each version of each library, it’s only natural each language would reinvent that wheel. It makes even more sense when you consider people using old LTS OS releases, which won’t get newer library versions at this point, and consider longstanding practice from the days before OSes tended to have package management at all.

                          1. 7

                            Therefore, since language implementers can’t rely on OS package repos to have a rich selection up-to-date library versions, and rightly balk at the idea of making n different OS-specific packages for each version of each library, it’s only natural each language would reinvent that wheel.

                            This is right on the mark.

                            Sorry if this is a bit of a tangent, but I think it is not just a failing of package sets – from the distributor’s perspective it is impossible to package every Rust crate and rust crate version manually – but especially of package managers themselves. There is nothing that prevents a powerful package management system to generate package sets from Cargo.lock files. But most package managers were not built for generating package definitions programmatically and most package managers do not allow allow installing multiple package versions in parallel (e.g. ndarray 0.11.0 and ndarray 0.12.0).

                            Nix shows that this is definitely feasible, e.g. the combo of crate2nix and buildRustCrate can create Nix derivations for every dependency in a Cargo.lock file. It does not use cargo at all, compiles every crate into a separate Nix store path. As a result, Rust crates are not really different from any other package provided through nixpkgs.

                            I am not that familiar with Guix, but I bet it could do the same.

                          2. 3

                            Build times are important, and you’re right, Rust takes a while to compile. Given the choice between waiting for rustc to finish and spending a lot longer debugging a C program after the fact, I choose the former. Or, better yet, use D and get the best of both worlds.

                            1. 3

                              rust can be damn fast to compile, most rust library authors just exercise fairly poor taste in my opinion and tend not to care how bad their build times get. sled.rs compiles in 6 seconds on my laptop, and most other embedded databases take a LOT longer (usually minutes), despite sled being Rust and them being C or C++.

                              rust is a complex tool, and as such, you need to exercise judgement (which, admittedly, is rare, but that’s no different from anything else). you can avoid unnecessary genericism, proc macros, and trivial dependencies to get compile times that are extremely zippy.

                              1. 2

                                Thanks for your insights! I’ll keep it in mind the next time I try out Rust.

                                1. 1

                                  Feel free to reach out if you hit any friction, I’m happy to point folks in the direction they want to go with Rust :)

                            2. 5

                              almost all you can do in C, you can do in rust

                              As an anecdata, I‘ve immediately recognized the snippet with elf header from the article, because I used one of the same tricks (just memcpying a repr(C) struct) for writing elf files in Rust a couple of months ago.

                              1. 2

                                I though about using rust to implement a byte-code compiler / vm for a gc’d language project, but I assumed that this would require too much fighting to escape rust’s ownership restrictions. Do you have any insight into how well suited rust is for vm implementation? I haven’t used the language much but I’d love to pick it up if I though I could make it work for my needs.

                                (I see that there’s a python interpreter written in rust, but I’m having trouble locating its gc implementation)

                                1. 5

                                  I honestly don’t know, I have never written an interpreter. You probably can fall back on unsafe for some things anyway, and still benefit from the move semantics, sum types, syntax, and friendly error messages. I’m doing a bit of exploring symbolic computations with rust and there are also some design space exploration to be done there.

                                  1. 2

                                    IMO, Rust is just as good as C and C++ for projects like this, if not better thanks to pattern matching and a focus on safety (which goes far beyond the borrow checker). Don’t be afraid to use raw pointers and NonNull pointers when they are appropriate.

                                    1. 2

                                      Also, just saw this GC for Rust on the front page: https://github.com/zesterer/broom/blob/master/README.md

                                      Looks like it’s designed specificly for writing dynamic languages in Rust.

                                      1. 1

                                        Oh cool! This looks super useful

                                    2. 2

                                      I wrote a ST80 VM in rust just to play around; the result was beautifully simple and didn’t require any unsafe code, though it doesn’t currently have any optimization at all. The result was still reasonably snappy, but I suspect that a big part of that is that the code I was running on it was designed in, well, 1980.

                                      1. 2

                                        I recently did a simple lisp interpreter in rust. Eventually decided to re-do it in c because of shared mutation and garbage collection.

                                        1. 2

                                          Rust works well for VM implementation. For GC, you may want to look at https://github.com/zesterer/broom.

                                      1. 5

                                        The suckless community, and some of the plan9 communities, are dominated by jackasses. I hope that’s strong enough wording to impress the severity. Don’t go into IRC for help. Stay off the suckless email list. The software is great, the people who write it are well-spoken and well-reasoned, but for some reason the fandom is horrible to everyone.

                                        Well that was unnecessary, and also inaccurate in my opinion.

                                        1. 27

                                          I have to agree this is inaccurate – I don’t find much of the Suckless software that great.

                                          1. 10

                                            I’d argue in terms of code quality suckless software stands head and shoulders above most stuff. Yesterday I was looking into terminal emulators and very surprised to find that suckless’s st is one of the best in terms of code quality and size. Other emulators like konsole and gnome-terminal just pretty much copy and paste from xterm, but even that is not done correctly, apparently.

                                            Another example of the quality there is dwm, which has inspired clones such as xmonad. That your deliberate misinterpretation of my citation has (at time of writing) received more upvotes than the original article is a sad indicator that some here are apparently more interested in rubbishing suckless than the tech itself.

                                            1. 1

                                              dwm, dmenu, st are their “main” projects, but I’d argue that most of the others have little more to offer than name recognition. For example surf seems unnecessary, since the part with the most complexity, webkit, remains untouched. Nobody (I know of) complaining about the bloat of browsers and the web is annoyed by the UI of the browser itself, but rather the technology behind it.

                                            2. 4

                                              I don’t find much of the Suckless software that great.

                                              Well, that depends on how you define “great”, and what you expected in the software.

                                          1. 9

                                            I’ll be honest: When posting this article, I totally missed the first paragraph. All I wanted was a plan9-like scrollbar in xterm.

                                            1. 2

                                              For the complete experience you also want https://github.com/BarkyTheDog/catclock

                                              1. 3

                                                Compare it with the 300-line catclock.c: https://plan9.io/sources/plan9/sys/src/games/catclock.c

                                            1. 21

                                              …we respect you for it. There’s probably some pity in there too, but honestly, it’s mostly respect.

                                              Haha, nice to know I’m pitied! How extraordinarily condescending! I just write code in my free time because I have nothing better to do really, does this mean I should be pitied?

                                              Not being a dick over being a rockstar

                                              Is writing a piece like this that puts down devs like me considered “dickish” behaviour or not? Just curious…

                                              1. 2

                                                We’re diverse people, we should embrace that. I love the subject of the document, how it exposes some developers to mindsets that might not be their own. The “pity” comment might make the manifesto feel as a cold shower to some, it might give a first impression that divides people rather than getting them to know each other. For this reason, I wouldn’t focus too much on that, rather, I’d focus on how interesting it is to get to know diverse viewpoints.

                                                1. 4

                                                  I tried a similar experiment in 2015, it’s definitely worth trying if never done before. I read more books that year than any previous year, and also more than any year since then. Unlike the author I didn’t have any special setup to supplement my offline experience, with the exception of a collection of Debian CD’s so that I could still install new software via apt.

                                                  1. 4

                                                    Agreed. I prefer desktops but having a nice 12” laptop for travel is great to have. Problem is there isn’t a worthy 12” in the market at the moment and hasn’t been for a long time.

                                                    Question- Why not use a desktop?

                                                    1. 5

                                                      My daily driver is a desktop.

                                                      1. 4

                                                        Depending on workload, an x201 in 2020 may still be viable, I use an x201 as my daily driver and honestly it’s perfect, the only downside is youtube, which eats processor and causes the fan to come on. But I mean the computer cost me £100, can’t exactly complain!

                                                        1. 2

                                                          For me personally, desktops just don’t offer enough advantages to outweigh the fact that they don’t really fit the way I work.

                                                          I’m hoping that the next computer I buy will be some descendant of the Pinebook; portability and battery beat power (almost) every time.

                                                        1. 1

                                                          BuildStream is a much less well known tool attempting to solve similar kinds of problems as nix, I’d argue it’s simpler, but it doesn’t have all the benefits that nix does either.

                                                          1. 4

                                                            A C programmer doesn’t like to use snprintf, mkay. Then he blames Spectre, a CPU bug, on the C programming language, mkay. Then he gives a very contrived example in an attempt to show that shell pipelines are bad, then he makes a bunch of irrelevant political observations, but hey at least he quoted Iain M Bank’s Excession…

                                                            1. 8

                                                              libc

                                                              STATUS: NOT YET

                                                              Uh musl?

                                                              1. 9

                                                                There are many items that can be added here. For example for the base system there’s sbase from suckless; I have no idea why Drew is re-implementing his own?

                                                                • For init system there’s runit, as well as some others like OpenRC (I have no experience with the latter though).
                                                                • C compiler: tcc
                                                                • GUI: fltk
                                                                • Package manager: xbps, pacman
                                                                • Shell: dash, mksh
                                                                • High-level programming: lua is probably the best/simplest here.

                                                                And probably some more … this is just from the top of my head.

                                                                1. 6
                                                                  • cproc is nicer than tcc in my opinion.
                                                                  • janet is nicer than lua in my opinion.

                                                                  But overall I agree.

                                                                  1. 5

                                                                    As the current maintainer of sbase, I’m also a bit confused about the re-implementation of UNIX tools. As far as I can tell, the main design goal differences are:

                                                                    • To not reuse code between utilities, which I think is a mistake. Many tools use the same flags for symlink behavior for recursive operations, have to deal with mode strings in the same way, etc.
                                                                    • To behave randomly when behavior is implementation defined. It is already hard enough to get the rest of the world to work with plain POSIX tools. I’ve spent quite a while making sure sbase works well with various scripts out there, for example building the Linux kernel, and I don’t see the point of making this harder than it needs to be.

                                                                    However, I think the addition of a test suite is great. It’d be neat to see if could be extracted to a standalone project, similar to how libc-test can be used for multiple libc’s.

                                                                    1. 2

                                                                      The first goal to not reuse code is definitely a mistake, but I think that will become clear to them as they write more tools.

                                                                1. 1

                                                                  link is 404 now :(

                                                                  1. 1

                                                                    wonder why they took it down?

                                                                  1. 3

                                                                    hi, keep a legendary game alive, consider playing unreal tournament 2004! :) https://discord.gg/kxAKeZ

                                                                    Ha, one of my all time favourite games!

                                                                      1. 12

                                                                        Even though it seems as though operating system package managers are almost falling out of favor in exchange for a proliferation of language-specific package managers

                                                                        if this is the case it is a mistake and a trend we should work to reverse.

                                                                        To help OS maintainers, keep the software as simple as possible, avoid CMake and autotools if possible, write very simple Makefiles.

                                                                        1. 11

                                                                          I totally agree, especially in regard to Makefiles, and am glad to see that you linked one of ours as an example. We only write Makefiles for all suckless tools and stay away from CMake, autohell or other solutions. This simplicity makes it easy to package software (see Gentoo, Alpine and NixOS as examples).

                                                                          Granted, we keep the scope of our software small, but maybe we should generally question the tendency nowadays to build massive behemoths with tons of dependencies and complex build logic. If you think about it, the reasons why things like autohell exist are not present anymore. 10-20 years ago, the ecosystem was much more diverse, but nowadays, every time I see a configure-script check if my compiler supports trigonometric functions or something, I just shake my head. 99% of configure scripts are copy-pasted from GNU code and they are a huge waste of time and energy. To make matters worse, these configure-scripts effectively prevent me from easily compiling such software on a RaspberryPI (or similar) as it takes so long to run these configure-scripts every time.

                                                                          In contrast to this, a Makefile takes mere seconds, and if you run a more “nonstandard” system, you just change config.mk (example taken from farbfeld) to your needs, but this is not necessary in 99% of the cases.

                                                                          To make it short, @xorhash: Keep it simple! :)

                                                                          1. 6

                                                                            To help OS maintainers, keep the software as simple as possible, avoid CMake and autotools if possible, write very simple Makefiles.

                                                                            This is madness if you intend to support anything other than Linux.

                                                                            1. 3

                                                                              All suckless programs are simple enough that any experienced Unix user should be able to compile them without any Makefile at all. Most can be compiled by just cc -lX11 -lXft -o dwm *.c, or something along those lines.

                                                                              It’s probably not a good solution for, say, Firefox or KDE, but not all software is Firefox or KDE.

                                                                              1. 2

                                                                                The makefile I linked is cross-platform.

                                                                                1. 1

                                                                                  I disagree, the only platform that can’t deal with a simple makefile in my experience is Windows.

                                                                                2. 2

                                                                                  Even though it seems as though operating system package managers are almost falling out of favor in exchange for a proliferation of language-specific package managers

                                                                                  if this is the case it is a mistake and a trend we should work to reverse.

                                                                                  Why is this a mistake?

                                                                                  1. 2

                                                                                    Most language package managers are poorly designed, poorly implemented and modify the system in ways that are not deterministic, not reproducible and cannot be reversed. I’m thinking of pip in particular, but I believe npm suffers from similar issues as well. If we want something inbetween OS package managers and language package managers then probably something like Nix is required.

                                                                                    1. 1

                                                                                      I don’t think it’s a mistake. Only 1% of open source components are packaged on a distro like Debian. Best chance to have a packaged ecosystem is CPAN and that hovers between 10-15%. Distros aren’t in that business anymore. What OS package managers should do is deliver native packaged and be good stewards of the rest of the software in the system. For example, making apt “npm aware” so that apt can singly emit a package install operation even if it was triggered by npm locally.

                                                                                    2. 1

                                                                                      It doesn’t take much for simple Makefiles to not scale. Try adding a dependency on something as basic as iconv or curses while remaining portable. Autoconf is not as bad as all that and is common enough that any OS packager will know how to deal with it. I’m rather less fond of libtool, though.

                                                                                      1. 1

                                                                                        I maintain a project that has iconv as a dependency, the Makefile supports Linux and the BSDs, trivially.

                                                                                        edit: disambiguate

                                                                                    1. 7

                                                                                      Politics and software are so tangled that they cannot be reasonably separated.

                                                                                      I reject this, my test running framework is not political, nor are basically any of the tools I’ve written in my free time.

                                                                                      1. 1

                                                                                        I think this notion that “everything is political” is fascinating. I’d love someone to explain it to me in a way that I understand.

                                                                                        1. 1

                                                                                          If someone thinks that the OP’s test running framework is actually harmful and needs to be altered or shut down - maybe because it doesn’t check if ICE is running it and is therefore complicit with enforcing American immigration law, maybe because it is closed source software and supporting companies that produce closed-source software is immoral, maybe it is in opposition to the text of the Quran and is therefore heretical, any number of reasons that someone might have - then continuing to use it to test software in spite of vocal opposition is political. “Political” doesn’t mean “bad”, it means that some people somewhere think it’s bad when you don’t.

                                                                                          1. 1

                                                                                            “Political” doesn’t mean “bad”, it means that some people somewhere think it’s bad when you don’t.

                                                                                            Aha, then I agree that everything is “political” by that definition. But is that what they really mean?

                                                                                            1. 1

                                                                                              I find this idea to be completely absurd, it’s like saying that the authors GNU coreutils are guilty of murder because some targetting program on a guided missile uses ls at some point. The fact that a guided missile uses GNU coreutils doesn’t make listing the contents of a directory political.

                                                                                              1. 2

                                                                                                No, but the people behind the license in this article do think that the GPL itself is bad, precisely because it doesn’t allow you to legally prevent someone from using GNU coreutils on a guided missile (or in this case, doesn’t allow you to legally prevent your software from being used by a law enforcement body that enforces laws in a way you don’t like - it’s pretty clear that this license is aimed at ICE specifically). That is political, just as the GPL itself is political.

                                                                                                1. 1

                                                                                                  You’re right that the GPL can be considered political, this isn’t the point I’m rejecting. The point I’m rejecting is this:

                                                                                                  Politics and software are so tangled that they cannot be reasonably separated.

                                                                                                  As I have already shown, this point is demonstrably false.

                                                                                        1. 1

                                                                                          So, just for hiding your own karma in the navbar?

                                                                                          1. 3

                                                                                            If I understood the idea correctly, it means showing the votes on each comment for instance one hour after the comment was posted.

                                                                                            1. 4

                                                                                              Isn’t karma display already hidden for a while on comments, until a certain period of time has passed or they hit some vote threshold?

                                                                                              Seems like it

                                                                                              1. 1

                                                                                                You could do both?

                                                                                                1. 1

                                                                                                  Just to be clear–is this for your own comments, or for others’ comments as well?

                                                                                                  1. 1

                                                                                                    I was thinking just for your own comments yes

                                                                                                    1. 2

                                                                                                      So, if it’s just for a user’s own comments, you could probably open an issue. My impression is that meta threads are usually more for features that would effect others or significantly change community dynamics–your proposed feature seems to be rather modest in that regard.

                                                                                                      1. 2

                                                                                                        I guess I’ve essentially opened the issue by posting here, if anyone thinks it’s a good idea it’ll get implemented.

                                                                                                        I’ll bear what you’ve said in mind for future post though thanks.

                                                                                            1. 2

                                                                                              Has anyone else looked at the code? How does https://github.com/naasking/async.h/blob/master/async/async.h accomplish this? Is today April fool’s day or something?

                                                                                              1. 3
                                                                                                1. 2

                                                                                                  It is a coroutines implementation with a selector based on Duff’s device, all wrapped into a few macros. That’s why you can’t use switch statements in these async bodies.

                                                                                                  1. 1

                                                                                                    Yeah, it’s pretty clever!

                                                                                                    Is there any way to recover the use of switch statements? At first, I thought you could insert braces into the macros, but I’m not sure if that would work.

                                                                                                1. 15

                                                                                                  I’m so glad I stopped using Linux after Systemd took over.

                                                                                                  1. 12

                                                                                                    For me, systemd is actually the reason why I cannot stand Free/OpenBSD anymore. I don’t want to see another shell script for controlling important system software that might or might not work. Perhaps one of these days, OpenBSD pulls a typical OpenBSD move and some cool hacker reimplements the best parts of systemd (mostly the service administration really) into a single cohesive package.

                                                                                                    1. 4

                                                                                                      Funny because systemd and the pulseaudio situation with firefox are two of the reasons I switched from GNU/Linux to OpenBSD.

                                                                                                      1. 1

                                                                                                        pulseaudio situation with firefox

                                                                                                        Mind elaborating on that? I use both and haven’t had any problems in years.

                                                                                                        1. 2

                                                                                                          Firefox no longer supports ALSA. ALSA has been fine for me for the past 14 years. I was unwilling to install pulseaudio and unwilling to switch to Chromium, so I moved to OpenBSD.

                                                                                                        2. 1

                                                                                                          There was a while ago when pulse audio and its Gnome controllers were shit and then it got good and I could just remote play or remote source really neatly and then that went away and I can only do normal stuff and it’s honestly kind of painless now.

                                                                                                        3. 1

                                                                                                          I quite enjoy having my boot process be shell-based. I regularly ^T it for information or ^C if I can’t be bothered to wait for something.

                                                                                                        4. 4

                                                                                                          What do you use now? What are the tradeoffs you had to make?

                                                                                                          1. 2

                                                                                                            I use Open, Net and FreeBSD as alternatives. For desktop and some server stuff I’ve used MacOS for a while. I’ve been using FreeBSD for a long time, and Open and Net on and off, but Systemd caused me so many problems that I’m almost completely off Linux. I have the odd throwaway VM here and there, and two hosts left running docker, one of which is going to be replaced with FreeBSD, the other retired.

                                                                                                            I probably should’ve been clearer - I don’t use Systemd encumbered Linux as a primary OS anymore for anything important, and took steps to reduce the amount of Linux. Of course my phone is Android, so I’m still using Linux in some capacity.

                                                                                                            The one tradeoff I’ve had to make with OpenBSD is that a lot of things are written for Linux, and because OpenBSD tends to do things in a more correct manner, things that don’t check to see something is there (e.g. /proc) tend to break. FreeBSD has better compatibility. On the other hand, OpenBSD is as rock solid stable as Debian used to be, which isn’t an indictment of Debian but really kudos to OpenBSD.

                                                                                                            I have been surprised at just how good OpenBSD is as a daily driver Laptop. I use an X230 thinkpad with a custom BIOS and X220 keyboard as a personal laptop, and it’s really nice to use.

                                                                                                        1. 15

                                                                                                          Getting kind of tired of these thinly-veiled off-topic political posts to be quite honest, we’ve had a few of them now. Stick to technology, take your unwanted political views to hacker news.

                                                                                                          1. 13

                                                                                                            Ah yes, agreed! Technology is the first known example of Plato’s Perfect Forms. Technology exists on its own abstract, perfect realm that trancends space and time and has no relevance to anything happening in this physical reality.

                                                                                                            Stick to technology, I say! And no funny human business!

                                                                                                            1. 8

                                                                                                              It’s fine to flag as off-topic and hide the submission so it doesn’t bother you.

                                                                                                              While this particular instance and article deals with a current hot-button political issue, the current structure of open source is vulnerable to this sort of disruption. See my comment here, and this comment by @chobeat.

                                                                                                            1. 23

                                                                                                              I think people rely on JavaScript too much. With sourcehut I’m trying to set a good example, proving that it’s possible (and not that hard!) to build a useful and competitive web application without JavaScript and with minimal bloat. The average sr.ht page is less than 10 KiB with a cold cache. I’ve been writing a little about why this is important, and in the future I plan to start writing about how it’s done.

                                                                                                              In the long term, I hope to move more things out of the web entirely, and I hope that by the time I breathe my last, the web will be obsolete. But it’s going to take a lot of work to get there, and I don’t have the whole plan laid out yet. We’ll just have to see.

                                                                                                              I’ve been thinking about this a lot lately. I really don’t like the web from a technological perspective, both as a user and as a developer. It’s completely outgrown its intended use-case, and with that has brought a ton of compounding issues. The trouble is that the web is usually the lowest-common-denominator platform because it works on many different systems and devices.

                                                                                                              A good website (in the original sense of the word) is a really nice experience, right out of the box. It’s easy for the author to create (especially with a good static site generator), easy for nearly anyone to consume, doesn’t require a lot of resources, and can be made easily compatible with user-provided stylesheets and reader views. The back button works! Scrolling works!

                                                                                                              Where that breaks down is with web applications. Are server-rendered pages better than client-rendered pages? That’s a question that’s asked pretty frequently. You get a lot of nice functionality for free with server-side rendering, like a functioning back button. However, the web was intended to be a completely stateless protocol, and web apps (with things like session cookies) are kind of just a hack on top of that. The experience of using a good web app without JavaScript can be a bit of a pain with many different use cases (for example, upvoting on sites like this: you don’t want to force a page refresh, potentially losing the user’s place on the page). Security is difficult to get right when the server manages state.

                                                                                                              I’ll argue, if we’re trying to avoid the web, that client-side rendering (single-page apps) can be better. They’re more like native programs in that the client manages the state. The backend is simpler (and can be the backend for a mobile app without changing any code). The frontend is way more complex, but it functions similarly to a native app. I’ll concede poorly-built SPA is usually a more painful experience than a poorly-built SSR app, but I think SPAs are the only way to bring the web even close to the standard set by real native programs.

                                                                                                              Of course, the JavaScript ecosystem can be a mess, and it’s often a breath of fresh air to use a site like Sourcehut instead of ten megs of JS. The jury’s still out as to which approach is better for all parties.

                                                                                                              1. 11

                                                                                                                (for example, upvoting on sites like this: you don’t want to force a page refresh, potentially losing the user’s place on the page)

                                                                                                                Some of the UI benefits of SPA are really nice tbh. Reddit for example will have a notification icon that doesn’t update unless you refresh the page, which can be annoying. It’s nice when websites can display the current state of things without having to refresh.

                                                                                                                I can’t find the video, but the desire for eliminating stale UI (like outdated notifications) in Facebook was one of the reasons React was created in the first place. There just doesn’t seem to be a way to do things like that with static, js-free pages.

                                                                                                                The backend is simpler (and can be the backend for a mobile app without changing any code).

                                                                                                                I never thought about that before, but to me that’s a really appealing point to having a full-featured frontend design. I’ve noticed some projects with the server-client model where the client-side was using Vue/React, and they were able to easily make an Android app by just porting the server.

                                                                                                                The jury’s still out as to which approach is better for all parties.

                                                                                                                I think as always it depends. In my mind there are some obvious choices for obvious usecases. Blogs work great as just static html files with some styling. Anything that really benefits from being dynamic (“reactive” I think is the term webdevs use) confers nice UI/UX benefits to the user with more client-side rendering.

                                                                                                                I think the average user probably doesn’t care about the stack and the “bloat”, so it’s probably the case that client-side rendering will remain popular anytime it improves the UI/UX, even if it may not be necessary (plus cargo-culting lol). One could take it to an extreme and say that you can have something like Facebook without any javascript, but would people enjoy that? I don’t think so.

                                                                                                                1. 17

                                                                                                                  But you don’t need to have a SPA to have notifications without refresh. You just need a small dynamic part of the page, which will degrade gracefully when JavaScript is disabled.

                                                                                                                  Claim: Most sites are mostly static content. For example, AirBNB or Grubhub. Those sites could be way faster than they are now if they were architected differently. Only when you check out do you need anything resembling an “app”. The browsing and searching is better done with a “document” model IMO.

                                                                                                                  Ditto for YouTube… I think it used to be more a document model, but now it’s more like an app. And it’s gotten a lot slower, which I don’t think is a coincidence. Netflix is a more obvious example – it’s crazy slow.

                                                                                                                  To address the OP: for Sourcehut/Github, I would say everything except the PR review system could use the document model. Navigating code and adding comments is arguably an app.

                                                                                                                  On the other hand, there are things that are and should be apps: Google Maps, Docs, Sheets.


                                                                                                                  edit: Yeah now that I check, YouTube does the infinite scroll thing, which is slow and annoying IMO (e.g. breaks bookmarking). Ditto for AirBNB.

                                                                                                                  1. 3

                                                                                                                    I’m glad to see some interesting ideas in the comments about achieving the dynamism without the bloat. A bit of Cunningham’s law in effect ;). It’s probably not easy to get such suggestions elsewhere since all I hear about is the hype of all the fancy frontend frameworks and what they can achieve.

                                                                                                                    1. 8

                                                                                                                      Yeah SPA is a pretty new thing that seems to be taking up a lot of space in the conversation. Here’s another way to think about it.

                                                                                                                      There are three ways to manage state in a web app:

                                                                                                                      1. On the server only (what we did in the 90’s)
                                                                                                                      2. On the server and on the client (sometimes called “progressive enhancement”, jQuery)
                                                                                                                      3. On the client only (SPA, React, Elm)

                                                                                                                      As you point out, #1 isn’t viable anymore because users need more features, so we’re left with a choice between #2 and #3.

                                                                                                                      We used to do #2 for a long time, but #3 became popular in the last few years.

                                                                                                                      I get why! #2 is is legitimately harder – you have to decide where to manage your state, and managing state in two places is asking for bugs. It was never clear if those apps should work offline, etc.

                                                                                                                      But somehow #3 doesn’t seem to have worked out in practice. Surprisingly, hitting the network can be faster than rendering in the browser, especially when there’s a tower of abstractions on top of the browser. Unfortunately I don’t have references at the moment (help appreciated from other readers :) )

                                                                                                                      I wonder if we can make a hybrid web framework for #2. I have seen a few efforts in that direction but they don’t seem to be popular.


                                                                                                                      edit: here are some links, not sure if they are the best references:

                                                                                                                      https://news.ycombinator.com/item?id=13315444

                                                                                                                      https://adamsilver.io/articles/the-disadvantages-of-single-page-applications/

                                                                                                                      Oh yeah I think this is what I was thinking of. Especially on Mobile phones, SPA can be slower than hitting the network! The code to render a page is often bigger than the page itself! And it may or may not be amortized depending on the app’s usage pattern.

                                                                                                                      https://medium.com/@addyosmani/the-cost-of-javascript-in-2018-7d8950fbb5d4

                                                                                                                      https://news.ycombinator.com/item?id=17682378

                                                                                                                      https://v8.dev/blog/cost-of-javascript-2019

                                                                                                                      https://news.ycombinator.com/item?id=20317736

                                                                                                                      1. 3

                                                                                                                        A good example of #2 is Ur/Web. Pages are rendered server-side using templates which looks very similar to JSX (but without the custom uppercase components part) and similarly desugars to simple function calls. Then at any point in the page you can add a dyn tag, which takes a function returning a fragment of HTML (using the same language as the server-side part, and in some cases even the same functions!) that will be run every time one of the “signals” it subscribes to is triggered. A signal could be triggered from inside an onclick handler, or even from an even happening on the server. This list of demos does a pretty good job at showing what you can do with it.

                                                                                                                        So most of the page is rendered on the server and will display even with JS off, and only the parts that need to be dynamic will be handled by JS, with almost no plumbing required to pass around the state: you just need to subscribe to a signal inside your dyn tag, and every time the value inside changes it will be re-rendered automatically.

                                                                                                                        1. 2

                                                                                                                          Thanks a lot for all the info, really helpful stuff.

                                                                                                                      2. 5

                                                                                                                        Reddit for example will have a notification icon that doesn’t update unless you refresh the page, which can be annoying. It’s nice when websites can display the current state of things without having to refresh.

                                                                                                                        On the other hand, it can be annoying when things update without a refresh, distracting you from what you were reading. Different strokes for different folks. Luckily it’s possible to fulfill both preferences, by degrading gracefully when JS is disabled.

                                                                                                                        I think the average user probably doesn’t care about the stack and the “bloat”, so it’s probably the case that client-side rendering will remain popular anytime it improves the UI/UX, even if it may not be necessary (plus cargo-culting lol).

                                                                                                                        The average user does care that browsing the web drains their battery, or that they have to upgrade their computer every few years in order to avoid lag on common websites. I agree that we will continue see the expansion of heavy client-side rendering, even in cases where it does not benefit the user, because it benefits the companies that control the web.

                                                                                                                        1. 1

                                                                                                                          Some of the UI benefits of SPA are really nice tbh. Reddit for example will have a notification icon that doesn’t update unless you refresh the page, which can be annoying. It’s nice when websites can display the current state of things without having to refresh.

                                                                                                                          Is this old reddit or new reddit? The new one is sort of SPA and I recall it updating without refresh.

                                                                                                                          1. 3

                                                                                                                            Old reddit definitely has the issue I described, not sure about the newer design. If the new reddit doesn’t have that issue, that aligns with my experience of it being bloated and slow to load.

                                                                                                                        2. 12

                                                                                                                          example, upvoting on sites like this: you don’t want to force a page refresh, potentially losing the user’s place on the page

                                                                                                                          There are lots of ways to do this. Here’s two:

                                                                                                                          1. You can use an iframe for the upvote link, and have the state change just reload the frame.
                                                                                                                          2. If you don’t need feedback, you can also use a button with a target= to a hidden iframe.

                                                                                                                          Security is difficult to get right when the server manages state.

                                                                                                                          I would’ve thought the exact opposite. Can you explain?

                                                                                                                          1. 7

                                                                                                                            In the case where you have lots of buttons like that isn’t loading multiple completely separate doms and then reloading one or more of them somewhat worse than just using a tiny bit of js? I try to use as little as possible but I think that kind of dynamic interaction is the use case js originally was made for.

                                                                                                                            1. 7

                                                                                                                              Worse? Well, iframes are faster (marginally), but yes I’d probably use JavaScript too.

                                                                                                                              I think most NoScript users will download tarballs and run ./configure && make -j6 without checking anything, so I’m not sure why anyone wants to turn off JavaScript anyway, except for maybe because adblockers aren’t perfect.

                                                                                                                              That being said, I use NoScript…

                                                                                                                            2. 4

                                                                                                                              I’m not sure if this would work, but an interesting idea would be to use checkboxes that restyle when checked, and by loading a background image with a query or fragment part, the server is notified of which story is upvoted.

                                                                                                                              1. 2

                                                                                                                                That’d require using GET, which might be harder to prevent accidental upvotes. Could possibly devise something though.

                                                                                                                            3. 4

                                                                                                                              One thing I really miss with SPA’s (when used as apps), aside from performance, is the slightly more consistent UI/UX/HI that you generally get with desktop apps. Most major OS vendors, and most oss desktop toolkits, at least have some level of uniformity of expectation. Things like: there is a general style for most buttons and menu styles, there are some common effects (fade, transparency), scrolling behavior is more uniform.

                                                                                                                              With SPAs… well, good luck! Not only is it often browser dependent, but matrixed with a myriad JS frameworks, conventions, and render/load performance on top of it. I guess the web is certainly exciting, if nothing else!

                                                                                                                              1. 3

                                                                                                                                I consider the “indented use-case” argument a bit weak, since for the last 20 years web developers, browser architects and our tech overlords have been working on making it work for applications (and data collection), and to be honest it does so most of the time. They can easily blame the annoyances like pop-ups and cookie-banners on regulations and people who use ad blockers, but from a non technical perspective, it’s a functional system. Of course when you take a look underneath, it’s a mess, and we’re inclined to say that these aren’t real websites, when it’s the incompetence of our operating systems that have created the need to off-load these applications to a higher level of abstraction – something had to do it – and the web was just flexible enough to take on that job.

                                                                                                                                1. 4

                                                                                                                                  You’re implying it’s Unix’s fault that the web is a mess but no other OS solved the problem either? Perhaps you would say that Plan 9 attempted to solve part of it, but that would only show that the web being what it is today isn’t solely down to lack of OS features.

                                                                                                                                  I’d argue that rather than being a mess due to the incompetence of the OS it’s a mess due to the incremental adoption of different technologies for pragmatic reasons. It seems to be this way sadly, even if Plan 9 was a better Unix from a purely technological standpoint Unix was already so widespread that it wasn’t worth putting the effort in to switch to something marginally better.

                                                                                                                                  1. 7

                                                                                                                                    No, I don’t think Plan 9 would have fixed things. It’s still fundamentally focused on text processing, rather than hypertext and universal linkability between objects and systems – ie the fundamental abstractions of an OS rather than just it’s features. Looking at what the web developed, tells us what needs were unformulated and ultimately ignored by OS development initiatives, or rather set aside for their own in-group goals (Unix was a research OS after all). It’s most unprobable that anyone could have foreseen what developments would take place, and even more that anyone will be able to fix them now.

                                                                                                                                2. 2

                                                                                                                                  From reading the question of the interviewer I get the feeling that it’s easy for non technical users to create a website using wordpress. Adding many plugins most likely leads to a lot of bloaty JavaScript and CSS.

                                                                                                                                  I would argue that it’s a good thing that non technical users can easily create website but the tooling to create it isn’t ideal. For many users a wysiwyg editor which generates a static html page would be fine but such a tool does not seem to exists or isn’t known.

                                                                                                                                  So I really see this as a tooling/solution problem, which isn’t for users to solve but for developers to create an excellent wordpress alternative.

                                                                                                                                  1. 2

                                                                                                                                    I am not affiliated to this in any way but I know of https://forestry.io/ which looks like what you describe. I find their approach quite interesting.

                                                                                                                                  2. 0

                                                                                                                                    for example, upvoting on sites like this: you don’t want to force a page refresh, potentially losing the user’s place on the page)

                                                                                                                                    If a user clicks a particular upvote button, you should know where on that page it is located, and can use a page anchor in your response to send them back to it.

                                                                                                                                    1. 1

                                                                                                                                      It’s not perfectly seamless, sadly, and it’s possible to set up your reverse proxy incorrectly enough to break applications relying on various http headers to get exactly the right page back.