1. 18

    No layoffs or pay cuts at the management level, of course! It’s not like they’re responsible for these problems, it’s not like anyone’s fucking responsible for any of this, it’s not like the very idea of personal responsibility has been forgotten by both executives and engineers, no sir!

    I disagree with pretty much the whole post, but this is patently false.

    1. 5

      https://twitter.com/lizardlucas42/status/1293232090985705478

      I imagine for those layed off, it was a bit of a financial burden too.

      1. 5

        There were no pay cuts anywhere. Layoffs happened fairly uniformly across ICs and management. Not sure how that tweet disproves my comment.

        Fwiw I don’t remember Baker saying those words, and her response to the same question today did not follow that theme.

        1. 15

          https://answers.thenextweb.com/s/mitchell-baker-aGY62z

          Baker: Are execs, esp CEOs paid too much? I’m of the camp that thinks the different between exec comp and other comp is high. So then i think, OK what should mozilla do about it? My answer is that we try to mitigate this, but we won’t solve this general social problem on our own.

          Here’s what I mean by mitigate: we ask our executives to accept a discount from the market-based pay they could get elsewhere. But we don’t ask for an 75-80% discount. I use that number because a few years ago when the then-ceo had our compensation structure examined, I learned that my pay was about an 80% discount to market. Meaning that competitive roles elsewhere were paying about 5 times as much. That’s too big a discount to ask people and their families to commit to.

          So, the “difference between exec and other comp is too high” but also it’s okay for Baker to raise their compensation to closer to market rate because that is “too big a discount to ask people and their families to commit to”.

          I wonder how Baker feels about the 100% discount that the people fired are getting. The average salary at Mozilla is ~$100k according to glassdoor, so Baker’s salary ~$2.5M would pay for maybe 20 engineers and managers with room to spare. Could have maybe kept 50 or more jobs if the whole C-suite committed to pay cuts.

          Anybody who genuinely believes that they’re worth 25 times their employees’ wage is a vampire.

          1. 5

            Speaking for myself, I suspect most C-level executives don’t earn their salary. Maybe there are a few genius CEOs out there who do, I don’t know.

            Most of us (ICs and management) take some sort of pay cut to work at Mozilla. We could likely make more elsewhere, but believe in the mission enough to make the cut worthwhile. I’m willing to take a small cut, but if the pay wasn’t at least competitive, I’d go work for one of the tech giants instead.

            So while I don’t believe it’s right that the wage gap is so high, I’m also a practical person and understand that it needs to at least be competitive with industry standards to attract people with that type of experience. It would take an enormous stroke of luck to find someone with talent who is willing to work for a quarter of what they could be making elsewhere. I certainly wouldn’t do it.

            1.  

              It’s pretty common for people in academia to take a 70% or more pay cut relative to industry wages to work on things that they’re passionate about. Top universities don’t seem to have any problem recruiting very smart people on that condition. My take-away message from this is that Mozilla C-level execs care less about Mozilla than a typical computer science academic does about their work. That doesn’t really fill me with confidence in their leadership. Particularly given that 30% is a competitive CxO salary still puts you in the top 1% by income. You can live very comfortably on 10% of a $2.5m/year salary, let alone 20-25%. If you offered $500K/year to run Mozilla Corp, does she really think you’d have a shortage of qualified and passionate applicants?

              1.  

                I think that’s a reasonable opinion, and I honestly don’t know the answer to your last question. I will say that Mozilla spent 8 months searching for a replacement CEO and failed to find someone suitable (even with competitive salary). I think it might be a little harder than you’re making it out to be.

                1.  

                  The academic and CEO job markets are different enough that I don’t think this is a good comparison.
                  CEO compensation is determined by the board (How Companies Actually Decide What to Pay CEOs) and they use other companies in the same industry as a benchmark. The average tech company CEO makes $6.6 million and many of them get stock options. It’s highly unlikely that the Mozilla board would decide to pay bottom of market under these conditions. Self interest is also a factor - Mitchell Baker is a member of both the Mozilla Corporation and Mozilla Foundation boards.

          2.  

            Same. I looked and looked and could not find any evidence of this.

            1.  

              We’re any senior managers fired? Did the CEO cut salary? From Mozilla’s announcement it sounded like the entire 250 were from staff working in cancelled projects.

              1.  

                Yes, and (as stated in another thread) no.

            1. 9

              What is your favorite pitfall in Date?

              Well, the usual magic type conversion applies of course :-)

              >>> var d = new Date();
              undefined
              >>> var d2 = new Date();
              undefined
              
              >>> d - d2
              -1737
              
              >>> d + d2
              "Mon Aug 03 2020 03:19:54 GMT+0800 (WITA)Mon Aug 03 2020 03:19:56 GMT+0800 (WITA)"
              

              It’s especially surprising/confusing since - works as expected (you get a difference between the dates) but + acts like string concatenation.

              So want to add 30 minutes to a date? Use new Date(d - -1300000) as d + 1300000 will result in the formatted date with 1300000 appended as a string. You need to re-parse the result in a new Date object as well, as it returns a timestamp rather than a date object; another weird thing IMO.


              By the way, getYear() was the only method included in the original Netscape 2 release. That’s right, in 1995 they released a programming language with y2k issues 🙃 It wasn’t until Netscape 4 in 1997 that this was fixed with the addition of getFullYear(). People complain about Internet Explorer, but let’s not forget what an absolute mess Netscape was as well.

              Perhaps designing a programming language in 10 days wasn’t the best of ideas. Then again, I doubt anyone 25 years ago could foresee what a success it would become; hindsight 20/20 and all that.

              1. 2

                It’s especially surprising/confusing since - works as expected (you get a difference between the dates) but + acts like string concatenation.

                What exactly would you expect from adding two dates together?

                1. 4

                  I would expect new Date() + 1300000 to add 30 minutes, and new Date() + new Date() to either throw an error, or be some time in March 2071 (i.e. do: new Date(new Date().getTime() + new Date().getTime())).

                  1. 1

                    This is sort of what Julia does, which I like. There are separate types for dates, datetimes, and amounts of time (Days, Hours, Minutes, etc).

                    You can add an amount of time to a date or datetime and get a new date or datetime. You can add amounts of time together sensibly, but you can’t add two dates together directly (that’s a type error). You can subtract them, to get an amount of time.

              1. 8

                There’s a name that doesn’t work in English, as blech tends to be used as an expression of disgust.

                1. 12

                  expression of disgust.

                  Given some of the things I’ve heard about the trials and tribulations of embedded programming this may not be unfair.

                  1. 3

                    Given some of the things I’ve heard about the trials and tribulations of embedded programming this may not be unfair.

                    Having done embedded development long in the past, it’s certainly apt!

                  2. 9

                    I was expecting a novelty language :)

                    1. 2

                      Same here! It the name made me think it was an esolang initially.

                      1. 1

                        Yeah, I expected this to be a parody language that does the opposite of what good languages do, resulting in something like INTERCAL. I think the name “Blech” will significantly slow the growth of the language.

                      2. 7

                        Seems to be done by Bosch Research, a German company. If it works for them … I see nothing wrong with it.

                        1. 2

                          Sure, but it might limit how seriously people take it. Then again, considering the silly names some projects have…

                        2. 6

                          Being one of the authors - we are aware of this. Blech should remind you of “bare metal”. Programs can run directly on “the Blech”. We also considered the name “Metal” but it was already taken by Apple.

                          1. 2

                            I really appreciate you chiming in.

                            To me a die looks like a piece of blech.
                            Thus the name totally makes sense.

                          2. 3

                            As German, I find the name very amusing. It’s usually used in disrespect towards sheet metal of questionable thickness/stability, something that bends easily and not being something that you want to relying on for bearing load. It’s sometimes used in an affectionate way, like the Trabbi being referred to as a ‘Blechle’ or ‘small Blech’. Anyways, in all uses I’ve heard it’s always been towards thin sheet metal.

                            1. 1

                              I checked several dictionaries but couldn’t find any evidence of this. Is it a local slang?

                              1. 2

                                I’m familiar with it, I don’t believe it’s local.

                                  1. 1

                                    Thanks. I wrote it with a (capital) ‘B’ and landed here:

                                    https://en.wiktionary.org/wiki/Blech

                                    1. 1

                                      Yuck, case sensitive URL!

                                1. 2

                                  I checked several dictionaries but couldn’t find any evidence of this. Is it a local slang?

                                  Nope, not slang: https://www.merriam-webster.com/dictionary/blech

                                  That was the first hit when I did a search.

                                2. 1

                                  I also assumed it was named along the lines of Worst: http://worst.mitten.party/

                                1. 3

                                  You can restrict the commits searched to initial commits with array_length(parent). Playing with that column, apparently some commits manage to have dozens of parents. I don’t even know how you manage that.

                                  select lower(trim(message)) as message, count(*)
                                  from bigquery-public-data.github_repos.commits
                                  where (array_length(parent)=0)
                                  group by message
                                  order by count(*) desc
                                  limit 100;
                                  

                                  First few values:

                                  message                                                            f0_
                                  initial commit                                                     1957292
                                  first commit                                                       151151
                                  init                                                               39375
                                  initial commit.                                                    36600
                                  initial                                                            17894
                                  initial import                                                     14737
                                  create readme.md                                                   11510
                                  init commit                                                        9692
                                  update license.md                                                  6606
                                  first                                                              6034
                                  first commit.                                                      5688
                                  initial version                                                    5325
                                  create license.md                                                  3968
                                                                                                     3908
                                  inital commit                                                      3854
                                  initial import.                                                    3459
                                  create gh-pages branch via github                                  3371
                                  initial release                                                    3348
                                  initial checkin                                                    3194
                                  initial commit to add default .gitignore and .gitattribute files.  2967
                                  initial revision                                                   2676
                                  :boom::camel: added .gitattributes & .gitignore files              2200
                                  :neckbeard: added .gitattributes & .gitignore files                2198
                                  first version                                                      2193
                                  :octocat: added .gitattributes & .gitignore files                  2159
                                  :space_invader: added .gitattributes & .gitignore files            2154
                                  :confetti_ball: added .gitattributes & .gitignore files            2154
                                  init project                                                       2150
                                  :tada: added .gitattributes & .gitignore files                     2139
                                  :circus_tent: added .gitattributes & .gitignore files              2134
                                  :lollipop: added .gitattributes & .gitignore files                 2079
                                  
                                  1. 3

                                    apparently some commits manage to have dozens of parents. I don’t even know how you manage that.

                                    This is called an “octopus merge” if you want to search for more information. You may also be interested in this article about octopus merges in the Linux kernel

                                    1. 2

                                      FYI I just updated my article to include the array_length(parent)=0 filter. Thanks for the input!

                                      1. 2

                                        You’re welcome :)

                                        Why did you do this? AND LENGTH(TRIM(LOWER(message))) > 0 Surely the empty commit message is still a valid commit message?

                                        1. 1

                                          Hehe yes it was to filter out the empty commits. You’re technically right, but I was more interested in the actual text in the initial commit messages, although like you mention it is worthy to note that empty messages are up there. However, it’s less clear that the empty commit messages are actually initial commit messages since they could come from detached head states with no parents.

                                          Also, in case you’re curious, I just wrote a post using a similar method to try and answer What % Of Git Commit Messages Use The Imperative Mood?.

                                      2. 2

                                        Haha just reading this - and it’s funny you mention this because I realized the same way of identifying initial commits in a discussion on the Reddit thread yesterday. I think this way is certainly more accurate than the method I used (just looking through the top counts and picking ones that looked like initial commit messages). I will most likely update my post to reflect this method.

                                      1. 27

                                        I am a very vocal person about systemd.

                                        With that said, I find the articles opening statements to be quite fair in all regards- However, it does seem to fall right into the trap of comparing systemd with sysvinit.

                                        Without fail whenever someone extolls virtues and waxes poetic on the subject of systemd being “easy” it is always with the preconceived notion that sysvinit was the alternative.

                                        My typical argument against systemd is precisely in that it’s so complex and ever changing as to be effectively a closed system; integration with systemd specifics ensures that there can never be a successor, we are locked in to systemd forever more. So it had better be damned near perfect architecturally; and given the compromises and nature of exploits I do not have faith that it is.

                                        evidenced by the lengthy but great run down of the events surrounding systemd and the recent system-down exploit.

                                        There were alternatives; runit being a good example, but now swapping out your init for any other will cause many bits of useful software (notably gnome, but more as time goes on) to no longer work.

                                        1. 13

                                          Even without comparing it with anything. What valid reason is there to increase the scope of what is generally percieved as an init system by some 1000%?

                                          I, like most people, like being able to define services just by creating a 4 line unit file rather than having those silly ad hoc old init scripts. But why not doing just that? Why do I all of the sudden need an application just to check logs?

                                          1. 5

                                            Counterpoint: with systemd the logs are now collected in a pretty consistent way instead of spread eccentrically around /var/log. I find it convenient that I don’t need to define what my logfiles are going to be called or what rotation will occur, etc. Those aren’t interesting problems to me.

                                            1. 5

                                              the logs are now collected in a pretty consistent way

                                              Few adjectives are missing: error-prone, inefficient, insecure. You can insert them after pretty and then your sentence is 100% spot on.

                                              Links:

                                              If you ask me if I want to trade the previous logging stack to this, I would say no.

                                              1. 2

                                                That’s your prerogative. I have not experienced any of those issues but have experienced issues with the traditional approach. In any case, all systems have faults.

                                          2. 7

                                            Most likely a system such as systemd is not correct or even possible to implement correctly because they’re not doing any formal verification to ensure every D-bus component conforms to their agreed upon interface.

                                            I’m just waiting for a cardhouse to fall.

                                            1. 2

                                              many bits of software, you mean

                                              1. 1

                                                Did any distros actually use runit?

                                                I used daemontools for a tiny project for awhile, and while it’s very elegant, I got the sense that you were also swimming upstream. It was more a thing I used on top of a distro (on top of sysv init or systemd), not really a replacement.

                                                I don’t know the details but I’d hope and expect that the projects that integrate with systemd would accept patches for non systemd inits.

                                                1. 8

                                                  Did any distros actually use runit?

                                                  Void uses it, Artix recently added it as an option, and Project Trident recently switched over to Void as their base so I believe they also use Runit now too.

                                                  I don’t know the details but I’d hope and expect that the projects that integrate with systemd would accept patches for non systemd inits.

                                                  I doubt it. Most programs I’ve seen that depend on systemd often have it as a hard requirement. Which forces users to use tools like elogind or consolekit or eudev, or patch the program themselves to not use systemd. It’s a trivial thing when using a distro like Gentoo, but I’m sorry for those who use distros like Debian because it’s near impossible to escape from systemd there.

                                              1. 20

                                                I think this comes down to cultural differences to a certain extent.

                                                Personally, I don’t think there’s any value in saying “Oh no! 😕 If you upgrade your ruby version, that should fix it” over saying “If you upgrade your ruby version, that should fix it”. The former doesn’t convey any additional sense of empathy to me. It’s just less formal. The difference is just communication style: some people have highly adorned communication styles, with lots of superfluous language and little stylistic flourishes. That’s not a bad thing unless taken to an extreme where it obscures meaning. I’ve been trying to do it less for that reason. Here though it’s just someone being more informal, which is fine but not mandatory.

                                                Saying ‘Hi Devin, happy to be of service to you today. I think that the problem is that your version of Ruby is outdated. I think that if you try to upgrade your version of Ruby, your issue will be resolved. have a nice day :)’ is a level of fake niceness and deference that just isn’t appropriate on a free software issue tracker, IMO. It’s what I’d expect from a customer service worker, someone that is paid to put up with people asking stupid questions, and not paid enough for it I might add.

                                                No the real difference between “Upgrade your Ruby version” and “If you upgrade your ruby version, that should fix it” is that the former is imperative. To me, but perhaps not to whoever wrote it, imperatives are mostly used by adults towards children and in formal hierarchical structures. A military officer might command his men and a parent might tell their children to go to bed (and perhaps teachers to children too) but in almost any other situation, a simple imperative without a ‘please’ is just rude. “Please upgrade your Ruby version” does have a kind of ‘customer service’-y vibe to it but also doesn’t come across as rude. To me.

                                                But that’s just me and it’s based on my upbringing, in New Zealand, of my particular age. It varies across cultures, could very well be different in more religious or more rural communities even here, certainly is different in other cultures, probably is different for my grandparents, and might be different for people that grew up even 10 years earlier or later than I did.

                                                All that is to say, it’s free/libre software with free/gratis support if you get any at all. You are requesting help from someone that has no legal obligation to help you or even respond to your queries. And I think really no moral or social obligation to help you either, although there is a social expectation of at least a response to a query even if the response is ‘i’m very busy atm sorry, you’ll have to figure that out yourself’. You should show deference to them and their cultural norms. It’s their software project. It’s their issue tracker. You are entering their domain and you need to understand that and respect that.

                                                I wonder if part of the disconnect here is that Americans are mostly culturally isolated and most don’t interact in real life with anyone that isn’t an American. Obviously that’s less true in some of the bigger cities, but even then American culture is so dominant in American media that a lot of Americans probably don’t really realise that not everyone is quite like them until they start interacting with people online. And even then, there are so many Americans online it’s easy to not interact with people unlike you for quite a while online and grow accustomed to it.

                                                For me, growing up in a port town and a country where 25% of the population weren’t born here, cultural differences are everywhere. I saw Russian sailors at the supermarket, my parents had friends from all over the place, I had Somalian refugees in my classes at secondary school, lots of immigrants in classes, etc. So being exposed to so many different people from so many different cultures, the idea that everyone is like me just never occurred to me in the first place.

                                                1. 21

                                                  No the real difference between “Upgrade your Ruby version” and “If you upgrade your ruby version, that should fix it” is that the former is imperative.

                                                  This puts it really well. The former commands, the latter informs.

                                                  1. 1

                                                    “Upgrade your Ruby version” is a sucky answer for a completely different reason. It’s neither specific nor motivated. That makes it sound like a random guess at best.

                                                    Consider this answer: “Make sure your Ruby version is at least 42.0, this program needs frobnicate() that wasn’t in the standard library until that version.” I now know if my Ruby is older than 42.0, I must upgrade, and I have a way to verify if my Ruby installation is suitable. I also know that it will fix at least that particular error, assuming the answerer is competent.

                                                    Now consider “I had this problem and upgrading my Ruby version to 42.0 fixed it.” The answerer is sharing a personal experience and clearly marks it as such. From that wording I know that the answerer may not know why that fixed the problem and if that fails I should turn to someone else, but that solution worked for someone so it’s worth a try.

                                                    If I heard “upgrade your Ruby version” my first question is “upgrade to what exactly?”. I have no way to know if my version is right, or if it’s a motivated answer or a random guess. Note that for people on certain OSes or in some circumstances, upgrading things may be much harder than for others.

                                                    If I’m at a peak frustration, what I need is specificity and authority markers, not emphathy.

                                                    Also, programs should be impossible to install in an unsupported environment without explicitly disabling environment checks. That’s a major frustration for me as a frequent packager. Sometimes a single line of code can eliminate a whole class of questions.

                                                    1. 1

                                                      “Upgrade your Ruby version” is a sucky answer for a completely different reason. It’s neither specific nor motivated. That makes it sound like a random guess at best.

                                                      To be scrupulously fair, the original exchange was

                                                      Devin: Hmmm… when I start up the app it crashes and I get this error message: Edward: upgrade your ruby version

                                                      It’s very possible that Edward, seeing the error message, deduced the solution.

                                                      But as I’ve mentioned many times in this thread, the hypothetical interaction is hard to parse.

                                                      1. 2

                                                        Right, but what Edward said says nothing about his motivation for that answer and doesn’t give specific instructions—that’s the issue. Adding “empaty” and rewording it like “Could you try upgrading Ruby?” does nothing to improve that.

                                                        An anti-emphathetic, confrontational answer can be immensely more useful, like “RTFM n00b, oldest supported Ruby version is 42.0 and the one you are running doesn’t even have frobnicate(). Why don’t you stupid lusers learn to read?”.

                                                  2. 5

                                                    a simple imperative without a ‘please’ is just rude.

                                                    Bingo, I think in the article both the initial response and the suggested one are at the ends of a spectrum, where the ideal tone, to me, is somewhere in the middle: neither curt, nor twee.

                                                    The dynamics of open source is complicated and for authors it’s often thankless work and dealing with undue entitlement. But I’ve also had my share of trying to contribute to something in what I considered to be a thoughtful / researched way and being met with what I perceived (possibly imprecisely / culturally-mediated[1]) as being a confrontational tone, and while I try to not dwell on it (your project your rules / you have no responsibility towards me / OSS is exhausting / reasons), I must admit these “woman yelling at cat” moments can sour, at least for the moment, my experience of $thing. Conversely, it just feels good and convivial to get back a polite answer, even if it’s on the short side. (Again, lest I come across as some thin-skinned entitled jerk who can’t read the room, this is not a request, nor something I feel entitled to; just a preference.)

                                                    [1] I remembered this interview with Andrzej Sapkowski (writer of The Witcher series of books) that is so funny on many levels: I recognize the rhetoric style, and how it might translate to English more awkwardly than it might sound in a more Eastern language, and how the interviewer tries to find an adjective for it (“refreshingly honest”, etc.)

                                                    1. 2

                                                      Right - I’ve offered working contributions to a variety of open source libraries.

                                                      Some of them I will contribute to again, despite the maintainers being very busy and not always being able to get to things.

                                                      Others I will not send patches to anymore; I keep my fixes to myself. Trying to get them integrated is simply not worth the effort, which is a pity as some are really great bits of software.

                                                      1. 2

                                                        A high-profile example of this is Debian forking GNU libc simply because the maintainer was too much pain to deal with, which later got re-integrated in GNU libc after said maintainer left.

                                                    2. 3

                                                      I think a please would look strange to me in this setting. I’m offering information, not requesting they do a thing. I (a British person) would just say “upgrade ruby?” (framing it as a hint or suggestion), or, if I felt more verbose, “upgrading ruby will probably fix that” (framing it as information).

                                                      1. 2

                                                        Yeah I agree it sounds a bit odd. That’s what I meant by the ‘customer service-y vibe’ where you have someone whose actual role is to tell you what to do to fix your computer but who can’t exactly just order you around. So you end up getting ‘please restart your router’ and ‘please click the start button and type in “device manager”’ i.e. politely instructing you to do things in a way that sounds a bit like a request but really is an instruction.

                                                        1. 2

                                                          Yeah those are both improvements on “upgrade ruby” (command).

                                                      1. 3

                                                        You can save a bit of money on DNS if you pay in advance. Several years ago, I paid £20 for a 10 year lease on a .co.uk domain. Also obviously means that I haven’t had to worry about my registrar changing their prices or forgetting to renew or whatever.

                                                        1. 1

                                                          But you do have to worry about getting the update notification in N years. Is your contact information up to date?

                                                          1. 1

                                                            My email address hasn’t changed, so I think it’s probably fine. If I cared about downtime I could set a calendar notification, too (as it is, I’m not even sure how many years I have left).

                                                        1. 2

                                                          One of the things I’ve been thinking of lately is could sqlite be used as the configuration file as well? That avoids many problems with parsing, but makes editing by endusers quite more painful.

                                                          1. 15

                                                            I’ve had a bunch of people suggest this to me over the years in response to my YAML post, and I think both editing and reading it will be painful.

                                                            With a simple config file (e.g. key = value # comment) it’s quite easy to make even extensive configs quite readable, add explanation/context where needed, etc. But with SQLite that seems a lot harder to me, even if you add a comments column for this.

                                                            Want to update a few words in that comments column or remove a sentence? Not so easy.

                                                            If your application is intended to be primarily modified through a GUI or some such then it’s probably a reasonable choice, but even there a simple config file would do just as well in most cases (it’s not that hard to parse a config file).

                                                            1. 8

                                                              Reading a config file is easy, but robustly reading and writing them might be hard.

                                                              • When serializing after your software changed its config, do you make sure to keep the original order (which the user would expect)? Does our config file format library make this easy?
                                                              • When serializing after your software changes its config, do you keep comments? Does your config file format library make this easy?
                                                              • When writing your new config file, do you do that atomically? I’ve both written and encountered programs which would just corrupt its config file when saving and the disk is full.
                                                              • What happens if a user changes the config while the software is running? Do you attach an inotify listener to re-read the file when it changes? (What if the user writes an invalid config file which they didn’t intend to take effect yet?) Or do you just not care? (Do you make sure not to overwrite the user’s config if they change it? How will your config file conflict resolution UI work?)
                                                              • What happens when a user writes an invalid config file? You can’t just crash a graphical program; does your config file parsing library make it easy to read the data that’s not corrupt while informing the user of which parts are corrupt?

                                                              I’m not against using human-read/writable config files for all kinds of software. It’s probably what I would do to be honest. There are good (or at least good enough) answers to all of these questions. However, it’s not as straightforward as you’re implying to use a simple text config file format as a program’s configuration file if you want the config to be also modified through a GUI.

                                                              1. 5

                                                                All valid points as such, but I’m not sure if this is really a big problem in most cases. If you allow editing manually and have an interface to edit it then a # DO NOT EDIT WHILE THE APPLICATION IS RUNNING comment at the top is an easy way to solve most confusion/problems. It’s simplistic and crude perhaps, but generally speaking people mostly want text config files so they can bootstrap their machines and/or share extensive configurations, rather than fiddle with their config while the app is running.

                                                                Another solution is to use two files: one that’s generated by the GUI, and one that the user can edit which overwrites the settings from automatically generated one. This is what Firefox does with prefs.js and user.js for example.

                                                                I think there’s a place for SQLite configuration, but you’re making sharp trade-offs with it and probably only worth it in fairly specialized cases.

                                                                1. 2

                                                                  I know that the point of your comment isn’t really for those questions to be answered, because you do say that you know answers exist, but some of the answers really are pretty trivial.

                                                                  • I don’t think that software should change its own configuration file. If it does though then it probably should maintain the contents of the original file other than the bit it changed, which is actually not that hard if you put a little thought into the parser and parse to a CST that retains the spans of input text on the syntax tree nodes. But probably you should have two separate files, one of which is only touched by the programme and the other only by the user, where the user’s preferences override the programme’s. This also fixes the problem of the developer changing the defaults in an update, resetting the preferences of users.

                                                                  • If your software can’t robustly read and write files to the disk then sort that out, because the whole programme is unreliable if that is true, not just the configuration. Sort out your primitives. If you have good primitives they’ll work fine on config files.

                                                                  • If the user wants to reload the config file they run reload.

                                                                  • If you try to reload with malformed configuration, do nothing and print an error. If you try to start with malformed configuration, do nothing and print an error. What you should not to do is try to ‘DWIM’.

                                                                  1. 3

                                                                    All those answers are valid for some kinds of applications, but they’re not universal.

                                                                    • Most graphical software written for non-developers (and honestly most graphical software written for developers too) wants a way to change preferences through a GUI. You’re probably right that it’s fairly easy to write a parser from scratch which preserves the spans of text, but do existing config parsing deserialization/serialization libraries do that? My experience is that the don’t, meaning you have to write an entire parser/serializer yourself just for your config file. If you wanna use a standard like yaml or toml, writing a correct parser isn’t a small amount of work.
                                                                    • My experience is that most software uses the posix open/write/close/rename interfaces directly (or thin wrappers), and manually do atomic writes by creating a temp file and renaming. Maybe an atomic file write function would be better, but you’re probably going to use your file format library’s writeToFile method anyways, which probably isn’t going to be atomic, meaning you still have to manually do the temp file + move dance manually.
                                                                    • The next two points are OK.

                                                                    Curiously, the top comment on one of the posts on the front page discusses how Firefox fails to make sure it writes JSON data atomically, leaving you with corrupt or empty file: https://lobste.rs/s/xt82a0/performance_avoid_sqlite_your_next#c_eslys1

                                                              2. 10

                                                                I’ve worked with applications that did this before (or used similar formats), and honestly it’s a pain because it makes configuration management incredibly difficult. You have to either (a) keep the binary db file in your repo, making it harder to track changes; or (b) use scripts to execute commands against the db. And then build a bunch of error handling into your scripts for the tool you’re calling to configure the app…

                                                                For single-user desktop apps, where you don’t do as much configuration management, db-based config can be less painful. Until one of your users decides to manage a fleet of laptops with the app; or hack it into some automated pipeline and run it in a VM in a data center, so now it’s actually a prod app.

                                                                … and as I’m typing, I realize I’ve actually been paged for production incidents involving all of those scenarios except the fleet of laptops one. Sigh. So yeah, I still strongly prefer text configuration.

                                                                1. 2

                                                                  Exactly this the review process + git makes this incredibly awkward

                                                                  pseudo-code example:

                                                                  case App.env do 
                                                                    :dev -> Config.find(api: "dev") # -> dev.api.com
                                                                    :prod -> Config.find(api: "prod") # -> prod.ap.com
                                                                    _ -> raise "unknown App environment" <> App.env <> "refusing to boot"
                                                                  end
                                                                  

                                                                  Would make the fact ap.com was committed a non-trivial thing to review, and would not appear during dev/staging testing

                                                                  1. 1

                                                                    I don’t disagree, but there are solutions, such as a –csv option that will read a CSV file of the config, or a –sql option that will read a SQL file/run a command. Then it’s no big deal to store the config(s) in plain text in a VCS, etc.

                                                                    We don’t have a –csv option, but we do have a –sql option.

                                                                    there are def. trade-offs, It’s not magically delicious, but then nothing in tech usually is.

                                                                  2. 3

                                                                    I guess you could, but I don’t really love the idea. Configurations are usually small and simple and seldom modified. Doesn’t seem to fit the RDBMS paradigm well or play to SQLite’s advantages. Maybe if you already had Sqlite in your codebase for something else and/or you have a really complex configuration for some reason. I’d prefer Json/Yaml/Toml or something most of the time.

                                                                    1. 2

                                                                      I do exactly this. It’s not overly hard to configure, we give a –get/set key value CLI to the config table, plus encourage them to use sqlite3 themselves. For GUI’s it’s just a table view. The config table holds the default values as well, so there is never any doubt as to what the value is.

                                                                      1. 1

                                                                        It’s not overly hard to configure, we give a –get/set key value CLI to the config table, plus encourage them to use sqlite3 themselves.

                                                                        You say not hard to configure, but that sounds a lot harder to configure to me than just editing a simple text file. It seems okay for things where the configuration variables are all simple booleans, strings or integers. But what if they’re more complicated? Imagine trying to configure Postfix with a CLI

                                                                        $ sudo postfix config --set smtpd.recipient_restrictions 'permit_mynetworks, permit_sasl_authenticated, reject_unknown_client_hostname, reject_unknown_sender_domain, reject_unknown_recipient_domain, reject_invalid_hostname, reject_non_fqdn_sender'
                                                                        $ sudo postfix config --get smtpd.helo_restrictions
                                                                        permit_mynetworks
                                                                        permit_sasl_authenticated
                                                                        reject_non_fqdn_helo_hostname
                                                                        reject_invalid_helo_hostname
                                                                        reject_unknown_helo_hostname
                                                                        permit
                                                                        $ sudo postfix config --set smtpd.relay_restrictions '
                                                                        >permit_mynetworks 
                                                                        >permit_sasl_authenticated 
                                                                        >reject_unauth_destination'
                                                                        

                                                                        The cases where sqlite configuration isn’t an issue are the cases where text configuration is trivial and the cases where it does create big issues are the cases where text configuration is necessary.

                                                                        1. 1

                                                                          That’s pretty much http://www.postfix.org/postconf.1.html.

                                                                          But yes, I too prefer editing the configuration file with an editor. (And postconf has more options, and is presumably more intended as a scripting target than as an interactive command?)

                                                                          1. 1

                                                                            your example is a touch annoying, but it’s not difficult. What becomes difficult is when your config has complex relationships between config items. It’s easy to store, YAY FK’s, but it’s not obvious how to expose that easily with a CLI interface.

                                                                            In those cases,if we can’t figure out a nice CLI interface, we generally just use the GUI, or allow them to execute SQL directly against the config table:

                                                                            myprog –sql ‘insert …’

                                                                            But we try to avoid those sorts of config options if possible.

                                                                            The upsides is, it’s very easy when debug time comes around, they just ship us the .db file as we store the last-ran args, etc, and we store logs in an audit table as well. (we still do the standard stdout logging too). Also we have none of the issues where IO nightmares come to roost, like files being 1/2 written or corrupted, etc. It happened often enough in our deployments before we switched that it was annoying for sure.

                                                                            there are def. trade-offs, It’s not magically delicious, but then nothing in tech usually is.

                                                                        2. 2

                                                                          Arcan (desktop framework) does this: https://github.com/letoram/arcan/wiki/Configuration-Support

                                                                          It provides a FUSE layer into the database, too.

                                                                          1. 2

                                                                            If you provide nice GUI and CLI tools or API to manage such configuration, it might be a great option. Despite one detail: version control – many people manage their configuration using a VCS (Mercurial, Git, Fossil etc.) and want to see, what has changed. Classic diff is quite useless on binary files and databases. Text formats (e.g. XML) are much more VCS-friendly. You might version SQL dumps which are also text. Or you can provide a diff tool for databases… It depends on situation – if your users are consumers, they would probably never tweak the config files by hand or manage them in a VCS.

                                                                            1. 3

                                                                              Version control should be easier to do on a database, as we have much more granular data. You can say this field changed, which is better than saying this whole line changed. It’s just that our tools for text diffs are better “right now”.

                                                                              1. 1

                                                                                Yes, you’re right, that is one of pretty important points — most of configurations now sit in version control systems, and seeing the differences between deployments is quite important for ops teams.

                                                                                True, I could write a script that populates such a database when I’m deploying a service, and that would be the new config. However, that would just add more complexity to our already complex systems.

                                                                                1. 2

                                                                                  Actually, this is not uncommon and it is used in real world for a long time – e.g. in Postfix you have pairs of files like:

                                                                                  $ file /etc/postfix/client_checks*
                                                                                  /etc/postfix/client_checks:    ASCII text                                                                                                                                                                                                    
                                                                                  /etc/postfix/client_checks.db: Berkeley DB (Hash, version 9, native byte-order)
                                                                                  

                                                                                  You edit the first text one. And during runtime, the database is created and used. The the text form is converted to the more efficient database form. In your VCS you just ignore the .db files and diff the text ones.

                                                                                  Regarding the complexity: it is question whether the features provided by a DBMS (or any other library) overweight its complexity. This differs project from project, there is not universal answer to this question.

                                                                                2. 1

                                                                                  if your users are consumers, they would probably never tweak the config files by hand or manage them in a VCS.

                                                                                  Some will want to though. If your users are consumers then they’re many and varied. Now you might not want to put a lot of effort into letting your users control their configuration with git but it doesn’t hurt anyone or force you to make negative tradeoffs so why not?

                                                                                  1. 1

                                                                                    We solved this with a –sql option. So you store the plaintext .sql file in VCS/etc and just read it in. Since we store more than just config, we can do a lot of end-to-end testing this way as well, since we can setup our state to be whatever we want with a given SQL file, and then we just have to test the output.

                                                                                1. 9

                                                                                  I’ve been meaning to write more about it, but it’s currently only documented in Lojban.

                                                                                  I feel like this line would make good flavour text in a hacking game ;)

                                                                                  1. 2

                                                                                    I wonder if it would be practical to do the kind of layout randomisation that Emery Berger discusses here. They found that the -O3 optimisation level was not statistically better than -O2 for C++ (with clang, I think)

                                                                                    Would be interesting to see how compilers for other languages fare.

                                                                                    1. 1

                                                                                      For future readers, (possibly including me), the other very good wormhole is croc (upside: CLI support; downside: always relays; upside: higher confidence that binary does what you think, compared to website; downside: no web support)

                                                                                      1. 3

                                                                                        I am satisfied with Nextcloud, but this looks neat. It looks synchronous, though, and I wonder if that’d be a UX impediment to adoption.

                                                                                        1. 18

                                                                                          Yup. It is synchronous because it tries to establish a direct connection between the two peers. If, for example, they were on the same local network, the data would not travel out to some server only to be sent back again.

                                                                                          For asynchronous file transfer I love https://send.firefox.com. I also use https://upspin.io/ and a web gateway to it, but that requires some setup. I hope that changes one day.

                                                                                          Disclaimer: I’m author of https://webwormhole.io.

                                                                                          1. 4

                                                                                            I’d like to plug ffsend here as fully featured CLI tool for Firefox Send. It has been super useful ever since I built it.

                                                                                            1. 1

                                                                                              Pretty disappointed that upspin died out.

                                                                                              1. 1

                                                                                                This is just ludicrously good. Thank you so so much.

                                                                                                It’s also a great demo of RTCPeerConnection which is really helpful!

                                                                                                The only one thing I can think of as feedback: the dictionary used for the keys has some difficult to spell words in it, so if the use case of “read it down the phone” is high on your priorities, it might be better to use a larger number of short words. Or maybe even present the same binary key two ways: would you rather read a phrase or a long number? Depending on language and medium, one might be easier than the other.

                                                                                                1. 1

                                                                                                  Thanks for the feedback. I completely agree the dictionary has to change. We use the PGP word list but some of the word combinations are quite unsavoury. I think it would also be cool to have word lists for different languages.

                                                                                                  I’d also like to implement word completion at some point which I think might help with spelling.

                                                                                                  1. 3

                                                                                                    I have a similar need for a readable string encoding … I started off writing a response in this box but instead it is now a “shorter words list” blog post

                                                                                                    1. 1

                                                                                                      I really liked this blog, thanks for doing it :)

                                                                                              2. 4

                                                                                                This is a very different use case than next cloud.

                                                                                                1. 3

                                                                                                  Is it really so materially different? My use case: I want to send a file to someone [which is too big for email] in as non-technical a way as possible.

                                                                                                  1. 2

                                                                                                    The point of magic wormhole is easily useable e2e encryption. Nextcloud does not have e2e encryption.

                                                                                                    1. 1

                                                                                                      Ignoring the underlying technical details and coming at it from the viewpoint of a user who doesn’t care about security (it’s not part of their use-case spec):

                                                                                                      Wormhole means if I’m on the phone with you, I can transfer a file to you without setting anything up. We both just open the website, I tell you my code, you type it in, I drag in my file (or you drag in yours), done. Neither of us needs to have/sign up for an account or anything.

                                                                                                      (I only glanced at nextcloud but my understanding is you need to set it up. Apologies if that’s not right.)

                                                                                                      1. 1

                                                                                                        I concur that wormhole (web or CLI) serves a slightly different use case. That said, in fairness, Nextcloud allows you to provide single-URL (one-click) access to a file, and recipients don’t need a user account on the NC server. However, it’s true that you do need to install or set up NC on your server (or use a provider).

                                                                                                1. 7

                                                                                                  I recently had to write some JavaScript, and this was my own experience too. I chalk a lot of it up to my own inexperience with the ecosystem, but I also think that there’s a fair amount of accidental complexity. When I use modern JavaScript, with async/await, promises, anonymous functions &c. it feels a lot like it is trying to be a proper dynamic language like Lisp, but it is hindered by its syntax and its legacy.

                                                                                                  Honestly, I would rather write Lisp or even Scheme.

                                                                                                  1. 4

                                                                                                    Honestly, I would rather write Lisp or even Scheme.

                                                                                                    How about clojurescript? That’s a lisp with pretty good support for JS.

                                                                                                    There are a bunch of other lisps that compile to JS, too: https://github.com/jashkenas/coffeescript/wiki/List-of-languages-that-compile-to-JS#lisp-scheme

                                                                                                  1. 4

                                                                                                    For all the shitstorm, I see no actual bug report invalidating results in the open issues. Can anyone please point it out?

                                                                                                    Otherwise it feels all the testards and drive-by team leaders will teach researches better than to open up their code.

                                                                                                    1. 7

                                                                                                      This pretty much matches my impression as well – it’s hard to wonder if any of the people who wrote those “analyses” ever used – let alone wrote – simulation software.

                                                                                                      There’s enough incorrect material in them that writing a rebuttal would be tedious (plus I really ought to stop wasting time on Lobste.rs and get back to work…). But I just want to point out that the rhetoric matches the analysis.

                                                                                                      For example, in this article you see things like:

                                                                                                      “A few people have claimed I don’t understand models, as if Google has no experience with them.”

                                                                                                      unless the author of the article is Google, that’s pretty much irrelevant. Google has hundreds of thousands of employees, I bet quite a few of them don’t understand models. (The author of this article is definitely one of them, by the way).

                                                                                                      Edit: it’s nothing to be ashamed of, at any given moment there’s an infinite amount of things any of us doesn’t understand. But ranting about things one does understand usually gives better results.

                                                                                                      1. 4

                                                                                                        Are you saying that nondeterminism doesn’t matter because the model is supposed to be nondeterministic? Then why are they nevertheless fixing the nondeterminism bugs?

                                                                                                        Do you understand the value of reproducible research, which logically implies making the source code open in this case? Are you aware that Ferguson’s code wasn’t open source for over a decade, and that is part of the problem?

                                                                                                        1. 8

                                                                                                          To answer the nondeterminism part, normally you take a large set of runs and analyze them as a group.

                                                                                                          For example, a monte carlo of a gamma particle tunneling through radiation shielding is inherently non deterministic, however a large number of runs allows you to find the distance necessary for most if not all particles to be stopped safely. Nondeterminism is not an issue if the behaviors involved allow you to derive reproduceable results from the aggregate.

                                                                                                          That said, software bugs like incorrect branching can also be nondeterministic. The degree to how much they affected the simulation is often done through error propagation analysis or comparing the results before and after. Not all bugs are created equal - many can be obviously wrong but not “infect” the results enough to trash them. Still can muddy it tho.

                                                                                                          That’s why yes you fix bugs in nondeterministic models because the model is meant to be the only source of nondeterminism. Bugs have to be reduced out enough to avoid tainting the result set

                                                                                                          1. 3

                                                                                                            To answer the nondeterminism part, normally you take a large set of runs and analyze them as a group.

                                                                                                            If your simulation is meant to be nondeterministic, then good reproduceable science uses a strong PRNG and takes a seed from a configuration. You run it with a fixed set of seeds but can then reproduce the same results by providing the same set of seeds. If it’s not meant to be nondeterministic then it’s a bug and it’s impossible to know its severity without knowing more (but in C++, it can be any kind of undefined behaviour and so the end result can be complete nonsense).

                                                                                                            1. 2

                                                                                                              For example, a monte carlo of a gamma particle tunneling through radiation shielding is inherently non deterministic, however a large number of runs allows you to find the distance necessary for most if not all particles to be stopped safely.

                                                                                                              Sorry if I misunderstand, but surely being careful with when and who is calling your PRNG helps limit this, especially in a single-threaded case?

                                                                                                              Over in game development the issues around non-determinism are a pretty well-known if not always well-solved problem and have been for near two decades, at least.

                                                                                                              1. 8

                                                                                                                (Note: not parent).

                                                                                                                There are processes – I’m not sure if gamma particle tunneling is one of them because solid-state physics isn’t exactly my field, but if I recall things correctly, it is – which are inherently probabilistic. It’s supposed to give different results each time you run it, otherwise it’s not a very useful simulator, and I’m pretty sure I read at least one paper discussing various approaches to getting a useful source of randomness for this sort of software.

                                                                                                                (Edit: there are various ways to cope with this and reconcile the inherent determinism of a machine with the inherent probabilistic character of a physical process, assuming you really do have one that’s probabilistic. It’s not as simple as yeah, we just write simulators that give different results each time you write them.)

                                                                                                                In this particular (i.e. Ferguson’s code) case, the non-determinism (fancy name for a bug. It’s a bug) manifests itself as a constant-ish extra error term – you get curves that have the same shape but don’t coincide exactly, at least not over the duration where the model is likely to give useful results..

                                                                                                                Unfortunately, that’s exactly what you expect to get when doing stochastic process simulation, which is probably is a plausible reason why it wasn’t caught for a long time. This kind of error gets “folded” under the expected variation. That can have two outcomes:

                                                                                                                • If the errors are random, then averaging several runs will indeed cancel them out
                                                                                                                • If the errors are systematic, then averaging several runs will yield an extra (likely time-dependent) error factor, but it’s hard to say if that actually changes the simulation outcome significantly without doing an actual analysis.

                                                                                                                Thing is, the latter case is usually swept under the rug because these models are meant to investigate trends, not exact values. If you look at the two graphs ( https://github.com/mrc-ide/covid-sim/issues/116#issuecomment-617304550 – that’s actually the only substantial example of “non-determinancy” that the article cites), both of them say pretty much the same thing: there’s a period modest, then accelerated growth, that settles for a linear growth after 50-60 days.

                                                                                                                It’s not really relevant if you reach 200,000 deaths in 62 or in 68 days – not because “reproducible outcomes don’t matter” but because there is an inherent expectation that a model that’s supposed to tell you how a flu will spread over 90-150 days in a non-homogenous population of 40,000,000 people is not going to be accurate down to a few days.

                                                                                                                Edit: to clarify – I’m not saying that’s not a bug, it is. But it’s definitely not clear that its impact over the simulation results is enough to invalidate them – in fact, if I were to speculate (which is exactly what the authors of these critical articles do, since they don’t actually run any numbers, either) I’d say they probably don’t. The one bug report shows only two curves, and that’s not even enough to refute the authors’ argument that averaging enough runs will cancel out these errors.

                                                                                                                Edit: also to clarify – what parent comment is saying is, IMHO, completely correct. The only source of non-determinism in the result should be the non-determinism in the model, and bugs that introduce extra error factors should absolutely be fixed. However – and this is the erroneous message that these articles are sending – tainted result sets can still provide valid conclusions. In fact, many result sets from actual, physical measurements – let alone simulations – are tainted, and we still use them to make decisions every day.

                                                                                                            2. 3

                                                                                                              Do you understand the value of reproducible research, which logically implies making the source code open in this case? Are you aware that Ferguson’s code wasn’t open source for over a decade, and that is part of the problem?

                                                                                                              There is a culture problem in academia around this, but it is getting better and more journals are requiring source code with paper submissions.

                                                                                                              In this case, the model has been reproduced by researchers using different Probabilistic Programming Languages (Turing.jl and STAN), which is the bar it needed to reach. Discussion of the implementation quality isn’t really useful or scientifically interesting. It’s the inputs and modelling assumptions that are interesting.

                                                                                                              (Draft?) replication post here: https://turing.ml/dev/posts/2020-05-04-Imperial-Report13-analysis Code for that post is here: https://github.com/cambridge-mlg/Covid19

                                                                                                          2. 4

                                                                                                            There’s coverage from the first link in the submission.

                                                                                                            1. 0

                                                                                                              “Lockdown sceptics”, seriously? “Stay sceptical, but presuppose the conclusion you want to reach and find facts in support of it”?

                                                                                                              1. 6

                                                                                                                That’s neither here nor there, let’s stay on discussion about the issues they’ve found.

                                                                                                                1. -2

                                                                                                                  Yeah, they may have a perfectly good breakdown of issues in the simulation which affects results, I’m not discussing that. I didn’t take the time to read it (and probably won’t; the topic doesn’t interest me that much), and I should’ve been more clear that I’m not saying their findings are invalid. I just thought it was worth pointing out, and probably should be something people keep in mind while reading their review.

                                                                                                          1. 4

                                                                                                            I’m sure it’s all very complicated, but looking at it from the outside, the whole history of DNS seems incredibly politically naive. Domain names are obviously land and ICANN manufactured a whole new rentier sector that needs to do very little work for fairly huge returns (which is bad).

                                                                                                            1. 3

                                                                                                              For someone starting with probabilistic programming, would you recomend Turing.jl or Stan.jl?

                                                                                                              1. 1

                                                                                                                Check out the #probprog channel on the Julia Slack and ask there :)

                                                                                                              1. 17

                                                                                                                I really dislike that part: “Like the Chinese firewall, this European internet would block off services that condone or support unlawful conduct from third party countries.”

                                                                                                                When you’re writing something and it starts with “Like what they do in China”, you can be sure that it will empede individual liberties and promote censorship…

                                                                                                                1. 10

                                                                                                                  I think they are pointing at that it’s technically possible to firewall a large region. I would guess that this is driven by various recent developments:

                                                                                                                  1. The success of US and Chinese internet companies compared to EU counterparts.
                                                                                                                  2. The introduction of the GDPR, which will get more teeth if the EU could actually threaten to block sites that do not comply.
                                                                                                                  3. The rise of Uber & AirBnB. In some EU countries these companies are operating against EU law. To which their reaction is basically shrug, we’ll just compensate drivers/property owners that get a fine.
                                                                                                                  4. The rise of Alibaba, which sells products to EU customers without proper safety certification.

                                                                                                                  Normally, I would be strongly against any kind of internet blockade. But with the disgraceful violations of privacy and pervasive tracking, we (as the EU) should at least consider explore different possibilities to force companies to ‘comply or shutdown’ if they want to do business in the EU but do not want to abide by our privacy laws.

                                                                                                                  1. 3

                                                                                                                    I don’t think they’re arguing for a literal “Chinese firewall” in the EU, but are rather observing that one effect of their firewall is that China has developed its own internal tech, which seems to be working quite well for them. This seems like a valid observation to me, and I think you can separate that effect from others such as the censorship.

                                                                                                                    1. 6

                                                                                                                      Like the Chinese firewall, this European internet would block off services that condone or support unlawful conduct from third party countries.

                                                                                                                      That sounds like they’d like to block e.g. services in the US that don’t respect privacy enough.

                                                                                                                      1. 3

                                                                                                                        I think you can separate that effect from others such as the censorship.

                                                                                                                        I don’t think that this sort of thing would end up in censorship territory (though the EU has certain… interesting opinions on copyright that wouldn’t be great to export), but I think it’s hard to underestimate all the collateral damage this would cause.

                                                                                                                        Imagine you’re travelling to Europe from abroad. Will you even be able to access stuff from your home country? It might get completely isolated because the EU strategy might end up being “Register your presence with us if you want routing here”.

                                                                                                                        It just feels like the sort of thing that would bring the net back many steps in terms of an amazing communication tool.

                                                                                                                        I agree on the EU’s reasonable interest in stopping Uber/AirBnB/Alibaba types. But we already have ways of dealing with this kind of stuff.

                                                                                                                        Examples:

                                                                                                                        • customs can just stop accepting stuff shipped from these kinds of services
                                                                                                                        • EU can pressure payments processors to stop allowing payments to these kinds of services
                                                                                                                        • Airbnb in particular, you could just look at all the listings and bulk fine everyone.
                                                                                                                        • Just DNS filter?

                                                                                                                        “Let’s build out our own infra” (which isn’t really all of the nuance of the PDF) just feels like a solution that’s come up by people wanting to sell a bunch of infra to the EU.

                                                                                                                        1. 3

                                                                                                                          Yeah, that’s reasonable. I’m not so sure what to think about any of this, I never really considered this idea before and don’t feel like I’ve thought about it enough and heard enough opinions about it to really form a good coherent opinion on it.

                                                                                                                          But “it will lead to Chinese censorship” doesn’t strike me as a very good argument.

                                                                                                                      2. 2

                                                                                                                        Lots of praise for WeChat on page 17:

                                                                                                                        WeChat lets users pay for their shopping at vending machines, public transport and the ever-p r esent street vendors. Payment is made easy by using systems such as QR codes or mini-pr o gr a mmes (see Figure 7). Doctor’s appointments can be made through WeChat just as well as job applications. Wh at’s more, WeChat’s operator Tencent Holdings Ltd. has no plans to stop just yet. According to a 2018 press release, WeChat plans to be part of the user’s daily life – from morning to night – with no gaps in between (Sapra, 2019). And they are on the right track to getting there with WeChat events starting to include a virtual ID in their app, used for social security by the Chinese government. In a nutshell, life in China is basically impossible without using WeChat (Sapra, 2019).

                                                                                                                        At attempt at a joke: One wonders if WeChat server locations are listed as a target option in the surely super secret New SIOP.

                                                                                                                      1. 25

                                                                                                                        There’s a very interesting pattern whenever UX comes up on Emacs lists - rms desperately wants someone to turn Emacs into a word processor (and better faces is part of that), but the developer and userbase of programmers are puzzled and have no idea what he means or wants from it. Someone half-listening occasionally suggests org, but rms somehow doesn’t know what it is - and it’s probably not what he wants anyways,

                                                                                                                        Also, it’s hilarious how many improvements to Emacs, be it trivial icon or major C major mode improvements, are blocked by bizarre and ideological interpretations of of the GPL. No small wonder why no one wants to come over to Emacs.

                                                                                                                        1. 7

                                                                                                                          Laying my biases out here, I’ve been an Emacsish user for more than 30 years, but I think that the various licensing machinations of GNU Emacs are probably not the primary reason people don’t want to use Emacs.

                                                                                                                          1. 14

                                                                                                                            I think the implication was that the licensing machinations cause many of the issues that actually keep people away, not that the licensing machinations directly keep people away.

                                                                                                                            1. 2

                                                                                                                              t as well as in any other application, and the traditional foot pedal, and other clever solutions like god-mode,

                                                                                                                              More blocks the resolution for the issues that keep people away, but same energy.

                                                                                                                            2. 8

                                                                                                                              The primary reason is probably that most humans have only five digits per hand, whereas Emacs is clearly designed for octopus.

                                                                                                                              1. 3

                                                                                                                                Ignoring the fact that you can use the mouse just as well as in any other application, and the traditional foot pedal, and other clever solutions like god-mode, which makes the default Emacs key binds modal, and evil-mode, which makes them the same as in vi. And did I mention you can just use the mouse?

                                                                                                                                1. 7

                                                                                                                                  My comment is light-hearted, perhaps yours is too :)

                                                                                                                            3. 4

                                                                                                                              I agree, I’ve seen RMS comment something to this effect multiple times. Odd that he doesn’t seem to want to put in effort to understand org mode. I think it could be close to what he wants. This post shows a very nice-looking, nearly WYSIWYG setup: https://lepisma.xyz/2017/10/28/ricing-org-mode/

                                                                                                                            1. 0

                                                                                                                              As far as I can tell, this is neither public or well documented, which makes it rather unattractive to explore.

                                                                                                                              1. 3

                                                                                                                                Some source code is public on a cgit instance. There are manuals, but more interesting to me are the example VM specifications.

                                                                                                                                1. 0

                                                                                                                                  Sure, but it’s explicitly mentioned that that’s a snapshot and the actual repo is private.

                                                                                                                                  1. 3

                                                                                                                                    It was a snapshot in 2017, but it looks like it is open now:

                                                                                                                                    The source code is hosted on my own git server, available to anybody via HTTP. Please contact me if you have some reason to require SSH access. I am now back to using the master branch on git, with short-lived feature branches.

                                                                                                                              1. 23

                                                                                                                                One can no more dissuade a visionary of this kind than one can dissuade a member of the Fabian Society from the virtues of global humanitarian government, but then neither will the vox populi of provincial yokels be of any use in countering it. One can only stoically resign to the pull of inexorable necessity.

                                                                                                                                With the help of an Internet search query or two, and a good deal of re-reading, I could probably figure out what this means. But I am le tired. And I haven’t even gotten through the first chapter.

                                                                                                                                This brings up a different controversy: Is writing like this useful to stretch peoples minds, help them grow? Or does it just discourage people and make them feel dumb? Is writing a form of art, or a means of communication, or both?

                                                                                                                                From my perspective, it looks more focused on artistry than actually communicating and transferring knowledge. Which isn’t necessarily a bad thing.

                                                                                                                                1. 22

                                                                                                                                  It’s called “purple prose”.

                                                                                                                                  1. 2

                                                                                                                                    That’s exactly what I was referring to, TIL.

                                                                                                                                  2. 9

                                                                                                                                    From my perspective, it looks more focused on artistry than actually communicating and transferring knowledge.

                                                                                                                                    Your perspective may change if you finish reading the document before dashing off to post a comment about the style instead of the substance of the source material. :)

                                                                                                                                    It goes on to give a lot of historical context on previous attempts and on systems issues.

                                                                                                                                    1. 8

                                                                                                                                      That’s the point though - I’d happily read the whole thing, if I had the mental capacity to do so. I’m sure there’s plenty of good info in there, but it’s buried under so much prose that I feel like I need a college degree to begin understanding it.

                                                                                                                                      1. 4

                                                                                                                                        The point that you mentioned is a local maximum in terms of hard-to-read prose, and (from my reading up to section 2.3) I believe it is a global maximum too - the text is much nicer almost from that passage onward and I only found one other spot that I believe to be particularly egregious. I encourage you to keep going! I very much dislike the Unix culture and tooling in general, but found this article to be fascinating anyway.

                                                                                                                                        1. 1

                                                                                                                                          I sampled towards the end and found the prose similarly tiresome.

                                                                                                                                        2. 3

                                                                                                                                          Not every reader is native English speaker (and reader). Reading this style is very demanding and makes it harder to focus on the main topic. I have no idea if there are expressions hidden that I don’t know yet, or if a reference in the text is key to the final point.

                                                                                                                                        3. 9

                                                                                                                                          You make the mistake of implying that there’s an objective way to communicate clearly and it’s not instead dependent on the listeners.

                                                                                                                                          Most tech documentations, even when assuming no previous knowledge from the reader, would be unreadable for most people for the sole reason of their structure and dryness.

                                                                                                                                          You’re witnessing something written by a person that is on the boundary between different worlds and can merge them into a single piece of writing and this confuses you. It’s normal and probably the author did it deliberately.

                                                                                                                                          Lot of us programmers on the left are keen in rupturing the cultural and social bubble in which the tech sector is entrenched and I wouldn’t be surprised if the author wrote the piece in this way to deliberately challenge the stylistic elements of engineer-oriented writing.

                                                                                                                                          1. 7

                                                                                                                                            I agree, but I think it’s just interesting that the author seems to have raised the educational bar, not lowered it. Now you have to be an engineer AND a literary genius to understand what’s being written.

                                                                                                                                            And I’m not saying this is necessarily a bad thing. I’m just noting that it’s unapproachable for people like me. I’m sure after a bit more education and time, I’ll appreciate it too.

                                                                                                                                            1. 13

                                                                                                                                              You don’t have to be a genius to understand that paragraph, just literate. I understood it just fine and the highest formal education I’ve received is community college.

                                                                                                                                              Anyone who works in software is accustomed to googling tech jargon they’re unfamiliar with and learning as they go. I think it is interesting that you balk at doing this in a humanities context and perhaps that was the point.

                                                                                                                                              1. 4

                                                                                                                                                I think you hit the nail on the head. It sounds to me like you’ve put in the hard work to understand and appreciate this kind of writing, and that is truly awesome (no sarcasm there). For me, I could totally figure this out, no doubt about it. But it would still be quite the slog, because I haven’t invested quite as much hard work as you have into the humanities yet. And that’s ok.

                                                                                                                                                That’s why I say this “isn’t necessarily a bad thing.” I could use some more development in my humanities skills! But if the goal is to communicate ideas, then writing like this will only communicate ideas to a gifted few who are good at both engineering and humanities. Again: Not necessarily a bad thing.

                                                                                                                                              2. 1

                                                                                                                                                If you want to start from somewhere, I suggest you read Geek Sublime from Vikhram Chandra. He’s both a programmer and a novelist.

                                                                                                                                              3. 1

                                                                                                                                                Lot of us programmers on the left are keen in rupturing the cultural and social bubble in which the tech sector is entrenched

                                                                                                                                                And yet you at the same time alienate readers who’ve never studied literature in English, nor English literature. More often than not from second and third world countries.

                                                                                                                                                1. 6

                                                                                                                                                  We write in different ways to reach different audiences in different ways. I never said everything should be written this way. There’s a growing idea of writing more propaganda disguised as tech opinion pieces using a language that programmers like. I mean, the far-right has been doing that for three decades now, it’s time for the left to react.

                                                                                                                                                  The “poking” at the bubble is complementary and clearly doesn’t aim at reaching the masses, but just at bringing out those that have the potential to connect with those readings.

                                                                                                                                                  Also I’m not American, I’m not an English native speaker and in “second and third world countries” humanities are usually valued a lot more than in the protestant anglosphere, so I don’t get your point.

                                                                                                                                              4. 8

                                                                                                                                                This is the “English (Literary)” locale where it is assumed you know your leftist lore (and French philosophy). Not my thing but sometimes the references lead to interesting wikipedia pages.

                                                                                                                                                1. 11

                                                                                                                                                  This brings up a different controversy: Is writing like this useful to stretch peoples minds, help them grow? Or does it just discourage people and make them feel dumb? Is writing a form of art, or a means of communication, or both?

                                                                                                                                                  When I was younger I thought that impressing people with my vocabulary is the utmost purpose of my writing, but as years have gone on I have realized that this is just mental peacocking (to use a friendly term). The real greatness is to convey information (or even humor) using simple language while staying informative and engaging. I have been way more impressed with authors being able to write like this than people who just show they own a thesaurus.

                                                                                                                                                  1. 6

                                                                                                                                                    This brings up a different controversy: Is writing like this useful to stretch peoples minds, help them grow? Or does it just discourage people and make them feel dumb? Is writing a form of art, or a means of communication, or both?

                                                                                                                                                    I would argue the former. You’ve learned a little more about the world by virtue of looking up a literary or cultural reference you didn’t previously understand. I’ve done this with plenty of texts I’ve read, in English and particularly in other languages (English is my cradletongue). Of course you weren’t obligated to do so - you could’ve decided that this article about systemd written using these kinds of literary references wasn’t worth your time to understand, and if enough people thought similarly, it would lose a substantial portion of its potential audience. But using literary and cultural references is something that writers and speakers do in pretty much every genre of human communication; and it’s only because this author happened to choose ones that you were unfamiliar with, that you found it something worth remarking on.

                                                                                                                                                    1. 3

                                                                                                                                                      I found it really funny. To me, that kind of descriptiveness adds humor, but maybe I’m the only one? Like putting an eccentric accent on a movie character.

                                                                                                                                                      1. 1

                                                                                                                                                        i found it pretty funny too :)

                                                                                                                                                      2. 2

                                                                                                                                                        I think the article would be much longer if it wasn’t for the use of various literary devices for compression.

                                                                                                                                                        Maybe that would be for the better as more people would benefit from reading it.

                                                                                                                                                        On the other hand, it’s useful to have someone shine a light on gaps in your knowledge of things which used to be well known. Certainly I don’t think that a lot of the things referred to in the writing should be particularly exotic, yet sadly they are.

                                                                                                                                                        Finally, I personally get some enjoyment from reading things like these. It’s the kind of enjoyment I get from reading old books. Difficult to read but full of very interesting ideas.

                                                                                                                                                        1. 2

                                                                                                                                                          Is writing like this useful to stretch peoples minds

                                                                                                                                                          While I do not particularly like the style of this text, I appreciate any kind of writing style that does not resemble the current “ted-talk” style uncultured vomit that is becoming the style of almost everybody today.

                                                                                                                                                          1. 2

                                                                                                                                                            I”m less offended by the use of some obscure terms and references than by the implicit comparison of a Gnome maintainer to a follower of Stalin:

                                                                                                                                                            And if we are to take the “revolution OS” metaphor further, then Bassi’s position is not unlike Stalin’s defense of the need of a vanguard party in The Foundations of Leninism (1924), with those opposed consequently in the role of Trotskyites, Zinovievites and ultra-leftists: “The theory of worshipping spontaneity is decidedly opposed to giving the spontaneous movement a politically conscious, planned character. It is opposed to the Party marching at the head of the working class, to the Party raising the masses to the level of political consciousness, to the Party leading the movement; it is in favour of the politically conscious elements of the movement not hindering the movement from taking its own course; it is in favour of the Party only heeding the spontaneous movement and dragging at the tail of it.”

                                                                                                                                                            1. 2

                                                                                                                                                              Arguably, in many historical cases, such ways of expression were used to hide the real meaning, a sort of emphemization. It was especially used when it came to criticizing a point of view, to filter out as many people as possible to not bear the consequences of saying clearly what you intended to say. The more fluff and ambiguity the more you can hide behind it.

                                                                                                                                                              EDIT as this comment says, it’s called “purple prose”.

                                                                                                                                                              1. 1

                                                                                                                                                                FWIW, here’s my translation:

                                                                                                                                                                You can’t dissuade visionaries like this, and the popular bloggers won’t help you counter them either. All you can do is give in [and use the visionaries’ stuff?]

                                                                                                                                                                Without the context of the surrounding paras I don’t really know what they were getting at.

                                                                                                                                                                I think people write like this because it’s fun for the writer, not necessarily for the reader ;)

                                                                                                                                                                Edit: the context is:

                                                                                                                                                                • The Fabian Society is a British internationalist lefty think tank. Because they’re internationalist and lefty (but not anarchists), they’d probably really like a global humanitarian government.

                                                                                                                                                                • “vox populi” is latin for “voice of the people” and sometimes means the “opinion of the people”, but that bit is a bit clumsy anyway.