1. 2

    I remember when Google killed their RSS aggregator, Google Reader. Tons of new RSS aggregators popped up to fill the new gap. I wouldn’t be surprised if someone decided to implement a Chrom{e,ium} sync service that peeps can use.

    1. 7

      The difference is that RSS is a standard. Meanwhile, the protocol Chrome uses for sync is proprietary, and they can change it anytime, and an alternative server would have to keep up. In the end, you end up needing to fork the browser.

      1. 2

        Brave has re-implemented the server in go. Vanilla chromium can’t use it IIRC because the server forces client-side encryption and the client doesn’t know what to do.

      1. 19

        Atlassian uses GitHub for all its projects. I think it keeps Bitbucket for existing customers that still pay but probably ships no features as it’s a waste of time. I am always surprised how so many companies still use Atlassian when for every single product they have, a better alternative exists.

        1. 8

          Jira is the most configurable issue tracker i know.

          Confluence is the best wysiwyg wiki i know.

          For Bitbucket I’m not sure, but it might also win for configurability.

          1. 28

            Jira is the most configurable issue tracker i know.

            That’s why it’s so bad. It makes busywork a full time job.

            1. 5

              An old go-to joke of mine is that I’d like to work at Atlassian for a year just to see the world’s only correctly-configured Jira install.

              1. 2

                I dunno. A lot of other tooling assumes a lot about workflows that you might not think about because it suits your workflow. I work in the games industry at a small shop. The server team, web team, gameplay teams, QA teams, art teams, content writing teams, and translation teams all have very different workflows, so the configurability is helpful. We have a yearly release cycle so we tweak the Jira workflows about once a year. But we also use BitBucket and it does indeed suck a whole lot, as does Confluence.

              2. 11

                How configurable do you need your issue management to be? Linear does pretty much everything one may need for issue tracking and does it fast.

                For Confluence, I had personal bad experience where I dreaded adding content to it because of its wysiwyg editor amongst horrible search and again super slow UI.

                Things may have changed though.

                1. 5

                  Linear is probably great for software projects. I think Jira is used much more broadly to track any given process in enterprises.

                  1. 2

                    Yes, JIRA is also used basically as a project management toolkit that goes beyond issue tracking. Epics, boards, service tickets are all things I’ve seen used at a huge international corporation.

                    That doesn’t mean it’s good, just what it’s used for. I think GitLab does a lot of this stuff.

                  2. 2

                    It isn’t just about issue management being configurable, it’s also about reporting and statistics-collecting being configurable. If your boss wants this report done this way, helping them deal with disappointment isn’t always the optimal answer, and Enterprise Software is Middle-Management-Ware first and foremost.

                    1. 1

                      Linear doesn’t even have on-premise installs, does it?

                      1. 1

                        Atlassian is phasing out on-premise installs of Jira.

                        https://www.atlassian.com/blog/announcements/journey-to-cloud

                        On February 2, 2021 Pacific Time (PT), the following changes will go into effect:

                        • End of new server license sales: You can no longer purchase or request a quote for a new server product.
                        • Updates to server prices: We will implement new prices for server renewals and upgrades.

                        On February 2, 2024 PT, the following change will go into effect:

                        • End support for all server products: This means that support and bug fixes will no longer be available for your server products.
                        1. 1

                          Have a guess why people using Jira are looking at alternatives that have a comparable feature set, one of the features being on-premise installs.

                          1. 1

                            My point exactly.

                    2. 6

                      Does anyone have any recommendations for issue management that aren’t online-only? We’re using Jira now, but since Atlassian has decided to stop developing the on-premises variant we’re in need of something new (eventually, we’ve got a couple of years to transition).

                      Both Asana and Linear (which got recommended in this thread) seem to be online only.

                      1. 2

                        there’s always bugzilla…

                        1. 3

                          Upstream Bugzilla is very far from the nice experience you get on bugzilla.mozilla.org though. You have to work a lot to get it to be not really ugly.

                        2. 1

                          Why do you guys need on-prem? Regulatory issues?

                          1. 7

                            We’d like to keep our secrets where we can see them, I suppose.

                            Edit: and also not be auto-updated to newer versions of a tool that could mess up our internal workflow with no chance of going back to a version that worked the way we liked it. Or have the provide go out of business. Or other similar issues.

                            1. 1

                              Redmine?

                            2. 4

                              Yes. Storing critical data on other peoples’ computers is simply not an option.

                              1. 4

                                Amen. It’s nice to use other peoples’ computers sometimes, for “unimportant” things. (Scare quotes used there, because I include things that are only unimportant owing to careful contingency planning that makes it so in that bucket.)

                                But for critical, core things, the question should be “what have you done to make it OK for this to live in the cloud?” Not “why do you need on-prem?”

                                1. 3

                                  I used to work in a place where adopting new tools was pretty straightforward if you needed them, but they required a reasonable bit of planning ahead, after the company got burned many years before when a software package they used got retired and a whole product line got delayed because there was no way to test them on time. There was a small sub-section in the proposal that read “Migration Path” and basically required you to list how you’d move to another solution should the current one stop working for whatever reason (company goes under, licensing costs become prohibitive etc.) Due to that sub-section the company was basically fully on-prem.

                                  When the expected lifetime of a company is in the 3-5 years range (ship something, get acquired) you can use pretty much anything from anywhere, but these guys had been in business for a very long time. They’d outlived virtually all of their suppliers, sometimes by decades.

                                  1. 1

                                    Same story here. Dropping/rejecting a lot of dependencies based on “we are unsure whether this stuff will exist in 20 years/built by Google”.

                            3. 1

                              My team is also looking into alternatives to JIRA and also wants to keep it on-prem. I would be curious as well as to what solutions others come up with.

                              1. 2

                                Paid GitLab? We use it even as an internal forum.

                                1. 1

                                  We actually are already using paid gitlab on prem. Not sure if thats being considered.

                              2. 1

                                Fossil might be worth a look? It’s from the SQLite folks I think.

                                https://www.fossil-scm.org/

                                (It does a lot more than issue tracking though.)

                              3. 1

                                Jira is the most configurable issue tracker i know.

                                I recommend to check out Asana. It comes pretty close.

                                1. 1

                                  Asana doesn’t even have on-premise installs, does it?

                                    1. 0

                                      Did you click on the link?

                                      (Assuming you did, guess why people using Jira are looking at alternatives with a comparable feature set, one of the features being on-premise installs?)

                                      1. 1

                                        Because Jira’s UX sucks. Which is what the submission is about. Except it’s about Bitbucket.

                                        I get the point you’re making but self-hostedness didn’t come up so far in this thread. Only UX and flexibility.

                                        So if this is a requirement for you that’s fine and I acknowledge you can’t use Asana. Just stop implying I did not read the submission or am missing the point of the discussion.

                                        1. 2
                                          1. 3

                                            self-hostedness didn’t come up so far in this thread

                                            Let me rephrase: I was responding to a poster that did not bring up self-hosted as requirement or apprechiated feature. I would not respond to a statement about Jira being the most configurable issue tracker if I didn’t consider Asana to be comparable in that regard.

                              4. 2

                                The hosted version of bitbucket (as opposed to bb server which is a completely separate thing for self hosting) is surely on life support at this point.

                                Then again, I think it’s hard to say it’s ever not been on life support, with issues like this one being open 10 years without even commitment to implement, much less actual implementation.

                                1. 4

                                  For a while BitBucket offered some pretty decent competition to GitHub; for example the whole “copying code” thing from this article was pretty borked on GitHub too up until 2 or 3 years ago. Even though BitBucket was always a “GitHub clone” some features were done better in BitBucket IMHO. It had stuff like proper code reviews way before GitHub had.

                                  But at some point it was pretty clear GitHub was on the winning side and they seemed to have just given up. Some features even regressed and became worse. It’s a shame in way, because it had a lot of potential and could have been what GitLab is today. The Atlassian acquirement was both a blessing and a curse, but ultimately more curse than blessing.

                              1. 30

                                Over the summer I started dabbling in GTK3. I made the mistake of looking at pretty much every ‘GTK3 tutorial’ on the internet, almost all of them involve Glade. After ending up with something not working 100% of the time, I jumped on IRC, was told:

                                • basically exactly what was written about here (don’t use glade)

                                • don’t use the ‘official’ GTK ‘tutorial’ docs/blog posts, they’re outdated/not functional

                                • only use gnome-builder

                                • reference the source code for 3-4 gnome app projects for information on how to use the API (including how to use/structure xml UI portion)

                                I hope they do some deep soul searching soon.

                                1. 10

                                  Agreed. The article is the usual “GTK devs broke things and blame other people for it” we saw for years.

                                  1. 3

                                    I wonder if the situation is significantly better at the kde side. QT stuff looks a bit more… Product oriented.

                                    1. 9

                                      I maintain a 10 year old Qt project and it compiles pretty much like it did when the project started. I think that in those ten years I have replaced a handful of lines because a method was deprecated. In all those cases, the documentation pointed me to the right replacements (the Qt documentation is really good compared to Gtk+). Also, even without replacing those calls to deprecated methods, the program would still compile fine (I guess they are removed in Qt6?).

                                      A year ago I had to make a nice, presentable UI for some work project that we wrote in Rust. Since the only functional GUI toolkit for Rust is Gtk+ (through the excellent gtk-rs binding), I wrote the first version with Gtk+. Gtk+ felt very archaic. Glade (yes, we shouldn’t use it, but who wants to write XML by hand) was very primitive compared to Qt Designer. Many of the APIs felt primitive and hard to extend (it’s easy to subclass widgets in Gtk an make your own flavors). And many things were not described in the documentation and I found the answers by digging through old mailing list discussions.

                                      Another issue is that you should probably only use Gtk+ if you target X11 or Wayland. Gtk+ is unbearably slow on e.g. macOS and does not integrate at all.

                                      At any rate, the whole experience was so miserable that I ended up making a Python binding and used PyQt to write the GUI, which was very pleasant. As a bonus, the application worked well on macOS and Windows as well and look and feel nearly native.

                                      1. 9

                                        Another issue is that you should probably only use Gtk+ if you target X11 or Wayland. Gtk+ is unbearably slow on e.g. macOS and does not integrate at all.

                                        GTK+ also has zero accessibility support on Windows and Mac. So some users would be completely blocked from using your application.

                                        1. 2

                                          I am having similar experience with qt, and wondering why developer still working with gtk, a much worse competitor of qt.

                                          1. 5

                                            For me it’s GStreamer and C bindings with GObject introspection.

                                            1. 3

                                              Most likely licensing issues.

                                              1. 6

                                                I thought the gtk/qt license wars were over a long time ago and QT is now GPL + LGPL (with the option to purchase commercial if you don’t want to have to abide by GPL/LGPL).

                                                That seems to offer strictly more options than GTK?

                                                1. 3

                                                  See, I was still in the licensing war mindset. I’d missed that Qt has resolved the outstanding questions with regards to their licensing.

                                              2. 1

                                                in a word, bindings. gtk works with a ton of languages.

                                            2. 2

                                              I can’t say about KDE specifically (KDE Frameworks are a thing and I haven’t used them in… uh, when was KDE 3.3 again?) but yeah, things are way, way better on the Qt side of things. Qt is very thoroughly documented, there are plenty of examples. When something gets deprecated, you usually know well in advance, and you generally have at least one migration path when the deprecation happens (I can’t describe how GTK does that because I inevitably descend into rage and snark, sorry). As with any large (partly) commercial codebase bugs do sometimes get ignored for a long time, especially in the Widgets, but in my experience, the “here’s a bug – this is not a bug” dance is very infrequent.

                                              This is mostly a general experience, of course. There are exceptions (things that get deprecated too soon/without adequate replacements/without a proper announcements etc.) but they’re rare.

                                              I’ve used both and between 2007 and 2020 (and especially in the GTK 3 age) my attitude towards GTK has slowly gone from “either GTK or Qt is fine, just pick the one you like and maybe the one that matches the DE most of your users prefer” to “I wouldn’t touch this even if you paid me to”.

                                        1. 1

                                          I was thinking recently, why didn’t MS implement NetBSD instead? They could have used the kernel headers directly (no need to comply with GPL), and the stark majority of the software that’s of interest for “Linux” developers runs on it as well.

                                          1. 4

                                            Because Linux has cachet, and BSDs don’t.

                                            1. 1

                                              It would be interesting to know whether NetBSD was approached for this.

                                              1. 1

                                                WSL is ABI compatible with Linux. You download a distribution that Microsoft doesn’t directly author, such as Ubuntu, and run those exact same programs on a drop in replacement kernel. The issue with doing anything such as NetBSD is it implies software needs to be recompiled for the environment. That starts to offer an experience similar to cygwin, where somebody needs to manage a repository of ported packages and be continually submitting upstream patches to programs that make Linux specific assumptions. This is basically the experience on macOS. The hope of WSL was to go one better and provide compatibility without needing things to be explicitly ported to it.

                                                1. 2

                                                  WSL is ABI compatible with Linux.

                                                  If you mean WSL1, then yes, but until it doesn’t. And the goalpost is moving with each new flag / syscall / ioctl / netlink option.

                                                  The issue with doing anything such as NetBSD is it implies software needs to be recompiled for the environment

                                                  Well, yes, but NetBSD has pkgsrc, and it’s not exactly a bare repository. And it runs on macOS too. Free work to profit off to!

                                                  EDIT: My point is that long-term WSL1 is unsustainable w/o Windows 10 Mobile using the same mechanism for Android compat. That ship has sailed, and so have the resources for re-impl of the linux ABI. WSL2 is the correct solution for Linux ABI compat.

                                                1. 5

                                                  My first question was indeed “why not Linux”. This is also the thread that answers that: The author made AppImage and did not feel that the Linux community accepted this.

                                                  1. 5

                                                    Been there: Got constant sh*t from the Linux community for pushing the idea of application bundles, err, AppImages (think .app inside a .dmg).

                                                    And yet, the whole premise of Fedora Silverblue is: you get a lean immutable base system, install applications through Flatpak containers, do development in containers.

                                                    The Linux community is large and has many different subcommunities. Many dislike the idea of application bundles/images, but the Red Hat, Fedora, and GNOME folks (which are partially overlapping) seem to be actively pushing this idea. I am sure once they get this going there are also FreeBSD conservatives who will say that application bundles are not the way of Unix.

                                                    Just pick the technology that is best for your vision and ignore the critics.

                                                    1. 2

                                                      FWIW FreeBSD had app bundles years ago in form of AppCafe.

                                                  2. 2

                                                    something Linux lacks for the most part because everything is so encapsulated and “distro-ified “that it’s not even clear how to build your own images, much less random pieces of the kernel and userland from one convenient, browsable location like FreeBSD still has

                                                    Guix and NixOS like to have a word with him ;).

                                                  1. 11

                                                    I wonder what they’re going to do for Mac Pro class of hardware.

                                                    Trying to fit more RAM, more CPU cores, and a beefier GPU all into one package doesn’t seem realistic, especially that one-size-fits-all chip isn’t going to make sense for all kinds of pro uses.

                                                    1. 7

                                                      It’s going to be interesting to see what they do (if anything at all) with a 250W TDP or so. Like, 64? 128? 196 cores? I’m also interested in seeing how they scale their GPU cores up.

                                                      1. 2

                                                        Trying to fit more RAM, more CPU cores, and a beefier GPU all into one package doesn’t seem realistic

                                                        I have heard this repeatedly from various people – but I don’t have any idea why this would be the case. Is there an inherent limit in SOC package size?

                                                        1. 2

                                                          There’s NUMA, though Darwin doesn’t support that right now I think.

                                                          1. 2

                                                            Darwin does support the trashcan Mac Pros, right? They have two CPUs, and that’s a bona fide NUMA system.

                                                            1. 3

                                                              Trashcan Mac Pros (MacPro6,1) are single CPU - it’s the earlier “cheesegrater” (MacPro1,1-5,1) that are dual CPU. I do believe they are NUMA - similar-era x86 servers certainly are.

                                                              1. 1

                                                                Ah, you’re right, sorry for the confusion.

                                                          2. 1

                                                            I’d assume they’ll just support non-integrated RAM - as there will be space and cooling available.

                                                          1. 4

                                                            This sounds good to me. I’d prefer a slightly more generic tag that includes Guix and other related build systems / package managers (I remember hermes off the top of my head, and there was some other package manager in the scientific computing sphere), reproducible builds, bootstrappability. But I don’t really have good suggestions for such a tag name.

                                                            1. 2

                                                              Thanks for the hermes shoutout :). Note I use hermes every day, though patches are not happening fast because I am working on releasing a new project first.

                                                              I do have plans for some future blog posts and posting them here, so a tag would be nice.

                                                              1. 2

                                                                I would love a more generic tag, but this discussion has come up before and we never settle on a good name.

                                                                We might as well bite the bullet and tag nix since it covers 80% of the “declarative/reproducible build” content.

                                                                1. 1

                                                                  We might as well bite the bullet and tag nix since it covers 80% of the “declarative/reproducible build” content.

                                                                  It doesn’t really, it just forward the confusion nixos has created with regard to reproducible builds and reproducible deployments. NixOS supports the latter, not the former.

                                                                  1. 1

                                                                    But, for reproducible deployments there’s NixOps, isn’t it ?

                                                                    It’s on my list of stuffs to learn and experiment with, and I think the Nix project is claiming that it does just that.

                                                                    1. 2

                                                                      NixOS is for all intentions and purposes about reproducing system behavior and configurations. NixOPS is probably just more abstractions on top of the existing configurations to deliver them to machines.

                                                                      None of this is reproducible builds.

                                                                      1. 3

                                                                        “None of this is reproducible builds”. That sounds really weird to my ears.

                                                                        You may have your definition of reproducible builds.

                                                                        My own is to have two identical binaries at the end of two builds with identical dependencies. And with this definition of reproducible builds in mind, for me Nix/NixOs is totally based and grounded in reproducible builds.

                                                                        The identity of a build is represented by a hash, and you can identify two builds who would have the same result in the extent that they produce the same hash.

                                                                        1. 1

                                                                          And with this definition of reproducible builds in mind, for me Nix/NixOs is totally centered on reproducible builds.

                                                                          The identity of a build is represented by a hash, and you can identify two builds who would have the same result in the extent that they produce the same hash.

                                                                          It’s not a unique feature of NixOS and not something they have worked hard towards the past years. It feels like a severe missattribution to conflate all of these things to one “nixos” tag.

                                                                          1. 1

                                                                            About attributing all those concepts to the nixos tag, as if Nixos was the only one… It is a concern I understand.

                                                                            But I cannot comment nor relate to something precisely about “not something they have worked hard towards the past years” : For me the /nix/store is so central, un-avoidable for any executable to run, that even if they happened not to work hard on it, even let’s say for several years, it would still be the ground on which reproducible builds depends inextricably on one another (other reproducible builds).

                                                                            1. 1

                                                                              For me the /nix/store is so central, un-avoidable for any executable to run, that even if they happened not to work hard on it, even let’s say for several years, it would still be the ground on which reproducible builds depends inextricably on one another (other reproducible builds).

                                                                              But /nix/store isn’t about reproducible builds. The checksums you see is just a hash over the dependency tree. Nothing about bit-for-bit identical build artifacts.

                                                                              1. 1

                                                                                If I may take a counter example, with your definition, let’s take a build (traditionnal) that would take as input the current date of the building of the executable, and would display it in a message at each startup. By design, without anyone being able to intervene, this build cannot be bit-by-bit identical on every machine, whether it be on NixOs or not. The date value in question would be always different.

                                                                                I’m interested, what would be an example of a serious (or insidious or…) issue you know about that could be hidden with current NixOs way of doing?

                                                                                1. 3

                                                                                  First one is easy as Reproducible Builds defines SOURCE_DATE_EPOCH for the build to follow if it support Reproducible Builds. https://reproducible-builds.org/docs/source-date-epoch/. You can’t achieve reproducible builds in isolation. And it’s a conscious effort from both upstream and downstream to ensure reproducability,

                                                                                  As for the second point, NixOS is still as vulnerable to supply chain compromises as any other distribution. Who compiles your packages, and where is that work done? Are you capable of verifying the work being done by the upstream NixOS packagers?

                                                                    2. 1

                                                                      Would you enlighten us and tell us what reproducible builds really are?

                                                                      1. 2

                                                                        Reproducible builds is bit-for-bit reproduction of build artifacts. There are people working on this from NixOS, but it’s by no means something that isn’t shared by Debian, OpenSUSE and Arch these days.

                                                                        https://en.wikipedia.org/wiki/Reproducible_builds

                                                                        1. 2

                                                                          What is the confusion? Is that NixOS isn’t part of the Reproducible Builds™ group?

                                                                          1. 1

                                                                            They are, but conflating all of the mentioned articles to one “nixos” tag is misattribution. This isn’t unique to NixOS and they have not had a strong push towards deterministic compilation. Reproducible in the context of nixos is just system behavior, but people conflate the features to mean the same thing.

                                                                          2. 1

                                                                            Maybe something like reporoducible-systems?

                                                                            1. 4

                                                                              r13y :)? Fits considering Graham got the domain for NixOS.

                                                                              https://r13y.com/

                                                                              1. 2

                                                                                No, lets not continue these number + letter combinations. First write down how you would explain to a new comer to the site and overall situation why plain english is inadequate.

                                                                                1. 3

                                                                                  “English has too long words and makes for a poor UX in a tagging system”.

                                                                                  Then I’d promptly point towards your sentence where you replaced “and” with a pluss sign as a demonstration how written language works in practise.

                                                                                  1. 1

                                                                                    Then I’d promptly point towards your sentence where you replaced “and” with a pluss sign as a demonstration how written language works in practise.

                                                                                    Or, we could just use the word reproducibility. I guess I can’t agree with your starting axiom.

                                                                                    Another consideration, screen readers. These letter+number “words”, and I use that loosely, seem a worse option for those using screen readers. Have you considered those problems and how they fit into this choice?

                                                                                    1. 2

                                                                                      The tag is explained with full complete English sentences if the tag is not clear enough. I do not understand the problem here.

                                                                                2. 1

                                                                                  I enjoy this proposal in a genuine way.

                                                                                  1. 1

                                                                                    I love it! The question is how to give your suggestion more visibility so that it’s actually adopted.

                                                                      1. 14

                                                                        We need more expressive languages in order to maintain a modern display-server stack. I think that we are reaching the limits of what can be maintained. As I have argued before, one of the main scaling limitations in the low-level graphics stack is the fact that so much code is written as open-coded C, and C has no expressive tools aside from C preprocessor macros for refactoring that complexity.

                                                                        That said, though, I don’t think that anybody is abandoning the Xorg repositories. The wider FreeDesktop ecosystem now has a GitLab instance, and code is still being merged. It seems that the article’s concerns are largely being driven by corporate engineers, specifically from Intel and Red Hat IBM, who fret that they cannot afford to continue contributing at their historical pace. While I’m not fond of the corporate point of view, I think that nobody can afford to continue contributing at the current level of complexity, and the corporations are the last to find out because they are the last to find their time and money being ill-spent.

                                                                        If there’s something that it’s time to admit, something that we need to put our foot down on as a collective community, then it’s time to admit that we cannot support closed-source GPU drivers in the ecosystem. It’s time to stop letting nVidia, Intel, etc. have so many blobs. It is not an accident that Nouveau is smaller than nVidia’s proprietary driver; with a deeper and more open understanding of the hardware comes a reduction in complexity. Because we tolerated them for so long, they are starting to desire firmware signing. We were complacent here, and we will continue to pay the price.

                                                                        The punchline is that Xorg folks are aware of all of this. Aside from Wayland, there’s a long-standing wishlist for X12 and what the X protocol could include in the future, and the XCB project refactored large amounts of hand-written C into XML-driven generic tables which can be compiled to many different languages.

                                                                        I think that the main thrust of Wayland which we should keep in mind is not necessarily to remove the X11 network-transparent API, but to remove the need for the high-level networking server to also be the low-level hardware driver. This is another pattern which has seen improvement in the past couple decades, but we are arriving at a bit of a crossroads as Linux device support becomes increasingly conditionalized on whether Google or Apple think that we should have access to any particular part of a device.

                                                                        The next step forward may not happen until we have a more common usage of rump techniques to not just build unikernels, but to reuse the same GPU driver modules in both the “kernel” and “userspace” portions of whatever division of responsibilities we choose. Ironically, this is the pattern which Xorg originally moved away from, decades ago. In a real way, Xorg cannot be better than the common intersection of Linux and the BSDs, aside from some localized specific GPU support. (Don’t undercount that; the entire Android ecosystem operates on localized specific GPU support on Linux.)

                                                                        1. 11

                                                                          Just dropping here some IRC discussions.

                                                                          We need more expressive languages in order to maintain a modern display-server stack.

                                                                          00:25 <airlied> the X server sucks to maintain not because it's 20 year old code base in C, it's because it has 20 years of concepts that only 5 people understand
                                                                          

                                                                          That said, though, I don’t think that anybody is abandoning the Xorg repositories.

                                                                          00:28 <airlied> well the article is that The X.org server is abandonware
                                                                          00:28 <airlied> and that is pretty much true
                                                                          00:28 <airlied> the X.org server isn't the graphics stack or drivers
                                                                          00:29 <airlied> I think even at it's peak the X.org server never got more than maybe 10 contributors
                                                                          00:30 <airlied> and I believe the peak of the X.org server development was ripping stuff out of it
                                                                          
                                                                          00:35 <airlied> it's abandonware in that PRs get merged but have 0 paths to a user
                                                                          00:35 <airlied> unless they have a reason to get fixed in the stable branch
                                                                          00:36 <airlied> it'll just end up distros piling patches onto 1.20 for ever until someone steps up and fills the void
                                                                          00:37 <airlied> like maybe someone will salvage a 1.21 release and it can then admit to new PRs that it's pointless
                                                                          
                                                                          1. 14

                                                                            Hi, please don’t exclude the context. In particular, please don’t exclude my side of the discussion. I am not interested in arguing against myself nor against people who I worked with harmoniously in a prior career. Here is a complete log of the IRC discussion from #xorg-devel on Freenode:

                                                                            16:20 <simpson> I saw the recent Phoronix "abandonware" story and wrote out some thoughts. I'm a little embarrassed that my position hasn't shifted much in a decade. https://lobste.rs/s/vqv6nu/it_s_time_admit_it_x_org_server_is#c_dxumkl
                                                                            16:21 <daniels> I'm all for better languages, e.g. Rust in Mesa, but the last thing I'd ever want to try to do is rewrite the X server
                                                                            16:23 <simpson> Yes. What I have aimed to do instead (and failed at, FWIW) is to explore design of languages that would make rewriting the X server a straightforward, easy, necessary refactoring task. I think that the Genode folks have a reasonable angle for how to do this, but again it is a little inconvenient to admit that the best angle forward could be more XML and lots of C++.
                                                                            16:24 <airlied> I can't see rewriting the X server helping in any way
                                                                            16:24 <airlied> no matter what language you choose
                                                                            16:25 <airlied> it's just one of those fallacies of grass is greener
                                                                            16:25 <airlied> the X server sucks to maintain not because it's 20 year old code base in C, it's because it has 20 years of concepts that only 5 people understande
                                                                            16:25 <simpson> Yes, that's the other thing. It would be much more comfortable, knowing what we know now, to have a much more robust low-level common GPU interface which can support Xorg and also Wayland and etc. However, now it's 2020 and the community has done just that; I hear regularly of folks living entire lives on top of Wayland alone. And yet the GPU drivers are still hard to maintain, so there's still problems
                                                                            16:25 <simpson> to figure out.
                                                                            16:26 <airlied> gpu driver maintainence seems pretty mature at this point
                                                                            16:26 <airlied> like we are never going to be swimming in resources
                                                                            16:27 <airlied> but the kernel and mesa tick over pretty nicely
                                                                            16:27 <emersion> > the best angle forward could be more XML and lots of C++
                                                                            16:27  * emersion reads lots of complexity
                                                                            16:27 <simpson> airlied: Right, that's the *other* thing: The thesis of the original article is bogus, and maintainers are still here, still working in established patterns, and still producing working software. There might not actually *be* any problems.
                                                                            16:28 <airlied> well the article is that The X.org server is abandonware
                                                                            16:28 <airlied> and that is pretty much true
                                                                            16:28 <airlied> the X.org server isn't the graphics stack or drivers
                                                                            16:29 <airlied> I think even at it's peak the X.org server never got more than maybe 10 contributors
                                                                            16:30 <airlied> and I believe the peak of the X.org server development was ripping stuff out of it
                                                                            16:31 <simpson> Sure. From a downstream perspective, though, that's not at all abandonware, and it's not functionally distinguishable from parts of Xorg (or indeed parts of FreeDesktop!) which are receiving steady releases. The act of integrating a complete Xorg release is sufficient to validate that the software still works, and PRs appear to get merged.
                                                                            16:35 <airlied> it's abandonware in that PRs get merged but have 0 paths to a user
                                                                            16:35 <airlied> unless they have a reason to get fixed in the stable branch
                                                                            16:36 <airlied> it'll just end up distros piling patches onto 1.20 for ever until someone steps up and fills the void
                                                                            16:37 <airlied> like maybe someone will salvage a 1.21 release and it can then admit to new PRs that it's pointless
                                                                            16:37 <simpson> Understandable. In nixpkgs, at least, we can do that indefinitely; it is as much effort to bump from "1.20" to "1.21" as it is to include a patch. But that isn't something that will help all distros.
                                                                            

                                                                            You seem reluctant to make a point, but I’ll try to guess. Yes, I am not happy that XML and C++, as used by Genode, form the most promising path forward for managing complexity. It is a little soothing to know that OCaml is also viable, thanks to the MirageOS project. However, in any case, we’re still trapped in a prison of text, writing one-dimensional syntax to express multi-dimensional structures. There aren’t any available programming languages which properly manage this complexity, and part of my frustration is that I’ve spent a few years exploring one of these paths only to find deep disappointment.

                                                                            1. 3

                                                                              Again… We don’t need new and/or complex languages to solve problems. This isn’t the reason why xserver isn’t being maintained. A complex language will only make the maintainers job harder IMHO.

                                                                              I don’t see the problem of expressivity you describe.

                                                                              1. 2

                                                                                My main reading recommendation on this topic is Shutt’s Abstractive Power.

                                                                                I will gladly concede that we may have different ideas of what is readable and maintainable. I have trouble reading more than one module at a time, or examining more than one screenful of code at once. The typical GPU datasheet has hundreds of pages, and the typical GPU driver has hundreds of KLoC spread across dozens of modules. Just like how the GPU datasheet could be in a structured format but is usually delivered as a machine-unreadable PDF, the GPU driver could be in a structured specification but is usually delivered as piles of C spaghetti.

                                                                              2. 2

                                                                                we’re still trapped in a prison of text, writing one-dimensional syntax to express multi-dimensional structures. There aren’t any available programming languages which properly manage this complexity, and part of my frustration is that I’ve spent a few years exploring one of these paths only to find deep disappointment.

                                                                                Developments are slow, but not nonexistent. There is fructure, a structured editor for scheme; and I saw another web-based one for an ML dialect. Another project along similar lines is semgrep.

                                                                                Neither of those projects is an ideal—not even close—but it’s a start.

                                                                              3. 6

                                                                                the X server sucks to maintain not because it’s 20 year old code base in C, it’s because it has 20 years of concepts that only 5 people understand

                                                                                Totally agree, but the 20 year old code base in C certainly doesn’t help.

                                                                                1. 3

                                                                                  Not related to the story about X.org, but is there a chance we could get these one-line <code> sections to wrap? I can’t read the first excerpt, because when I try to scroll it left, it gets obscured by the scrollbar, that just pops up.

                                                                                  1. 3

                                                                                    They should’ve been using quotations instead, no?

                                                                                    1. 2

                                                                                      That tripped on the angle brackets unfortunately.

                                                                                      1. 1

                                                                                        You should be able to escape those, though; no?

                                                                                2. 3

                                                                                  the XCB project refactored large amounts of hand-written C into XML-driven generic tables which can be compiled to many different languages.

                                                                                  While the XML tables are certainly better than hand-written C, they’re still very complex, underdocumented, and full of concepts that only 5 people understand. I started a project trying to understand them and compile them to higher-level languages (OCaml in particular, but it infers enough information that making a code generator for any other language shouldn’t be too hard) and while I’m only working on it on and off in my spare time and I burned out on it a few times, it’s been about two years since I started and there’s still stuff I don’t understand. That said, I’m doing my best to document my struggles so I hope I’ll be able to contribute some documentation back to it.

                                                                                  1. 1

                                                                                    May be too superficial on my side, but could D [1] be used to compile Xorg (may be with awk magic to massage includes) ?

                                                                                    [1] https://dlang.org/blog/the-d-and-c-series/

                                                                                    1. 5

                                                                                      Why would that help?

                                                                                  1. 8

                                                                                    Is there going to be every operating system distribution’s package repository taken down as well?

                                                                                    1. 8

                                                                                      Don’t expect any due diligence of ouf the copyright enforcement goons.

                                                                                    1. 6

                                                                                      I really like the concept of Kakoune, tried it a couple of times and inverting the movement to action order is a great UX improvement. But unfortunately my muscle memory in vi is keeping me there, the differences is simply slowing me down too much. I would however love to see someone to “steal” Kakoune style editing in a vim extension, visual mode is the closest we have, which I do use quite a bit but it’s not quite the same.

                                                                                      1. 7

                                                                                        I might misunderstand you, but if muscle memory is what’s keeping you in vi, wouldn’t it also keep you from using such an extension?

                                                                                        1. 1

                                                                                          The upside is that such an extension could be used on an opt in basis, e.g. by toggling it via a :ToggleKak or as an additional mode which can be entered from normal mode. This would allow me to instantly switch back to normal vi-mode thus making me able to get used to it gradually.

                                                                                          Additionally I was thinking an extension that keep more original vim movements instead of keeping some and changing others. Word is the same in kak but for instance foregoing g and GG for instance is a massive hassle, I don’t recall on top of my head what more was missing but there was quite a few changes. These changes probably makes sense if you start from a blank slate and thus makes sense for a new editor but as an extension to vi/m I’d rather see adherence to the old learned movement words.

                                                                                          Edit: Some things that I notice missing/changed at once when starting kak again and just trying to navigate a little bit in the project I’m working on right now:

                                                                                          • Folding, zc/zo
                                                                                          • Set line numbers, :set nu
                                                                                          • Go to line, :n where n is line number
                                                                                          • gcc/cs are popular plugins for comment and change surrounding, these are popular enough to be ported to vi-mode in other editors like vscode.
                                                                                          • At this point I’m going back to vi because it’s unfortunately slowing me down to much to get real work done.

                                                                                          Now I still love what kak is doing and if I weren’t already a vim user a lot of the things probably make a lot more sense.

                                                                                          1. 5

                                                                                            I found that the bindings that got changed from Vim was mostly an improvement in consistency, whereas original Vim bindings are constrained by their legacy. For instance in Kakoune shifted version of keys “extend” your current selection rather than move it. Thus, G is just g (which enters “goto” mode that includes g for buffer begin, j for buffer end etc.) that extends the selection rather than moving it, which is why you need to use gj instead of G to go to the buffer end.

                                                                                            Other than folding (which is not currently possible) your other missing features are actually available right now, so if you decide to give it a go again here are some pointers:

                                                                                            Set line numbers, :set nu

                                                                                            This is available as a highlighter, documented in :doc highlighters and the wiki page

                                                                                            Go to line, :n where n is line number

                                                                                            This is available with <n>g, from :doc keys

                                                                                            gcc/cs are popular plugins for comment and change surrounding, these are popular enough to be ported to vi-mode in other editors like vscode.

                                                                                            This is built-in with :comment-line and :comment-block commands, but not mapped to a key by default

                                                                                            I can’t blame someone much for not being able to discover some features – while in-editor help with the clippy and reference documentation with :doc is pretty great, it doesn’t have a good “user manual” like Vim that the user can discover features through. The wiki also helps but is not very well organized. TRAMPOLINE is a decent vimtutor replacement, but hard to find unless you know it exists.

                                                                                            1. 1

                                                                                              Thanks, that’s hugely helpful. Will for sure try out trampoline next time I give it a spin, I do love vimtutor.

                                                                                        2. 3

                                                                                          Similarly for me, kak just simply isn’t available as ubiquitously as vi(m). I fear relearning the muscle memory would be a detriment in the long run as I would still likely need to switch back to vi(m) fairly frequently

                                                                                          1. 2

                                                                                            What distro are you using that doesn’t have a Kakoune package available? About a dozen are supported, it’s surprising to hear that the editor isn’t widely available.

                                                                                            1. 5

                                                                                              What distro are you using that doesn’t have a Kakoune package available?

                                                                                              Telecom-deployed clusters of RHEL VM’s.

                                                                                              1. 1

                                                                                                Can you not use this RHEL package?

                                                                                                1. 1

                                                                                                  First, no el7 build, second, getting it there would be problematic at best (in terms of file copying).

                                                                                              2. 2

                                                                                                Alpine Linux. I also occasionally deal with embedded ‘distros’ that don’t have a package manager .

                                                                                                1. 4

                                                                                                  I can see a package for Alpine, I’ve installed it myself in Docker containers.

                                                                                                  In any case, it’s true that muscle memory is a big obstacle when trying to use one or the other. But when you switch over to Kakoune, it’s harder in my experience to go back to Vi bindings (for example when there’s absolutely nothing else installed on a random system).

                                                                                                  1. 1

                                                                                                    The Alpine package is on testing/edge, which isn’t considered stable. I already intentionally stick to stock vi(m) configurations as much as possible to alleviate muscle memory issues, switching seems like a step backwards to me despite the overall UI/UX language being better.

                                                                                                    1. 1

                                                                                                      When I use vim nowadays (and I install kakoune anywhere I need to edit anything), I am staying only with the very limited set of commads.

                                                                                                2. 2

                                                                                                  What might be left out about how common place vi(m) is the fact that there are vi(m) modes for A LOT of things, I’m talking editors like VSCode, IDE’s like JetBrains suite, Visual Studio, emacs evil, etc. but most importantly all major browsers (vimari/vimium/vimpinator/pentadactly/qtBrowser/w3m/etc), window managers (ultimate macOS for one), tmux, shells, scripting via s(ed), and more. Wherever these will diverge from kakoune there will be friction in daily usage.

                                                                                                  Again this isn’t criticism to kakoune just a note on how ubiquitously available the vi(m) keybinding set really is.

                                                                                                  Additionally to that I’ve worked with industrial control systems often being quite literary air gapped (not uncommonly located in rural places without internet connection) running some flavour of BSD/Linux, vi is pretty much always available for some quick adhoc configuration at a customer site, anything else, not so much.

                                                                                                  1. 2

                                                                                                    Yeah, this is also a factor for me, though less so as I have never been happy with a vim plugin/emulation layer.

                                                                                                    1. 3

                                                                                                      The one in VSCode is surprisingly good if you bind it to a neovim backend. Onivim is also interseting but more expimental.

                                                                                                      1. 1

                                                                                                        Have any sources on the neovim backend? I use neovim as my daily editor and was unimpressed by VSCodes vim plugin about ~1 year ago, but using neovim as a backend might address my concerns.

                                                                                                        I’ve tried OniVim2, as I purchased a license way back when it was fairly cheap. Their current builds seem very promising.

                                                                                              1. 1

                                                                                                If you liked this post, do me a favor and tell me if you can run the dev build of Oil, which I believe takes less than 2 minutes, although people appear to have problems with it:

                                                                                                https://github.com/oilshell/oil/blob/master/README.md

                                                                                                It’s basically:

                                                                                                1. A Linux machine – Debian/Ubuntu-ish is most likely to work – bash, coreutils, etc. (Other distros should also work, but Debian/Ubuntu are frequently tested)
                                                                                                2. git clone (with a submodule)
                                                                                                3. build/dev.sh minimal
                                                                                                4. bin/osh.
                                                                                                5. Now you have a shell and you can even modify it with pure Python code!

                                                                                                I think that is easy, but I’m interested in feedback otherwise. And let me know if there instructions are unclear.

                                                                                                If you have a Linux machine, and are not able to do that in 2 minutes, let me know where you are at the 2 minute mark … did something not work?

                                                                                                1. 4

                                                                                                  I gave this a go, but I don’t have a /bin/bash and got stuck at:

                                                                                                  Removing _devbuild/gen/*
                                                                                                  asdl/hnode.asdl -> (asdl/tool) -> _devbuild/gen/hnode_asdl.py
                                                                                                  frontend/types.asdl -> (asdl/tool) -> _devbuild/gen/types_asdl.py
                                                                                                  core/runtime.asdl -> (asdl/tool) -> _devbuild/gen/runtime_asdl.py
                                                                                                  tools/find/find.asdl -> (asdl/tool) -> _devbuild/gen/find_asdl.py
                                                                                                  ./build/dev.sh: build/codegen.sh: /bin/bash: bad interpreter: No such file or directory
                                                                                                  

                                                                                                  I do have a /bin/sh (which is dash) and I do have bash in my PATH and /usr/bin/env, so #!/usr/bin/env bash would work.

                                                                                                  edit I gave it more than two minutes. I ran:

                                                                                                  rg -l '#!/bin/bash' | xargs sed -i -e 's%#!/bin/bash%#!/usr/bin/env bash%'
                                                                                                  

                                                                                                  and got further, but found gcc was needed:

                                                                                                  build/setup.py -> libc.so
                                                                                                  unable to execute 'gcc': No such file or directory
                                                                                                  error: command 'gcc' failed with exit status 1
                                                                                                  

                                                                                                  I added gcc and readline to my environment, and ran:

                                                                                                  (export PATH=$(dirname $(which zcat)):$(dirname $(which git)):$(dirname $(which gcc)):$(dirname $(which bash)):$(dirname $(which coreutils)):$(dirname $(which python2)); ./build/dev.sh minimal)
                                                                                                  

                                                                                                  and it seems to work, and the build is super fast. Really nice!

                                                                                                  1. 3

                                                                                                    Excellent, the shebangs are indeed a mistake and I appreciate the followups! Thanks for trying it.

                                                                                                  2. 2

                                                                                                    On Arch it works as advertised.

                                                                                                    1. 1

                                                                                                      ‘’’Removing _devbuild/gen/* /usr/bin/env: ‘python2’: No such file or directory’’’

                                                                                                      Fwiw, it’s issues like this that steer me away from Python projects. I’ve been burnt out from maintaining Python dependencies, and even though Py2 is now deprecated, it still exists. If I really need a Python project, I’ll typically try to encapsulate it within a docker container or go out of my way to make sure it only support Py3.

                                                                                                      I’ve been following Oil since it feels like it’s inception, but Python has always kept me from trying it, and still does apparently.

                                                                                                      1. 3

                                                                                                        OK thanks for trying it.

                                                                                                        BTW you don’t need Python (either 2 or 3) to use Oil. You only need it to change the code.

                                                                                                        The tarballs don’t depend on Python: https://www.oilshell.org/release/0.8.1/ (and that’s been true since the very first release, over 3 years ago)

                                                                                                        Or it is also packaged in a number of places: https://github.com/oilshell/oil/wiki/Oil-Deployments

                                                                                                        Also, for developers, there is a nascent shell.nix that declares the Python dep: https://github.com/oilshell/oil/blob/master/shell.nix

                                                                                                        (I don’t use Nix personally, but others may want to run with it.)

                                                                                                        Filed an issue for this: https://github.com/oilshell/oil/issues/833


                                                                                                        Also FAQ about Python: http://www.oilshell.org/blog/2018/03/04.html#faq

                                                                                                    1. 1

                                                                                                      Now I really want a font that supports the “Per” symbol. Anyone know of one, or how to search for such a font?

                                                                                                      I can’t even find another source for info about the “per” symbol, aside from this entry in the unicode table, let alone a modern font that supports it. The Wikipedia article for that unicode character redirects to “Ratio”.

                                                                                                      1. 3

                                                                                                        Firefox inspector reveals the font rendering as “Unviersalia”. At least on my Arch Linux it renders correctly everywhere, including VTE-based terminals, but I can’t verify which font file it comes from.

                                                                                                        EDIT: Of course Noto includes this. Also, /usr/share/fonts/misc/10x20.pcf.gz, 6x12.pcf.gz, Code2000.ttf, and Symbola.otf

                                                                                                        1. 2

                                                                                                          fileformat.info has a handy “fonts that support this” link - https://www.fileformat.info/info/unicode/char/214c/fontsupport.htm

                                                                                                        1. 4

                                                                                                          Isn’t the complicated code in GNU libc related to locales, see: https://github.com/gliderlabs/docker-alpine/issues/144, https://www.openwall.com/lists/musl/2014/08/01/1.

                                                                                                          Maybe someone with more knowledge can comment.

                                                                                                          1. 11

                                                                                                            The funny thing is that isalnum cannot take Unicode codepoints, according to its specification. What’s the point of using locales for unsigned char? 8-bit encodings? But I’d be surprised if it handled cyrillic in e.g. CP1251.

                                                                                                            Update: Ok, I am surprised. After generating a uk_UA.cp1251 locale, isalnum actually handles cyrillic:

                                                                                                            $ cat > isalnum.c
                                                                                                            #include <ctype.h>
                                                                                                            #include <stdio.h>
                                                                                                            #include <locale.h>
                                                                                                            
                                                                                                            int main() {
                                                                                                                setlocale(LC_ALL, "uk_UA.cp1251");
                                                                                                                printf("isalnum = %s\n", isalnum('\xE0') ? "true" : "false");
                                                                                                            }
                                                                                                            
                                                                                                            $ sudo localedef -f CP1251 -i uk_UA uk_UA.cp1251
                                                                                                            $ gcc isalnum.c && ./a.out
                                                                                                            isalnum = true
                                                                                                            

                                                                                                            On the practical side, I have never used a non-utf8 locale on Linux.

                                                                                                            1. 17

                                                                                                              I guess you haven’t been around in the 90ies then, which incidentally also is likely when the locale related complexity was introduced in glibc.

                                                                                                              Correctness often requires complexity.

                                                                                                              When you are privileged to only needing to deal with english input to software running on servers inter US, then, yes, all the complexity of glibc might feel over the top and unnecessary. But keep in mind others might not share that privilege and while glibc provides a complicated implementation, at least it provides a working implementation that fixes your problem.

                                                                                                              musl does not.

                                                                                                              1. 10

                                                                                                                Correctness often requires complexity.

                                                                                                                In this case, it doesn’t – it just requires a single:

                                                                                                                _ctype_table = loaded_locale.ctypes;
                                                                                                                

                                                                                                                when loading up the locale, so that a lookup like this would work:

                                                                                                                #define	isalpha(c)\
                                                                                                                        (_ctype_table[(unsigned char)(c)]&(_ISupper|_ISlower))
                                                                                                                

                                                                                                                Often, correctness is used as an excuse for not understanding the problem, and mashing keys until things work.

                                                                                                                Note, this one-line version is almost the same as the GNU implementation, once you unwrap the macros and remove the complexity. The complexity isn’t buying performance, clarity, or functionality.

                                                                                                                1. 7

                                                                                                                  Interestingly, this is exactly how OpenBSD’s libc does it, which I looked up after reading this article out of curiosity.

                                                                                                                2. 4

                                                                                                                  Locale support in standard C stuff is always surprising to me. I just never expect anything like that at this level. My brain always assumes that for unicode anything you need a library like ICU, or a higher level language.

                                                                                                                  1. 4

                                                                                                                    Glibc predates ICU (of a Sun ancestry) by 12 years.

                                                                                                                    1. 2

                                                                                                                      It probably does. A background project I’ve been working on is a Pascal 1973 Compiler (because the 1973 version is simple) and I played around with using the wide character functions in C99. When I use the wide character version (under Linux) I can see it loads /usr/lib/gconv/gconv-modules.cache and /usr/lib/locale/locale-archive. The problem I see with using this for a compiler though (which I need to write about) is ensuring a UTF-8 locale.

                                                                                                                    2. 2

                                                                                                                      you haven’t been around in the 90ies then

                                                                                                                      – true

                                                                                                                      only needing to deal with english input to software running on servers inter US

                                                                                                                      – I’ve been using and enjoying uk_UA.utf8 on my personal machines since 2010, that is my point

                                                                                                                      The rest of your assumptions does not apply to me in the slightest (“only English input”, “servers in the US”). I agree that I just missed the time when this functionality made sense.

                                                                                                                      Still, I think that the standard library of C feels like a wrong place to put internationalization into. It’s definitely a weird GNUism to try to write as much end-user software in C as possible (but again, it was not an unreasonable choice at the time).

                                                                                                                      1. 3

                                                                                                                        Locale support is part of the POSIX standard and the glibc support for locales was all there was back in the 90ies; ICU didn’t exist yet.

                                                                                                                        You can’t fault glibc for wanting to be conformant to POSIX, especially when there was no other implementation at the time

                                                                                                                        1. 4

                                                                                                                          Locale support is part of the POSIX standard

                                                                                                                          Locales are actually part of C89, though the standard says any locales other than "C" are implementation-defined. The C89 locale APIs are incredibly problematic because they are unaware of threads and a call to setlocale in one thread will alter the output of printf in another. POSIX2008 adopted Apple’s xlocale extension (and C++11 defined a very thin wrapper around POSIX2008 locales, though the libc++ implementation uses a locale_t per facet, which is definitely not the best implementation). These define two things, a per-thread locale and _l-suffixed variants of most standard-library functions that take an explicit locale (e.g. printf_l) so that you can track the locale along with some other data structure (e.g. a document) and not the thread.

                                                                                                                          1. 2

                                                                                                                            Oh. Very interesting. Thank you. I know about the very problematic per-process setlocale, but I thought this mess was part of posix, not C itself.

                                                                                                                            Still. This of course doesn’t change my argument that we shouldn’t be complaining about glibc being standards compliant, at least not when we’re comparing the complexities of two implementations when one is standard compliant and one isn’t.

                                                                                                                            Not doing work is always simpler and considerable speedier (though in this case it turns out that the simpler implementation is also much slower), but if not doing work also means skipping standards compliance, then doing work shouldn’t be counted as being a bad thing.

                                                                                                                            1. 3

                                                                                                                              I agree. Much as I dislike glibc for various reasons (the __block fiasco, the memcpy debacle, and the refusal to support static linking, for example), it tries incredibly hard to be standards compliant and to maintain backwards ABI compatibility. A lot of other projects could learn from it. I’ve come across a number of cases in musl where it half implements things (for example, __cxa_finalize is a no-op, so if you dlclose a library with musl then C++ destructors aren’t run, nor are any __attribute__((destructor)) C functions, so your program can end up in an interesting undefined state), yet the developers are very critical of other approaches.

                                                                                                                    3. 5

                                                                                                                      What’s the point of using locales for unsigned char? 8-bit encodings?

                                                                                                                      Yes, locales were intended for use with extended forms of ASCII.

                                                                                                                      They were a reasonable solution at the time and it’s not surprising that there are some issues 30 years later. The committee added locales so that the ANSI C standard could be adopted without any changes as an ISO standard. This cost them another year of work but eliminated many of the objections to reusing the ANSI standard.

                                                                                                                      If you’re curious about this topic then I would recommend P.J. Plauger’s The Standard C Library.
                                                                                                                      He discusses locales and the rest of a 1988 library implementation in detail.

                                                                                                                      1. 2

                                                                                                                        Yes, locales were intended for use with extended forms of ASCII.

                                                                                                                        Locales don’t just include character sets, they include things like sorting. French and German, for example, sort characters with accents differently. They also include number separators (e.g. ',' for thousands, '.' for decimals in English, ' ' for thousands, ',' for the decimal in French). Even if everyone is using UTF-8, 90% of the locale code is still necessary (though I believe that putting it in the core C/C++ standard libraries was a mistake).

                                                                                                                        1. 2

                                                                                                                          Date formatting is also different:

                                                                                                                          $ LC_ALL=en_US.UTF-8 date
                                                                                                                          Tue Sep 29 12:37:13 CEST 2020
                                                                                                                          
                                                                                                                          $ LC_ALL=de_DE.UTF-8 date
                                                                                                                          Di 29. Sep 12:37:15 CEST 2020
                                                                                                                          
                                                                                                                    4. 1

                                                                                                                      My post elsewhere explains a bit about how the glibc implementation works.

                                                                                                                    1. -1

                                                                                                                      I love the look of haskell, but damned if I can ever use it for more than a week.

                                                                                                                      1. 3

                                                                                                                        I’ve generally found that practically minded Haskell-inspired languages and/or frameworks hit a really good balance for my sanity. On the .NET side, for example, F# can be excellent (and its trivial escape valve to C# is perfect when you need a more typical way to reason about a problem). And even in pure C#, there’s always language-ext to give you ad hoc Haskell-like purism. On the JVM side, it’s a bit trickier: Kotlin would fill in nicely for C#, but I don’t know a good F# equivalent, and the Kotlin variant of language-ext is Arrow, which I absolutely loathe. But I’m sure there’s something equivalent you could do there, too. And I could point to similar libs for things like Ruby (the dry libraries), JavaScript (Immutable.js and the like), and so on.

                                                                                                                        I’m otherwise with you, though: I’ve tired to use Haskell in anger many, many times, and the closest I ever get is being angry I ever tried to use Haskell.

                                                                                                                        1. 2

                                                                                                                          Care to elaborate on why you loathe Arrow?

                                                                                                                          1. 2

                                                                                                                            Docs are poor, upgrades have been rough, performance impact has been disproportionately high compared to something like language-ext, the way they use Kotlin destructuring for bind borders on syntax abuse…it basically feels like someone tried to staple-gun Haskell onto Kotlin and ended up with something that’s alien to both. (The recent push towards using the IO monad everywhere also makes it comparatively harder to use Arrow for only parts of our app, IMHO.)

                                                                                                                            1. 1

                                                                                                                              Thanks for elaborating! I haven’t used Kotlin, but based on what I know about the language it does seem a bit odd to pair it with Haskell.

                                                                                                                          2. 2

                                                                                                                            On the JVM side, it’s a bit trickier:

                                                                                                                            A baby-step is to use the Atlassian’s library Fugue.

                                                                                                                            A “head-dive” is to start using the Frege programming language.

                                                                                                                            1. 1

                                                                                                                              JVM has Scala

                                                                                                                          1. 6

                                                                                                                            Modern font rendering is so complicated I’m nostalgic for bitmap fonts.

                                                                                                                            Intuitively there’s something very wrong with font formats being designed around running the fonts in a vm.

                                                                                                                            1. 14

                                                                                                                              Intuitively there’s something very wrong with font formats being designed around running the fonts in a vm.

                                                                                                                              One thing I have to remind people of from time to time is that computers are used in more languages than just English. Languages that use the Arabic alphabet (Arabic, Farsi, Urdu, etc.), for example, are extremely hard—arguably impossible—to properly do armed with only bitmaps. Letters have different sizes and shapes depending on their position in the word and what comes before and after, and justification is done not by adjusting the spaces between words, but by adjusting individual letter widths. Yeah, you can do this as a bitmap with no VM, but then you need a huge number of glyphs, and each program has to natively reimplement Arabic rendering logic. Using a VM for such a script is a huge boon, saving tons of disk space, code points, and duplicated logic. And while Arabic script is extreme, scripts like Hudum, Chinese, and Devanagari have similar issues.

                                                                                                                              1. 5

                                                                                                                                One thing I find fascinating but somewhat under-studied is that Latin script has been typeset in print for something like 600 years, and typewriters have existed for over 100. To some extent then, what Latin alphabet text looks like has been influenced by the needs of machines for a long time. Contrast with what pre-print formalized handwriting styles sometimes look like, and ponder trying to come up with bitmap fonts that look like that.

                                                                                                                                Text is fundamentally shaped by the tools used to write it. Try writing with a fountain pen instead of a ball pen and after all the scuffs and smudges as you re-learn the process, your handwriting will come out different. Try writing with a Chinese/Japanese brush or a cuneiform stylus-in-mud and you’ll get different letter shapes again. Scripts throughout European history are often based off of Roman Latin script… or rather, the formal Latin script that people of the time had available, which was generally carved into stone.

                                                                                                                                1. 5

                                                                                                                                  You might be interested in this very deep dive into fonts developed in the Papal states in the 15th century:

                                                                                                                                  https://ilovetypography.com/2016/04/18/the-first-roman-fonts/

                                                                                                                                  1. 2

                                                                                                                                    Whew that is WAY too deep for me, but it’s still absolutely fascinating. Thank you!

                                                                                                                                2. 1

                                                                                                                                  On a related but maybe not as important a note - what bitmap fonts (if any) support emojis?

                                                                                                                                  1. 2

                                                                                                                                    GNU unifont

                                                                                                                                    1. 1

                                                                                                                                      Thanks for the link, I did not know about this!

                                                                                                                                3. 11

                                                                                                                                  I mean, I definitely get the same feeling, but it’s not at all clear to me that there’s a better method for encoding the ideal way to rasterize a given vector image at every possible raster size, without excessively bloating the filesize.

                                                                                                                                  If you do naive interpolation, you either get jaggies or blur. Embedding explicit hinting data for every raster size is a non-starter for web fonts.

                                                                                                                                  1. 5

                                                                                                                                    Typography is a pretty complicated subject, so (no offense) your intuition doesn’t hold much water. (My creds: I was working in font digitization from 1988-90 during the “font wars”, have friends who’ve stayed in the field longer, and have had a pretty strong amateur interest ever since.)

                                                                                                                                    The virtual machine for font hinting has been around since Apple developed TrueType circa 1988-90. One of the rationales was that there were several pre-existing proprietary hinting systems (such as Adobe’s “Type 1” fonts), and they wanted those vendors to be able to migrate to TrueType, so having lots of flexibility in the hinting system was necessary. Also, a VM allows for new innovations, instead of just supporting one hinting algorithm.

                                                                                                                                    And I want to second what @gecko said — Roman-alphabet typography is dead easy compared to most other scripts. During some meetings between Apple and Sun about font technology in Java2D (circa 1998), after a lot of back and forth about ligatures, one of the Sun guys said “but really, how many people care about ligatures and contextual forms?” One of the Apple folks gave him a very sharp look and said “How about every literate person in India and Pakistan?”

                                                                                                                                  1. 4

                                                                                                                                    The day bitmap fonts stop working on computers is the day computers die.

                                                                                                                                    1. 8

                                                                                                                                      So that was about a year ago when Pango (which on Linux is used by almost everything) dropped support for them? Good to know. I’ll keep my dieded PC.

                                                                                                                                      1. 8

                                                                                                                                        As I said when I talked about this on another website, it’s complicated:

                                                                                                                                        True bitmap fonts, like those saved as .bdf files, are on their way out. Pango, for instance, recently dropped support for them.

                                                                                                                                        But “bitmap fonts” don’t have to be saved as .bdf files. The fonts mentioned above, Scientifica and Curie, can just as easily be built as .ttf or .otb files and work fine.

                                                                                                                                        So true bitmap fonts are already deprecated, but “bitmap fonts” that map to specific pixel sizes aren’t going anywhere. There’s nothing about them that ensures their doom, even as we approach ridiculously high resolutions like 8K. We can just upscale these fonts and move on with our lives.

                                                                                                                                        It’s my fault for not being more specific though. I called them “bitmap fonts” because I don’t really know what else to refer to them as. “Pixel fonts” maybe?

                                                                                                                                        1. 2

                                                                                                                                          That’s a great explanation. I also wrote a bit about how to convert bdf/pcf to sfnt.

                                                                                                                                        2. 2

                                                                                                                                          It was catastrophic, and caused a lot of people (myself included) pains as we had to scramble to find ways to continue to use our favored fonts, typically by switching to software that doesn’t depend on Pango.

                                                                                                                                        3. 3
                                                                                                                                          • Bitmap fonts -> practical, consequential
                                                                                                                                          • TTF fonts -> pretty, intentional

                                                                                                                                          Luckily pretty stuff tends not to outlive the practical stuff.

                                                                                                                                          I’ll also add one: the day we’re forced to use one of those terms that feels laggy to type on (Gnome & KDE’s default terms? It’s been a while, I only use them on other people’s computers these days) is the day computers die.

                                                                                                                                        1. 12

                                                                                                                                          There are a lot of really nice and readable free fonts out there. Price ≠ quality; yes, that’s true in some cases, but you can get beautiful and high quality fonts freely licensed.

                                                                                                                                          1. 10

                                                                                                                                            The author is also in business of selling fonts, so you have to take that one particular piece of advice in light of that. That said, I’ve read his whole book and it seems to be on point everywhere else.

                                                                                                                                            1. 2

                                                                                                                                              What do you like? I’m leaning towards Charter + Fira Sans for my blog, but I love collecting fonts so I’m always eager to hear what others like.

                                                                                                                                              1. 6

                                                                                                                                                I really love the look of Inconsolata. Originally, I had fallen in love with Consolas, but wanted to make some extensions to it. Looking for an open font similar to Consolas lead me to Inconsolata, which I could easily add extra glyphs to using FontForge. Recently, Inconsolata has had a major update making it a variable font family.

                                                                                                                                                I use it everywhere where it’s appropriate, which is 90% of my use cases (text editors, code editors, and personal notes).

                                                                                                                                                For the rest, I use Computer Modern, due to LaTeX. To my eye, LaTeX documents look gorgeous, usually with minimal tweaking, sometimes with more. Again, an open source font.

                                                                                                                                                1. 4

                                                                                                                                                  What do you like? I’m leaning towards Charter + Fira Sans for my blog, but I love collecting fonts so I’m always eager to hear what others like.

                                                                                                                                                  I keep (kept?) a list of good typefaces, and I have a Google doc from Doug Wilson in my bookmarks.

                                                                                                                                                  1. 1

                                                                                                                                                    Fantastic, thank you!

                                                                                                                                                  2. 2

                                                                                                                                                    I’m using Open Sans for my blog (blog.avalos.me), which might not be the fanciest or prettiest font; but it’s extremely readable and friendly. I’m giving hacker vibes to my personal website (avalos.me) with Jetbrains Mono.

                                                                                                                                                    1. 2

                                                                                                                                                      Open Sans is quite lovely, I may have to use it!

                                                                                                                                                1. 5

                                                                                                                                                  Where do I start.

                                                                                                                                                  STL Library. I have a whole ton of STL files from the various patreons I follow. I’d love to be able to collect and tag the various STLs so I can find what I’m looking for quickly. For instance, I’ve got one stl in one subfolder of a subfolder that is a dragonborn ranger. I may say one day, hey I need a ranger, well good luck finding that in “June Atrisans guild 2020/Dragonborns/dbr02.stl” or whatever. Tagging the individual models is the real trick here. Linking to multiple files is needed as some of them are split, and some even have pre-supported versions. I’d love to have a preview as well.

                                                                                                                                                  Same goes with Audiobooks. I have audiobooks in several places around my various drives. I’d love to be able to collect them into an app and catalog them in situ. Just allow me to gather metadata about the book, organize in the program and not have to collate my files.

                                                                                                                                                  1. 7

                                                                                                                                                    STLvault http://stlvault.com/ is aiming at this.

                                                                                                                                                    I’d love to have a preview as well.

                                                                                                                                                    There’s a nautilus plugin for that :>

                                                                                                                                                    1. 3

                                                                                                                                                      I love you.

                                                                                                                                                    2. 3

                                                                                                                                                      Sounds like what you want is actually a way of handling the file tagging.

                                                                                                                                                      What I tried doing at some point is have files live in whatever places they live, then have an SQL database with paths and tags, then have a virtual filesystem so I can just cd into a query looking up some tags, then use whatever basic thing-handling tool that can understand the basic idea «this directory, let me browse the stuff in it»

                                                                                                                                                      I do have the virtual FS part now (QueryFS), but I never moved beyond very basic metadata extraction, as I learned to put files into consistent places and find them there faster than I learned to build a consistent tagging structure. But this is a function of what files I store and how I handle them, of course.

                                                                                                                                                      (I still use that setup for streams of files, be it emails or Lobste.rs discussions — fetch, index into DB, cd into selection, handle with a fitting tool/script, rm to dismiss — which just marks as read)

                                                                                                                                                      1. 2

                                                                                                                                                        Yeah! That’s a cool idea, it’s sort of an abstracted tool set for these ideas.While this would be ok for me to use, it would be hard to get my fiancee sold on this method. Maybe step one is setting something based on this. Or, maybe a generic library application where it takes care of things like “watch this directory, add new files to sort queue” and you can then define metadata fields for whichever library you’re trying to create. It then takes care of the querying and linking for you.

                                                                                                                                                        1. 1

                                                                                                                                                          Both inotify and multiple configurable FS indexers come to mind…

                                                                                                                                                          I guess if you setup something you like, it might be feasible to distill what you need to get more of your family sold, and wrap it in a minimalistic GUI?

                                                                                                                                                          Basically: finding things should be done simply by browsing the virtual FS in a file manager or the tool’s own directory picker. At least that’s what I do, except in shell. I think if you can sell people on the approach, such UI solution will be deemed acceptable — you are not guaranteed to convince people that tag-setting, regardless of UI, is worth the benefit, of course…

                                                                                                                                                          I assume the initial background setup can stay your exclusive task for a long time, hopefully you don’t reinstall the system from zero weekly.

                                                                                                                                                          So the question is tagging. I believe that you can find an indexer with mixed inotify and crawling, which achieves good balance between fixing the omissions in the knowledge after problems and not hogging the entire IO throughput… As you, by definition, have an SQL table with all the tagged files, and hopefully you get an SQL table of all the found files, it should be easy to get all the files in need of hand-tagging. And feed them to a virtual directory, naturally. Generally a GUI for going through a directory and recording what tags the user wants to assign to each entry should be fesible if you know already there is a workflow that is worth that effort… A virtual directory helps here as a viewer tool can be launched side by side in case of a doubt.

                                                                                                                                                          PS. QueryFS is in a state of being in the state of being very useful to me but without clear plan to make it useful to others; in particular that means that feature requests have a good chance of being implemented.

                                                                                                                                                          1. 2

                                                                                                                                                            Looking into this now as well, going to take me a bit to grok it properly. FUSE is something I have never taken the time to look into

                                                                                                                                                    1. 12

                                                                                                                                                      I currently use MyFitnessPal for calorie-tracking and BigOven for recipe storage, and I cordially detest them both. They’re both buggy, slow, lacking a lot of features that I’d like to have, and “unmaintained” in that special SaaS way where vendors just stop fixing bugs or adding features once they have cash flow going. They also both cover like 80% of the same ground - BigOven has a way to calculate the nutrition numbers for a recipe but no daily calorie log, while MFP has no way to store recipes as anything more than a list of ingredients.

                                                                                                                                                      I want to replace the pair of them with a lightning-fast local-first app, but I just never seem to get around to it.

                                                                                                                                                      1. 2

                                                                                                                                                        We have Fitatu here and it seems to do both, but yeah, it’s local really.

                                                                                                                                                        1. 1

                                                                                                                                                          I second detesting MFP, but I really haven’t found anything better. It’s one of the few services I use where the mobile app is really the only way to use it (they have a web app, which is completely unusable IMO). Also very frustrating that they don’t have a public API. I spent some time reverse engineering their mobile sync API, but gave up after a while…

                                                                                                                                                          I did some research into making something similar, and found https://world.openfoodfacts.org/ as an interesting data source, but haven’t had the time/motivation to build anything yet.

                                                                                                                                                          1. 1

                                                                                                                                                            I’ve tried a whole bunch of MFP alternatives and I keep coming back to MFP (which I also do not like) because it just has more stuff in its database - I can scan almost anything I buy (in the UK) and MFP will know the nutritional details.